#!/usr/bin/python3 -i # # Copyright (c) 2015-2025 The Khronos Group Inc. # Copyright (c) 2015-2025 Valve Corporation # Copyright (c) 2015-2025 LunarG, Inc. # Copyright (c) 2015-2025 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. import sys import os from vulkan_object import Member from base_generator import BaseGenerator from generators.generator_utils import PlatformGuardHelper # 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: # Returns the list of validation layers for the target API @staticmethod def getValidationLayerList(targetApiName: str) -> list[dict[str, str]]: match targetApiName: # Vulkan specific validation layer list case 'vulkan': return [ { 'include': 'thread_tracker/thread_safety_validation.h', 'device': 'threadsafety::Device', 'instance': 'threadsafety::Instance', 'type': 'LayerObjectTypeThreading', 'enabled': '!settings.disabled[thread_safety]' }, { 'include': 'stateless/stateless_validation.h', 'device': 'stateless::Device', 'instance': 'stateless::Instance', 'type': 'LayerObjectTypeParameterValidation', 'enabled': '!settings.disabled[stateless_checks]' }, { 'include': 'object_tracker/object_lifetime_validation.h', 'device': 'object_lifetimes::Device', 'instance': 'object_lifetimes::Instance', 'type': 'LayerObjectTypeObjectTracker', 'enabled': '!settings.disabled[object_tracking]' }, { 'include': 'state_tracker/state_tracker.h', 'device': 'vvl::DeviceState', 'instance': 'vvl::InstanceState', 'type': 'LayerObjectTypeStateTracker', 'enabled': ''' !settings.disabled[core_checks] || settings.enabled[best_practices] || settings.enabled[gpu_validation] || settings.enabled[debug_printf_validation] || settings.enabled[sync_validation] ''' }, { 'include': 'core_checks/core_validation.h', 'device': 'CoreChecks', 'instance': 'core::Instance', 'type': 'LayerObjectTypeCoreValidation', 'enabled': '!settings.disabled[core_checks]' }, { 'include': 'best_practices/best_practices_validation.h', 'device': 'BestPractices', 'instance': 'bp_state::Instance', 'type': 'LayerObjectTypeBestPractices', 'enabled': 'settings.enabled[best_practices]' }, { 'include': 'gpuav/core/gpuav.h', 'device': 'gpuav::Validator', 'instance': 'gpuav::Instance', 'type': 'LayerObjectTypeGpuAssisted', 'enabled': 'settings.enabled[gpu_validation] || settings.enabled[debug_printf_validation]' }, { 'include': 'sync/sync_validation.h', 'device': 'SyncValidator', 'instance': 'syncval::Instance', 'type': 'LayerObjectTypeSyncValidation', 'enabled': 'settings.enabled[sync_validation]' } ] class DispatchObjectGenerator(BaseGenerator): def __init__(self): BaseGenerator.__init__(self) # Commands which are not autogenerated but still intercepted self.no_autogen_list = ( 'vkCreateInstance', 'vkDestroyInstance', 'vkCreateDevice', 'vkDestroyDevice', # Need to handle Acquired swapchain image handles 'vkGetSwapchainImagesKHR', 'vkDestroySwapchainKHR', # Have issues with generating logic to work correctly with Safe Struct 'vkQueuePresentKHR', 'vkCreateGraphicsPipelines', 'vkCreateComputePipelines', 'vkCreateRayTracingPipelinesNV', 'vkCreateRayTracingPipelinesKHR', # Need to only wrap on certain cases 'vkCreateShadersEXT', # Need handle which pool descriptors were allocated from 'vkResetDescriptorPool', 'vkDestroyDescriptorPool', 'vkAllocateDescriptorSets', 'vkFreeDescriptorSets', 'vkCreateDescriptorUpdateTemplate', 'vkCreateDescriptorUpdateTemplateKHR', 'vkDestroyDescriptorUpdateTemplate', 'vkDestroyDescriptorUpdateTemplateKHR', 'vkUpdateDescriptorSetWithTemplate', 'vkUpdateDescriptorSetWithTemplateKHR', 'vkCmdPushDescriptorSetWithTemplate', 'vkCmdPushDescriptorSetWithTemplateKHR', 'vkCmdPushDescriptorSetWithTemplate2', 'vkCmdPushDescriptorSetWithTemplate2KHR', # Tracking renderpass state for the pipeline safe struct 'vkCreateRenderPass', 'vkCreateRenderPass2KHR', 'vkCreateRenderPass2', 'vkDestroyRenderPass', # Accesses to the map itself are internally synchronized. 'vkDebugMarkerSetObjectTagEXT', 'vkDebugMarkerSetObjectNameEXT', 'vkSetDebugUtilsObjectNameEXT', 'vkSetDebugUtilsObjectTagEXT', # TODO - These have no manual source, but we still produce the headers 'vkEnumerateInstanceExtensionProperties', 'vkEnumerateInstanceLayerProperties', 'vkEnumerateDeviceLayerProperties', 'vkEnumerateInstanceVersion', # Manually track pToolCount 'vkGetPhysicalDeviceToolProperties', 'vkGetPhysicalDeviceToolPropertiesEXT', # Track deferred operations 'vkDeferredOperationJoinKHR', 'vkGetDeferredOperationResultKHR', # Need to deal with VkAccelerationStructureGeometryKHR 'vkBuildAccelerationStructuresKHR', 'vkGetAccelerationStructureBuildSizesKHR', 'vkCmdBuildAccelerationStructuresKHR', # Depends on the VkDescriptorType to pick the union pointer 'vkGetDescriptorEXT', # Depends on the VkIndirectExecutionSetInfoTypeEXT to pick the union pointer 'vkCreateIndirectExecutionSetEXT', # Special destroy call from the Acquire 'vkReleasePerformanceConfigurationINTEL', # need to call CopyExportMetalObjects 'vkExportMetalObjectsEXT', # These are for special-casing the pInheritanceInfo issue (must be ignored for primary CBs) 'vkAllocateCommandBuffers', 'vkFreeCommandBuffers', 'vkDestroyCommandPool', 'vkBeginCommandBuffer', # Currently we don't properly generate a Wrap and will accidently unwrap the VkDisplayKHR handle 'vkGetPhysicalDeviceDisplayPropertiesKHR', 'vkGetPhysicalDeviceDisplayProperties2KHR', 'vkGetPhysicalDeviceDisplayPlanePropertiesKHR', 'vkGetPhysicalDeviceDisplayPlaneProperties2KHR', 'vkGetDisplayModePropertiesKHR', 'vkGetDisplayModeProperties2KHR', 'vkGetDisplayPlaneSupportedDisplaysKHR', # Need to handle binaries in VkPipelineBinaryHandlesInfoKHR as output, not input. 'vkCreatePipelineBinariesKHR', 'vkGetPipelineKeyKHR', # Need to handle VkBindMemoryStatus 'vkBindBufferMemory2', 'vkBindBufferMemory2KHR', 'vkBindImageMemory2', 'vkBindImageMemory2KHR', ) # List of all extension structs strings containing handles self.ndo_extension_structs = [ # These are added manually because vkGetPipelineKeyKHR needs to unwrap these (see VUID 09604) "VkComputePipelineCreateInfo", "VkGraphicsPipelineCreateInfo", "VkRayTracingPipelineCreateInfoKHR", "VkExecutionGraphPipelineCreateInfoAMDX", ] self.extended_query_exts = ( 'VK_KHR_get_physical_device_properties2', 'VK_KHR_external_semaphore_capabilities', 'VK_KHR_external_fence_capabilities', 'VK_KHR_external_memory_capabilities', 'VK_KHR_get_memory_requirements2', ) # Dispatch functions that need special state tracking variables passed in self.custom_definition = {} def isNonDispatchable(self, name: str) -> bool: return name in self.vk.handles and not self.vk.handles[name].dispatchable def containsNonDispatchableObject(self, structName: str) -> bool: struct = self.vk.structs[structName] for member in struct.members: if self.isNonDispatchable(member.type): return True # recurse for member structs, guard against infinite recursion elif member.type in self.vk.structs and member.type != struct.name: if self.containsNonDispatchableObject(member.type): return True return False # Now that the data is all collected and complete, generate and output the wrapping/unwrapping routines def generate(self): self.write(f'''// *** THIS FILE IS GENERATED - DO NOT EDIT *** // See {os.path.basename(__file__)} for modifications /*************************************************************************** * * Copyright (c) 2015-2025 The Khronos Group Inc. * Copyright (c) 2015-2025 Valve Corporation * Copyright (c) 2015-2025 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. ****************************************************************************/\n''') self.write('// NOLINTBEGIN') # Wrap for clang-tidy to ignore if self.filename == 'dispatch_object_instance_methods.h': self.generateInstanceMethods() elif self.filename == 'dispatch_object_device_methods.h': self.generateDeviceMethods() elif self.filename == 'dispatch_functions.h': self.generateFunctions() elif self.filename == 'dispatch_object.cpp': self.generateSource() else: self.write(f'\nFile name {self.filename} has no code to generate\n') self.write('// NOLINTEND') # Wrap for clang-tidy to ignore def generateMethods(self, want_instance): out = [] guard_helper = PlatformGuardHelper() for command in [x for x in self.vk.commands.values() if x.instance == want_instance]: prototype = command.cPrototype prototype = prototype.replace('VKAPI_ATTR ', '') prototype = prototype.replace('VKAPI_CALL vk', '') if command.name in self.custom_definition: prototype = prototype.replace(');', f'{self.custom_definition[command.name]});') out.extend(guard_helper.add_guard(command.protect)) out.append(f'{prototype}\n') out.extend(guard_helper.add_guard(None)) self.write("".join(out)) def generateDeviceMethods(self): out = [] out.append(''' // This file contains methods for class vvl::dispatch::Device and it is designed to ONLY be // included into dispatch_object.h. #pragma once ''') self.write("".join(out)) self.generateMethods(False) def generateInstanceMethods(self): out = [] out.append(''' // This file contains methods for class vvl::dispatch::Instance and it is designed to ONLY be // included into dispatch_object.h. #pragma once ''') self.write("".join(out)) self.generateMethods(True) def generateFunctions(self): out = [] out.append(''' // This file contains contains convience functions for non-chassis code that needs to // make vulkan calls. #pragma once #include "chassis/dispatch_object.h" ''') dispatchable_handles = [handle.name for handle in self.vk.handles.values() if handle.dispatchable] guard_helper = PlatformGuardHelper() for command in self.vk.commands.values(): # Weed out weird commands like vkCreateInstance() if command.params[0].type not in dispatchable_handles: continue prototype = command.cPrototype prototype = prototype.replace('VKAPI_ATTR ', 'static inline ') prototype = prototype.replace('VKAPI_CALL vk', 'Dispatch') proto_extra = '' call_extra = '' if command.name in self.custom_definition: proto_extra = self.custom_definition[command.name] call_extra = ', ' + proto_extra.split(' ')[-1] prototype = prototype.replace(');', f'{proto_extra}) {{') out.extend(guard_helper.add_guard(command.protect)) out.append(f'\n{prototype}\n') out.append(f'auto dispatch = vvl::dispatch::GetData({command.params[0].name});\n') returnResult = 'return ' if (command.returnType != 'void') else '' paramsList = ', '.join([param.name for param in command.params]) out.append(f'{returnResult}{command.name.replace("vk", "dispatch->")}({paramsList}{call_extra});\n') out.append('}\n') out.extend(guard_helper.add_guard(None)) out.append('// We make many internal dispatch calls to extended query functions which can depend on the API version\n') for extended_query_ext in self.extended_query_exts: for command in self.vk.extensions[extended_query_ext].commands: parameters = (command.cPrototype.split('(')[1])[:-2] # leaves just the parameters arguments = ','.join([x.name for x in command.params]) out.append(f''' static inline {command.returnType} Dispatch{command.alias[2:]}Helper(APIVersion api_version, {parameters}) {{ if (api_version >= VK_API_VERSION_1_1) {{ return Dispatch{command.alias[2:]}({arguments}); }} else {{ return Dispatch{command.name[2:]}({arguments}); }} }} ''') self.write("".join(out)) def generateSource(self): # Construct list of extension structs containing handles # Generate the list of APIs that might need to handle wrapped extension structs for struct in [x for x in self.vk.structs.values() if x.sType and x.extendedBy]: for extendedStruct in struct.extendedBy: if self.containsNonDispatchableObject(extendedStruct) and extendedStruct not in self.ndo_extension_structs: self.ndo_extension_structs.append(extendedStruct) out = [] out.append(''' #include "chassis/dispatch_object.h" #include "utils/cast_utils.h" #include #include "state_tracker/pipeline_state.h" #include "containers/custom_containers.h" ''') for layer in APISpecific.getValidationLayerList(self.targetApiName): include_file = layer['include'] out.append(f'#include "{include_file}"\n') out.append('\n') out.append(''' #define DISPATCH_MAX_STACK_ALLOCATIONS 32 namespace vvl { namespace dispatch { void Instance::InitValidationObjects() { // Note that this DEFINES THE ORDER IN WHICH THE LAYER VALIDATION OBJECTS ARE CALLED ''') for layer in APISpecific.getValidationLayerList(self.targetApiName): classname = layer['instance'] out.append(f''' if ({layer["enabled"]}) {{ object_dispatch.emplace_back(new {classname}(this)); }}''') out.append('\n') out.append('}\n') out.append(''' void Device::InitValidationObjects() { // Note that this DEFINES THE ORDER IN WHICH THE LAYER VALIDATION OBJECTS ARE CALLED ''') for layer in APISpecific.getValidationLayerList(self.targetApiName): classname = layer['device'] layer_type = layer['type'] instance = layer['instance'] instance_arg = f'static_cast<{instance}*>(dispatch_instance->GetValidationObject({layer_type}))' out.append(f''' if ({layer["enabled"]}) {{ object_dispatch.emplace_back(new {classname}(this, {instance_arg})); }}''') out.append('\n') out.append('}\n') out.append(''' // Unique Objects pNext extension handling function void HandleWrapper::UnwrapPnextChainHandles(const void *pNext) { void *cur_pnext = const_cast(pNext); while (cur_pnext != nullptr) { VkBaseOutStructure *header = reinterpret_cast(cur_pnext); switch (header->sType) { ''') guard_helper = PlatformGuardHelper() for struct in [self.vk.structs[x] for x in self.ndo_extension_structs]: (api_decls, api_pre, api_post) = self.uniquifyMembers(struct.members, 'safe_struct->', 0, False, False, False) # Only process extension structs containing handles if not api_pre: continue safe_name = 'vku::safe_' + struct.name out.extend(guard_helper.add_guard(struct.protect)) out.append(f'case {struct.sType}: {{\n') out.append(f' auto *safe_struct = reinterpret_cast<{safe_name} *>(cur_pnext);\n') out.append(api_pre) out.append('} break;\n') out.extend(guard_helper.add_guard(None)) out.append(''' default: break; } // Process the next structure in the chain cur_pnext = header->pNext; } } ''') out.append(''' [[maybe_unused]] static bool NotDispatchableHandle(VkObjectType object_type) { switch(object_type) { ''') out.extend([f'case {handle.type}:\n' for handle in self.vk.handles.values() if handle.dispatchable]) out.append('''return false; default: return true; } } ''') for command in [x for x in self.vk.commands.values() if x.name not in self.no_autogen_list]: out.extend(guard_helper.add_guard(command.protect)) # Generate NDO wrapping/unwrapping code for all parameters isCreate = any(x in command.name for x in [ 'vkCreate', 'vkAllocate', # Create a VkFence object 'vkRegisterDeviceEvent', 'vkRegisterDisplayEvent', # Create VkPerformanceConfigurationINTEL object 'vkAcquirePerformanceConfigurationINTEL', # Special calls that we wrap because they are created statically on the driver, but users query for them 'vkGetWinrtDisplayNV', 'vkGetRandROutputDisplayEXT', 'vkGetDrmDisplayEXT', ]) isDestroy = any(x in command.name for x in ['vkDestroy', 'vkFree']) # Handle ndo create/allocate operations create_ndo_code = '' if isCreate: lastParam = command.params[-1] handle_type = lastParam.type if self.isNonDispatchable(handle_type): # Check for special case where multiple handles are returned wrap_call = 'WrapNew' if handle_type != 'VkDisplayKHR' else 'MaybeWrapDisplay' ndo_array = lastParam.length is not None create_ndo_code += 'if (result == VK_SUCCESS) {\n' ndo_dest = f'*{lastParam.name}' if ndo_array: create_ndo_code += f'for (uint32_t index0 = 0; index0 < {lastParam.length}; index0++) {{\n' ndo_dest = f'{lastParam.name}[index0]' create_ndo_code += f'{ndo_dest} = {wrap_call}({ndo_dest});\n' if ndo_array: create_ndo_code += '}\n' create_ndo_code += '}\n' # Handle ndo destroy/free operations destroy_ndo_code = '' if isDestroy: param = command.params[-2] # Last param is always VkAllocationCallbacks if self.isNonDispatchable(param.type): # Remove a single handle from the map destroy_ndo_code += f'{param.name} = Erase({param.name});' (api_decls, api_pre, api_post) = self.uniquifyMembers(command.params, '', 0, isCreate, isDestroy, True) api_post += create_ndo_code if isDestroy: api_pre += destroy_ndo_code elif api_pre: api_pre = f'{{\n{api_pre}}}\n' # If API doesn't contain NDO's, we still need to make a down-chain call down_chain_call_only = False if not api_decls and not api_pre and not api_post: down_chain_call_only = True prototype = command.cPrototype[:-1] prototype = prototype.replace('VKAPI_ATTR ', '') prototype = prototype.replace('VKAPI_CALL vk', 'Instance::' if command.instance else 'Device::') out.append(f'\n{prototype} {{\n')\ # Pull out the text for each of the parameters, separate them by commas in a list paramstext = ', '.join([param.name for param in command.params]) wrapped_paramstext = paramstext # If any of these paramters has been replaced by a local var, fix up the list for param in command.params: struct = self.vk.structs[param.type] if param.type in self.vk.structs else None isLocal = (self.isNonDispatchable(param.type) and param.length and param.const) or (struct and self.containsNonDispatchableObject(struct.name)) isExtended = struct and struct.extendedBy and any(x in self.ndo_extension_structs for x in struct.extendedBy) if isLocal or isExtended: if param.pointer: if param.const: wrapped_paramstext = wrapped_paramstext.replace(param.name, f'(const {param.type}*)local_{param.name}') else: wrapped_paramstext = wrapped_paramstext.replace(param.name, f'({param.type}*)local_{param.name}') else: wrapped_paramstext = wrapped_paramstext.replace(param.name, f'(const {param.type})local_{param.name}') # First, add check and down-chain call. Use correct dispatch table dispatch_table = 'instance_dispatch_table' if command.instance else 'device_dispatch_table' # Put all this together for the final down-chain call if not down_chain_call_only: out.append(f'if (!wrap_handles) return {dispatch_table}.{command.name[2:]}({paramstext});\n') # Handle return values, if any assignResult = f'{command.returnType} result = ' if command.returnType != 'void' else '' # Pre-pend declarations and pre-api-call codegen if api_decls: out.append("\n".join(str(api_decls).rstrip().split("\n"))) if api_pre: out.append("\n".join(str(api_pre).rstrip().split("\n"))) out.append('\n') # Generate the wrapped dispatch call out.append(f'{assignResult}{dispatch_table}.{command.name[2:]}({wrapped_paramstext});\n') out.append("\n".join(str(api_post).rstrip().split("\n"))) out.append('\n') # Handle the return result variable, if any if assignResult != '': out.append('return result;\n') out.append('}\n') out.extend(guard_helper.add_guard(None)) out.append('} // namespace dispatch\n') out.append('} // namespace vvl\n') self.write("".join(out)) # # Clean up local declarations def cleanUpLocalDeclarations(self, prefix, name, len, deferred_name): cleanup = '' if deferred_name is not None: delete_var = f'local_{prefix}{name}' if len is None: delete_code = f'delete {delete_var}' else: delete_code = f'delete[] {delete_var}' cleanup = f'if ({delete_var}) {{\n' cleanup += f''' // Fix check for deferred ray tracing pipeline creation // https://github.com/KhronosGroup/Vulkan-ValidationLayers/issues/5817 const bool is_operation_deferred = ({deferred_name} != VK_NULL_HANDLE) && (result == VK_OPERATION_DEFERRED_KHR); if (is_operation_deferred) {{ std::vector> cleanup{{[{delete_var}](){{ {delete_code}; }}}}; deferred_operation_post_completion.insert({deferred_name}, cleanup); }} else {{ {delete_code}; }}''' cleanup += '}\n' return cleanup # # topLevel indicates if elements are passed directly into the function else they're below a ptr/struct # isCreate means that this is API creates or allocates NDOs # isDestroy indicates that this API destroys or frees NDOs def uniquifyMembers(self, members: list[Member], prefix: str, arrayIndex: int, isCreate: bool, isDestroy: bool, topLevel: bool): decls = '' pre_code = '' post_code = '' index = f'index{str(arrayIndex)}' arrayIndex += 1 # Process any NDOs in this structure and recurse for any sub-structs in this struct for member in members: # Handle NDOs if self.isNonDispatchable(member.type): count_name = member.length if (count_name is not None) and not topLevel: count_name = f'{prefix}{member.length}' if (not topLevel) or (not isCreate) or (not member.pointer): if count_name is not None: if topLevel: decls += f'small_vector<{member.type}, DISPATCH_MAX_STACK_ALLOCATIONS> var_local_{prefix}{member.name};\n' decls += f'{member.type} *local_{prefix}{member.name} = nullptr;\n' pre_code += f' if ({prefix}{member.name}) {{\n' if topLevel: pre_code += f''' var_local_{prefix}{member.name}.resize({count_name}); local_{prefix}{member.name} = var_local_{prefix}{member.name}.data(); for (uint32_t {index} = 0; {index} < {count_name}; ++{index}) {{ local_{prefix}{member.name}[{index}] = Unwrap({member.name}[{index}]);''' else: pre_code += f''' for (uint32_t {index} = 0; {index} < {count_name}; ++{index}) {{ {prefix}{member.name}[{index}] = Unwrap({prefix}{member.name}[{index}]);''' pre_code += '}\n' pre_code += '}\n' else: if topLevel: if not isDestroy: pre_code += f'{member.name} = Unwrap({member.name});\n' else: # Make temp copy of this var with the 'local' removed. It may be better to not pass in 'local_' # as part of the string and explicitly print it fix = str(prefix).strip('local_') pre_code += f''' if ({fix}{member.name}) {{ {prefix}{member.name} = Unwrap({fix}{member.name}); }}''' # Handle Structs that contain NDOs at some level elif member.type in self.vk.structs: struct = self.vk.structs[member.type] process_pnext = struct.extendedBy and any(x in self.ndo_extension_structs for x in struct.extendedBy) # Structs at first level will have an NDO, OR, we need a safe_struct for the pnext chain if self.containsNonDispatchableObject(member.type) or process_pnext: safe_type = 'vku::safe_' + member.type if any(x.pointer for x in struct.members) else member.type # Struct Array if member.length is not None: # Check if this function can be deferred. deferred_name = next((x.name for x in members if x.type == 'VkDeferredOperationKHR'), None) # Update struct prefix if topLevel: new_prefix = f'local_{member.name}' # Declare vku::safe_VkVarType for struct if not deferred_name: decls += f'small_vector<{safe_type}, DISPATCH_MAX_STACK_ALLOCATIONS> var_{new_prefix};\n' decls += f'{safe_type} *{new_prefix} = nullptr;\n' else: new_prefix = f'{prefix}{member.name}' pre_code += f'if ({prefix}{member.name}) {{\n' if topLevel: if deferred_name: pre_code += f'{new_prefix} = new {safe_type}[{member.length}];\n' else: pre_code += f'var_{new_prefix}.resize({member.length});\n' pre_code += f'{new_prefix} = var_{new_prefix}.data();\n' pre_code += f'for (uint32_t {index} = 0; {index} < {prefix}{member.length}; ++{index}) {{\n' if topLevel: if safe_type.startswith('vku::safe'): # Handle special initialize function for VkAccelerationStructureBuildGeometryInfoKHR if member.type == "VkAccelerationStructureBuildGeometryInfoKHR": pre_code += f'{new_prefix}[{index}].initialize(&{member.name}[{index}], false, nullptr);\n' else: pre_code += f'{new_prefix}[{index}].initialize(&{member.name}[{index}]);\n' else: pre_code += f'{new_prefix}[{index}] = {member.name}[{index}];\n' if process_pnext: pre_code += f'UnwrapPnextChainHandles({new_prefix}[{index}].pNext);\n' local_prefix = f'{new_prefix}[{index}].' # Process sub-structs in this struct (tmp_decl, tmp_pre, tmp_post) = self.uniquifyMembers(struct.members, local_prefix, arrayIndex, isCreate, isDestroy, False) decls += tmp_decl pre_code += tmp_pre post_code += tmp_post pre_code += '}\n' pre_code += '}\n' if topLevel: post_code += self.cleanUpLocalDeclarations(prefix, member.name, member.length, deferred_name) # Single Struct elif member.pointer: # Check if this function can be deferred. deferred_name = next((x.name for x in members if x.type == 'VkDeferredOperationKHR'), None) # Update struct prefix if topLevel: new_prefix = f'local_{member.name}->' if deferred_name is None: decls += f'{safe_type} var_local_{prefix}{member.name};\n' decls += f'{safe_type} *local_{prefix}{member.name} = nullptr;\n' else: new_prefix = f'{prefix}{member.name}->' # Declare safe_VarType for struct pre_code += f'if ({prefix}{member.name}) {{\n' if topLevel: if deferred_name is None: pre_code += f'local_{prefix}{member.name} = &var_local_{prefix}{member.name};\n' else: pre_code += f'local_{member.name} = new {safe_type};\n' if safe_type.startswith('vku::safe'): # Handle special initialize function for VkAccelerationStructureBuildGeometryInfoKHR if member.type == "VkAccelerationStructureBuildGeometryInfoKHR": pre_code += f'local_{prefix}{member.name}->initialize({member.name}, false, nullptr);\n' else: pre_code += f'local_{prefix}{member.name}->initialize({member.name});\n' else: pre_code += f'*local_{prefix}{member.name} = *{member.name};\n' # Process sub-structs in this struct (tmp_decl, tmp_pre, tmp_post) = self.uniquifyMembers(struct.members, new_prefix, arrayIndex, isCreate, isDestroy, False) decls += tmp_decl pre_code += tmp_pre post_code += tmp_post if process_pnext: pre_code += f'UnwrapPnextChainHandles({new_prefix}pNext);\n' pre_code += '}\n' if topLevel: post_code += self.cleanUpLocalDeclarations(prefix, member.name, member.length, deferred_name) else: # Update struct prefix if topLevel: sys.exit(1) else: new_prefix = f'{prefix}{member.name}.' # Process sub-structs in this struct (tmp_decl, tmp_pre, tmp_post) = self.uniquifyMembers(struct.members, new_prefix, arrayIndex, isCreate, isDestroy, False) decls += tmp_decl pre_code += tmp_pre post_code += tmp_post if process_pnext: pre_code += f'UnwrapPnextChainHandles({prefix}{member.name}.pNext);\n' elif member.type == 'VkObjectType' and member.name == 'objectType' and any(m.name == 'objectHandle' for m in members): pre_code += ''' if (NotDispatchableHandle(objectType)) { objectHandle = Unwrap(objectHandle); } ''' return decls, pre_code, post_code