scripts: Remove unused codegen from build
There was some old codegen that was used for generating validation
layers when those were in the same repo as the loader. Since they're
separate, we can remove the files so they only exist in the layers
repo.
Change-Id: Ia72f235ea0617f25258631e1003123ec3edd88d4
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 76fc7fd..d0b135e 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -170,23 +170,13 @@
# Use the macro to generate the source files.
GenerateFromVkXml(vk_layer_dispatch_table.h loader_extension_generator.py)
GenerateFromVkXml(vk_dispatch_table_helper.h dispatch_table_helper_generator.py)
-GenerateFromVkXml(vk_safe_struct.h helper_file_generator.py)
-GenerateFromVkXml(vk_safe_struct.cpp helper_file_generator.py)
-GenerateFromVkXml(vk_enum_string_helper.h helper_file_generator.py)
GenerateFromVkXml(vk_object_types.h helper_file_generator.py)
-GenerateFromVkXml(vk_extension_helper.h helper_file_generator.py)
-GenerateFromVkXml(vk_typemap_helper.h helper_file_generator.py)
# Use a custom target to cause the source files to be generated.
add_custom_target(generate_helper_files
- DEPENDS vk_enum_string_helper.h
- vk_safe_struct.h
- vk_safe_struct.cpp
- vk_object_types.h
+ DEPENDS vk_object_types.h
vk_layer_dispatch_table.h
- vk_dispatch_table_helper.h
- vk_extension_helper.h
- vk_typemap_helper.h)
+ vk_dispatch_table_helper.h)
set_target_properties(generate_helper_files PROPERTIES FOLDER ${LOADER_HELPER_FOLDER})
diff --git a/scripts/helper_file_generator.py b/scripts/helper_file_generator.py
index bfdcab3..56045ee 100644
--- a/scripts/helper_file_generator.py
+++ b/scripts/helper_file_generator.py
@@ -385,266 +385,6 @@
outstring += '}\n'
return outstring
#
- # Tack on a helper which, given an index into a VkPhysicalDeviceFeatures structure, will print the corresponding feature name
- def DeIndexPhysDevFeatures(self):
- pdev_members = None
- for name, members, ifdef in self.structMembers:
- if name == 'VkPhysicalDeviceFeatures':
- pdev_members = members
- break
- deindex = '\n'
- deindex += 'static inline const char * GetPhysDevFeatureString(uint32_t index) {\n'
- deindex += ' const char * IndexToPhysDevFeatureString[] = {\n'
- for feature in pdev_members:
- deindex += ' "%s",\n' % feature.name
- deindex += ' };\n\n'
- deindex += ' return IndexToPhysDevFeatureString[index];\n'
- deindex += '}\n'
- return deindex
- #
- # Combine enum string helper header file preamble with body text and return
- def GenerateEnumStringHelperHeader(self):
- enum_string_helper_header = '\n'
- enum_string_helper_header += '#pragma once\n'
- enum_string_helper_header += '#ifdef _WIN32\n'
- enum_string_helper_header += '#pragma warning( disable : 4065 )\n'
- enum_string_helper_header += '#endif\n'
- enum_string_helper_header += '\n'
- enum_string_helper_header += '#include <vulkan/vulkan.h>\n'
- enum_string_helper_header += '\n'
- enum_string_helper_header += self.enum_output
- enum_string_helper_header += self.DeIndexPhysDevFeatures()
- return enum_string_helper_header
- #
- # Helper function for declaring a counter variable only once
- def DeclareCounter(self, string_var, declare_flag):
- if declare_flag == False:
- string_var += ' uint32_t i = 0;\n'
- declare_flag = True
- return string_var, declare_flag
- #
- # Combine safe struct helper header file preamble with body text and return
- def GenerateSafeStructHelperHeader(self):
- safe_struct_helper_header = '\n'
- safe_struct_helper_header += '#pragma once\n'
- safe_struct_helper_header += '#include <vulkan/vulkan.h>\n'
- safe_struct_helper_header += '\n'
- safe_struct_helper_header += self.GenerateSafeStructHeader()
- return safe_struct_helper_header
- #
- # safe_struct header: build function prototypes for header file
- def GenerateSafeStructHeader(self):
- safe_struct_header = ''
- for item in self.structMembers:
- if self.NeedSafeStruct(item) == True:
- safe_struct_header += '\n'
- if item.ifdef_protect is not None:
- safe_struct_header += '#ifdef %s\n' % item.ifdef_protect
- safe_struct_header += 'struct safe_%s {\n' % (item.name)
- for member in item.members:
- if member.type in self.structNames:
- member_index = next((i for i, v in enumerate(self.structMembers) if v[0] == member.type), None)
- if member_index is not None and self.NeedSafeStruct(self.structMembers[member_index]) == True:
- if member.ispointer:
- safe_struct_header += ' safe_%s* %s;\n' % (member.type, member.name)
- else:
- safe_struct_header += ' safe_%s %s;\n' % (member.type, member.name)
- continue
- if member.len is not None and (self.TypeContainsObjectHandle(member.type, True) or self.TypeContainsObjectHandle(member.type, False)):
- safe_struct_header += ' %s* %s;\n' % (member.type, member.name)
- else:
- safe_struct_header += '%s;\n' % member.cdecl
- safe_struct_header += ' safe_%s(const %s* in_struct%s);\n' % (item.name, item.name, self.custom_construct_params.get(item.name, ''))
- safe_struct_header += ' safe_%s(const safe_%s& src);\n' % (item.name, item.name)
- safe_struct_header += ' safe_%s& operator=(const safe_%s& src);\n' % (item.name, item.name)
- safe_struct_header += ' safe_%s();\n' % item.name
- safe_struct_header += ' ~safe_%s();\n' % item.name
- safe_struct_header += ' void initialize(const %s* in_struct%s);\n' % (item.name, self.custom_construct_params.get(item.name, ''))
- safe_struct_header += ' void initialize(const safe_%s* src);\n' % (item.name)
- safe_struct_header += ' %s *ptr() { return reinterpret_cast<%s *>(this); }\n' % (item.name, item.name)
- safe_struct_header += ' %s const *ptr() const { return reinterpret_cast<%s const *>(this); }\n' % (item.name, item.name)
- safe_struct_header += '};\n'
- if item.ifdef_protect is not None:
- safe_struct_header += '#endif // %s\n' % item.ifdef_protect
- return safe_struct_header
- #
- # Generate extension helper header file
- def GenerateExtensionHelperHeader(self):
-
- V_1_0_instance_extensions_promoted_to_core = [
- 'vk_khr_device_group_creation',
- 'vk_khr_external_fence_capabilities',
- 'vk_khr_external_memory_capabilities',
- 'vk_khr_external_semaphore_capabilities',
- 'vk_khr_get_physical_device_properties_2',
- ]
-
- V_1_0_device_extensions_promoted_to_core = [
- 'vk_khr_16bit_storage',
- 'vk_khr_bind_memory_2',
- 'vk_khr_dedicated_allocation',
- 'vk_khr_descriptor_update_template',
- 'vk_khr_device_group',
- 'vk_khr_external_fence',
- 'vk_khr_external_memory',
- 'vk_khr_external_semaphore',
- 'vk_khr_get_memory_requirements_2',
- 'vk_khr_maintenance1',
- 'vk_khr_maintenance2',
- 'vk_khr_maintenance3',
- 'vk_khr_multiview',
- 'vk_khr_relaxed_block_layout',
- 'vk_khr_sampler_ycbcr_conversion',
- 'vk_khr_shader_draw_parameters',
- 'vk_khr_storage_buffer_storage_class',
- 'vk_khr_variable_pointers',
- ]
-
- output = [
- '',
- '#ifndef VK_EXTENSION_HELPER_H_',
- '#define VK_EXTENSION_HELPER_H_',
- '#include <string>',
- '#include <unordered_map>',
- '#include <utility>',
- '',
- '#include <vulkan/vulkan.h>',
- '']
-
- def guarded(ifdef, value):
- if ifdef is not None:
- return '\n'.join([ '#ifdef %s' % ifdef, value, '#endif' ])
- else:
- return value
-
- for type in ['Instance', 'Device']:
- struct_type = '%sExtensions' % type
- if type == 'Instance':
- extension_dict = self.instance_extension_info
- promoted_ext_list = V_1_0_instance_extensions_promoted_to_core
- struct_decl = 'struct %s {' % struct_type
- instance_struct_type = struct_type
- else:
- extension_dict = self.device_extension_info
- promoted_ext_list = V_1_0_device_extensions_promoted_to_core
- struct_decl = 'struct %s : public %s {' % (struct_type, instance_struct_type)
-
- extension_items = sorted(extension_dict.items())
-
- field_name = { ext_name: re.sub('_extension_name', '', info['define'].lower()) for ext_name, info in extension_items }
- if type == 'Instance':
- instance_field_name = field_name
- instance_extension_dict = extension_dict
- else:
- # Get complete field name and extension data for both Instance and Device extensions
- field_name.update(instance_field_name)
- extension_dict = extension_dict.copy() # Don't modify the self.<dict> we're pointing to
- extension_dict.update(instance_extension_dict)
-
- # Output the data member list
- struct = [struct_decl]
- struct.extend([ ' bool %s{false};' % field_name[ext_name] for ext_name, info in extension_items])
-
- # Construct the extension information map -- mapping name to data member (field), and required extensions
- # The map is contained within a static function member for portability reasons.
- info_type = '%sInfo' % type
- info_map_type = '%sMap' % info_type
- req_type = '%sReq' % type
- req_vec_type = '%sVec' % req_type
- struct.extend([
- '',
- ' struct %s {' % req_type,
- ' const bool %s::* enabled;' % struct_type,
- ' const char *name;',
- ' };',
- ' typedef std::vector<%s> %s;' % (req_type, req_vec_type),
- ' struct %s {' % info_type,
- ' %s(bool %s::* state_, const %s requires_): state(state_), requires(requires_) {}' % ( info_type, struct_type, req_vec_type),
- ' bool %s::* state;' % struct_type,
- ' %s requires;' % req_vec_type,
- ' };',
- '',
- ' typedef std::unordered_map<std::string,%s> %s;' % (info_type, info_map_type),
- ' static const %s &get_info(const char *name) {' %info_type,
- ' static const %s info_map = {' % info_map_type ])
-
- field_format = '&' + struct_type + '::%s'
- req_format = '{' + field_format+ ', %s}'
- req_indent = '\n '
- req_join = ',' + req_indent
- info_format = (' std::make_pair(%s, ' + info_type + '(' + field_format + ', {%s})),')
- def format_info(ext_name, info):
- reqs = req_join.join([req_format % (field_name[req], extension_dict[req]['define']) for req in info['reqs']])
- return info_format % (info['define'], field_name[ext_name], '{%s}' % (req_indent + reqs) if reqs else '')
-
- struct.extend([guarded(info['ifdef'], format_info(ext_name, info)) for ext_name, info in extension_items])
- struct.extend([
- ' };',
- '',
- ' static const %s empty_info {nullptr, %s()};' % (info_type, req_vec_type),
- ' %s::const_iterator info = info_map.find(name);' % info_map_type,
- ' if ( info != info_map.cend()) {',
- ' return info->second;',
- ' }',
- ' return empty_info;',
- ' }',
- ''])
-
- if type == 'Instance':
- struct.extend([
- ' uint32_t NormalizeApiVersion(uint32_t specified_version) {',
- ' uint32_t api_version = (specified_version < VK_API_VERSION_1_1) ? VK_API_VERSION_1_0 : VK_API_VERSION_1_1;',
- ' return api_version;',
- ' }',
- '',
- ' uint32_t InitFromInstanceCreateInfo(uint32_t requested_api_version, const VkInstanceCreateInfo *pCreateInfo) {'])
- else:
- struct.extend([
- ' %s() = default;' % struct_type,
- ' %s(const %s& instance_ext) : %s(instance_ext) {}' % (struct_type, instance_struct_type, instance_struct_type),
- '',
- ' uint32_t InitFromDeviceCreateInfo(const %s *instance_extensions, uint32_t requested_api_version,' % instance_struct_type,
- ' const VkDeviceCreateInfo *pCreateInfo) {',
- ' // Initialize: this to defaults, base class fields to input.',
- ' assert(instance_extensions);',
- ' *this = %s(*instance_extensions);' % struct_type])
-
- struct.extend([
- '',
- ' static const std::vector<const char *> V_1_0_promoted_%s_extensions = {' % type.lower() ])
- struct.extend([' %s_EXTENSION_NAME,' % ext_name.upper() for ext_name in promoted_ext_list])
- struct.extend([
- ' };',
- '',
- ' // Initialize struct data, robust to invalid pCreateInfo',
- ' if (pCreateInfo->ppEnabledExtensionNames) {',
- ' for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {',
- ' if (!pCreateInfo->ppEnabledExtensionNames[i]) continue;',
- ' auto info = get_info(pCreateInfo->ppEnabledExtensionNames[i]);',
- ' if(info.state) this->*(info.state) = true;',
- ' }',
- ' }',
- ' uint32_t api_version = NormalizeApiVersion(requested_api_version);',
- ' if (api_version >= VK_API_VERSION_1_1) {',
- ' for (auto promoted_ext : V_1_0_promoted_%s_extensions) {' % type.lower(),
- ' auto info = get_info(promoted_ext);',
- ' assert(info.state);',
- ' if (info.state) this->*(info.state) = true;',
- ' }',
- ' }',
- ' return api_version;',
- ' }',
- '};'])
-
- # Output reference lists of instance/device extension names
- struct.extend(['', 'static const char * const k%sExtensionNames = ' % type])
- struct.extend([guarded(info['ifdef'], ' %s' % info['define']) for ext_name, info in extension_items])
- struct.extend([';', ''])
- output.extend(struct)
-
- output.extend(['', '#endif // VK_EXTENSION_HELPER_H_'])
- return '\n'.join(output)
- #
# Combine object types helper header file preamble with body text and return
def GenerateObjectTypesHelperHeader(self):
object_types_helper_header = '\n'
@@ -763,481 +503,11 @@
object_types_header += ' return VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT;\n'
object_types_header += '}\n'
return object_types_header
- #
- # Determine if a structure needs a safe_struct helper function
- # That is, it has an sType or one of its members is a pointer
- def NeedSafeStruct(self, structure):
- if 'sType' == structure.name:
- return True
- for member in structure.members:
- if member.ispointer == True:
- return True
- return False
- #
- # Combine safe struct helper source file preamble with body text and return
- def GenerateSafeStructHelperSource(self):
- safe_struct_helper_source = '\n'
- safe_struct_helper_source += '#include "vk_safe_struct.h"\n'
- safe_struct_helper_source += '#include <string.h>\n'
- safe_struct_helper_source += '#ifdef VK_USE_PLATFORM_ANDROID_KHR\n'
- safe_struct_helper_source += '#if __ANDROID_API__ < __ANDROID_API_O__\n'
- safe_struct_helper_source += 'struct AHardwareBuffer {};\n'
- safe_struct_helper_source += '#endif\n'
- safe_struct_helper_source += '#endif\n'
-
- safe_struct_helper_source += '\n'
- safe_struct_helper_source += self.GenerateSafeStructSource()
- return safe_struct_helper_source
- #
- # safe_struct source -- create bodies of safe struct helper functions
- def GenerateSafeStructSource(self):
- safe_struct_body = []
- wsi_structs = ['VkXlibSurfaceCreateInfoKHR',
- 'VkXcbSurfaceCreateInfoKHR',
- 'VkWaylandSurfaceCreateInfoKHR',
- 'VkMirSurfaceCreateInfoKHR',
- 'VkAndroidSurfaceCreateInfoKHR',
- 'VkWin32SurfaceCreateInfoKHR'
- ]
- for item in self.structMembers:
- if self.NeedSafeStruct(item) == False:
- continue
- if item.name in wsi_structs:
- continue
- if item.ifdef_protect is not None:
- safe_struct_body.append("#ifdef %s\n" % item.ifdef_protect)
- ss_name = "safe_%s" % item.name
- init_list = '' # list of members in struct constructor initializer
- default_init_list = '' # Default constructor just inits ptrs to nullptr in initializer
- init_func_txt = '' # Txt for initialize() function that takes struct ptr and inits members
- construct_txt = '' # Body of constuctor as well as body of initialize() func following init_func_txt
- destruct_txt = ''
-
- custom_construct_txt = {
- # VkWriteDescriptorSet is special case because pointers may be non-null but ignored
- 'VkWriteDescriptorSet' :
- ' switch (descriptorType) {\n'
- ' case VK_DESCRIPTOR_TYPE_SAMPLER:\n'
- ' case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:\n'
- ' case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:\n'
- ' case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:\n'
- ' case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:\n'
- ' if (descriptorCount && in_struct->pImageInfo) {\n'
- ' pImageInfo = new VkDescriptorImageInfo[descriptorCount];\n'
- ' for (uint32_t i=0; i<descriptorCount; ++i) {\n'
- ' pImageInfo[i] = in_struct->pImageInfo[i];\n'
- ' }\n'
- ' }\n'
- ' break;\n'
- ' case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:\n'
- ' case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:\n'
- ' case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:\n'
- ' case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:\n'
- ' if (descriptorCount && in_struct->pBufferInfo) {\n'
- ' pBufferInfo = new VkDescriptorBufferInfo[descriptorCount];\n'
- ' for (uint32_t i=0; i<descriptorCount; ++i) {\n'
- ' pBufferInfo[i] = in_struct->pBufferInfo[i];\n'
- ' }\n'
- ' }\n'
- ' break;\n'
- ' case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:\n'
- ' case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:\n'
- ' if (descriptorCount && in_struct->pTexelBufferView) {\n'
- ' pTexelBufferView = new VkBufferView[descriptorCount];\n'
- ' for (uint32_t i=0; i<descriptorCount; ++i) {\n'
- ' pTexelBufferView[i] = in_struct->pTexelBufferView[i];\n'
- ' }\n'
- ' }\n'
- ' break;\n'
- ' default:\n'
- ' break;\n'
- ' }\n',
- 'VkShaderModuleCreateInfo' :
- ' if (in_struct->pCode) {\n'
- ' pCode = reinterpret_cast<uint32_t *>(new uint8_t[codeSize]);\n'
- ' memcpy((void *)pCode, (void *)in_struct->pCode, codeSize);\n'
- ' }\n',
- # VkGraphicsPipelineCreateInfo is special case because its pointers may be non-null but ignored
- 'VkGraphicsPipelineCreateInfo' :
- ' if (stageCount && in_struct->pStages) {\n'
- ' pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];\n'
- ' for (uint32_t i=0; i<stageCount; ++i) {\n'
- ' pStages[i].initialize(&in_struct->pStages[i]);\n'
- ' }\n'
- ' }\n'
- ' if (in_struct->pVertexInputState)\n'
- ' pVertexInputState = new safe_VkPipelineVertexInputStateCreateInfo(in_struct->pVertexInputState);\n'
- ' else\n'
- ' pVertexInputState = NULL;\n'
- ' if (in_struct->pInputAssemblyState)\n'
- ' pInputAssemblyState = new safe_VkPipelineInputAssemblyStateCreateInfo(in_struct->pInputAssemblyState);\n'
- ' else\n'
- ' pInputAssemblyState = NULL;\n'
- ' bool has_tessellation_stage = false;\n'
- ' if (stageCount && pStages)\n'
- ' for (uint32_t i=0; i<stageCount && !has_tessellation_stage; ++i)\n'
- ' if (pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT || pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT)\n'
- ' has_tessellation_stage = true;\n'
- ' if (in_struct->pTessellationState && has_tessellation_stage)\n'
- ' pTessellationState = new safe_VkPipelineTessellationStateCreateInfo(in_struct->pTessellationState);\n'
- ' else\n'
- ' pTessellationState = NULL; // original pTessellationState pointer ignored\n'
- ' bool has_rasterization = in_struct->pRasterizationState ? !in_struct->pRasterizationState->rasterizerDiscardEnable : false;\n'
- ' if (in_struct->pViewportState && has_rasterization) {\n'
- ' bool is_dynamic_viewports = false;\n'
- ' bool is_dynamic_scissors = false;\n'
- ' if (in_struct->pDynamicState && in_struct->pDynamicState->pDynamicStates) {\n'
- ' for (uint32_t i = 0; i < in_struct->pDynamicState->dynamicStateCount && !is_dynamic_viewports; ++i)\n'
- ' if (in_struct->pDynamicState->pDynamicStates[i] == VK_DYNAMIC_STATE_VIEWPORT)\n'
- ' is_dynamic_viewports = true;\n'
- ' for (uint32_t i = 0; i < in_struct->pDynamicState->dynamicStateCount && !is_dynamic_scissors; ++i)\n'
- ' if (in_struct->pDynamicState->pDynamicStates[i] == VK_DYNAMIC_STATE_SCISSOR)\n'
- ' is_dynamic_scissors = true;\n'
- ' }\n'
- ' pViewportState = new safe_VkPipelineViewportStateCreateInfo(in_struct->pViewportState, is_dynamic_viewports, is_dynamic_scissors);\n'
- ' } else\n'
- ' pViewportState = NULL; // original pViewportState pointer ignored\n'
- ' if (in_struct->pRasterizationState)\n'
- ' pRasterizationState = new safe_VkPipelineRasterizationStateCreateInfo(in_struct->pRasterizationState);\n'
- ' else\n'
- ' pRasterizationState = NULL;\n'
- ' if (in_struct->pMultisampleState && has_rasterization)\n'
- ' pMultisampleState = new safe_VkPipelineMultisampleStateCreateInfo(in_struct->pMultisampleState);\n'
- ' else\n'
- ' pMultisampleState = NULL; // original pMultisampleState pointer ignored\n'
- ' // needs a tracked subpass state uses_depthstencil_attachment\n'
- ' if (in_struct->pDepthStencilState && has_rasterization && uses_depthstencil_attachment)\n'
- ' pDepthStencilState = new safe_VkPipelineDepthStencilStateCreateInfo(in_struct->pDepthStencilState);\n'
- ' else\n'
- ' pDepthStencilState = NULL; // original pDepthStencilState pointer ignored\n'
- ' // needs a tracked subpass state usesColorAttachment\n'
- ' if (in_struct->pColorBlendState && has_rasterization && uses_color_attachment)\n'
- ' pColorBlendState = new safe_VkPipelineColorBlendStateCreateInfo(in_struct->pColorBlendState);\n'
- ' else\n'
- ' pColorBlendState = NULL; // original pColorBlendState pointer ignored\n'
- ' if (in_struct->pDynamicState)\n'
- ' pDynamicState = new safe_VkPipelineDynamicStateCreateInfo(in_struct->pDynamicState);\n'
- ' else\n'
- ' pDynamicState = NULL;\n',
- # VkPipelineViewportStateCreateInfo is special case because its pointers may be non-null but ignored
- 'VkPipelineViewportStateCreateInfo' :
- ' if (in_struct->pViewports && !is_dynamic_viewports) {\n'
- ' pViewports = new VkViewport[in_struct->viewportCount];\n'
- ' memcpy ((void *)pViewports, (void *)in_struct->pViewports, sizeof(VkViewport)*in_struct->viewportCount);\n'
- ' }\n'
- ' else\n'
- ' pViewports = NULL;\n'
- ' if (in_struct->pScissors && !is_dynamic_scissors) {\n'
- ' pScissors = new VkRect2D[in_struct->scissorCount];\n'
- ' memcpy ((void *)pScissors, (void *)in_struct->pScissors, sizeof(VkRect2D)*in_struct->scissorCount);\n'
- ' }\n'
- ' else\n'
- ' pScissors = NULL;\n',
- # VkDescriptorSetLayoutBinding is special case because its pImmutableSamplers pointer may be non-null but ignored
- 'VkDescriptorSetLayoutBinding' :
- ' const bool sampler_type = in_struct->descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER || in_struct->descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;\n'
- ' if (descriptorCount && in_struct->pImmutableSamplers && sampler_type) {\n'
- ' pImmutableSamplers = new VkSampler[descriptorCount];\n'
- ' for (uint32_t i=0; i<descriptorCount; ++i) {\n'
- ' pImmutableSamplers[i] = in_struct->pImmutableSamplers[i];\n'
- ' }\n'
- ' }\n',
- }
-
- custom_copy_txt = {
- # VkGraphicsPipelineCreateInfo is special case because it has custom construct parameters
- 'VkGraphicsPipelineCreateInfo' :
- ' if (stageCount && src.pStages) {\n'
- ' pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];\n'
- ' for (uint32_t i=0; i<stageCount; ++i) {\n'
- ' pStages[i].initialize(&src.pStages[i]);\n'
- ' }\n'
- ' }\n'
- ' if (src.pVertexInputState)\n'
- ' pVertexInputState = new safe_VkPipelineVertexInputStateCreateInfo(*src.pVertexInputState);\n'
- ' else\n'
- ' pVertexInputState = NULL;\n'
- ' if (src.pInputAssemblyState)\n'
- ' pInputAssemblyState = new safe_VkPipelineInputAssemblyStateCreateInfo(*src.pInputAssemblyState);\n'
- ' else\n'
- ' pInputAssemblyState = NULL;\n'
- ' bool has_tessellation_stage = false;\n'
- ' if (stageCount && pStages)\n'
- ' for (uint32_t i=0; i<stageCount && !has_tessellation_stage; ++i)\n'
- ' if (pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT || pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT)\n'
- ' has_tessellation_stage = true;\n'
- ' if (src.pTessellationState && has_tessellation_stage)\n'
- ' pTessellationState = new safe_VkPipelineTessellationStateCreateInfo(*src.pTessellationState);\n'
- ' else\n'
- ' pTessellationState = NULL; // original pTessellationState pointer ignored\n'
- ' bool has_rasterization = src.pRasterizationState ? !src.pRasterizationState->rasterizerDiscardEnable : false;\n'
- ' if (src.pViewportState && has_rasterization) {\n'
- ' pViewportState = new safe_VkPipelineViewportStateCreateInfo(*src.pViewportState);\n'
- ' } else\n'
- ' pViewportState = NULL; // original pViewportState pointer ignored\n'
- ' if (src.pRasterizationState)\n'
- ' pRasterizationState = new safe_VkPipelineRasterizationStateCreateInfo(*src.pRasterizationState);\n'
- ' else\n'
- ' pRasterizationState = NULL;\n'
- ' if (src.pMultisampleState && has_rasterization)\n'
- ' pMultisampleState = new safe_VkPipelineMultisampleStateCreateInfo(*src.pMultisampleState);\n'
- ' else\n'
- ' pMultisampleState = NULL; // original pMultisampleState pointer ignored\n'
- ' if (src.pDepthStencilState && has_rasterization)\n'
- ' pDepthStencilState = new safe_VkPipelineDepthStencilStateCreateInfo(*src.pDepthStencilState);\n'
- ' else\n'
- ' pDepthStencilState = NULL; // original pDepthStencilState pointer ignored\n'
- ' if (src.pColorBlendState && has_rasterization)\n'
- ' pColorBlendState = new safe_VkPipelineColorBlendStateCreateInfo(*src.pColorBlendState);\n'
- ' else\n'
- ' pColorBlendState = NULL; // original pColorBlendState pointer ignored\n'
- ' if (src.pDynamicState)\n'
- ' pDynamicState = new safe_VkPipelineDynamicStateCreateInfo(*src.pDynamicState);\n'
- ' else\n'
- ' pDynamicState = NULL;\n',
- # VkPipelineViewportStateCreateInfo is special case because it has custom construct parameters
- 'VkPipelineViewportStateCreateInfo' :
- ' if (src.pViewports) {\n'
- ' pViewports = new VkViewport[src.viewportCount];\n'
- ' memcpy ((void *)pViewports, (void *)src.pViewports, sizeof(VkViewport)*src.viewportCount);\n'
- ' }\n'
- ' else\n'
- ' pViewports = NULL;\n'
- ' if (src.pScissors) {\n'
- ' pScissors = new VkRect2D[src.scissorCount];\n'
- ' memcpy ((void *)pScissors, (void *)src.pScissors, sizeof(VkRect2D)*src.scissorCount);\n'
- ' }\n'
- ' else\n'
- ' pScissors = NULL;\n',
- }
-
- custom_destruct_txt = {'VkShaderModuleCreateInfo' :
- ' if (pCode)\n'
- ' delete[] reinterpret_cast<const uint8_t *>(pCode);\n' }
-
- for member in item.members:
- m_type = member.type
- if member.type in self.structNames:
- member_index = next((i for i, v in enumerate(self.structMembers) if v[0] == member.type), None)
- if member_index is not None and self.NeedSafeStruct(self.structMembers[member_index]) == True:
- m_type = 'safe_%s' % member.type
- if member.ispointer and 'safe_' not in m_type and self.TypeContainsObjectHandle(member.type, False) == False:
- # Ptr types w/o a safe_struct, for non-null case need to allocate new ptr and copy data in
- if m_type in ['void', 'char']:
- # For these exceptions just copy initial value over for now
- init_list += '\n %s(in_struct->%s),' % (member.name, member.name)
- init_func_txt += ' %s = in_struct->%s;\n' % (member.name, member.name)
- else:
- default_init_list += '\n %s(nullptr),' % (member.name)
- init_list += '\n %s(nullptr),' % (member.name)
- init_func_txt += ' %s = nullptr;\n' % (member.name)
- if 'pNext' != member.name and 'void' not in m_type:
- if not member.isstaticarray and (member.len is None or '/' in member.len):
- construct_txt += ' if (in_struct->%s) {\n' % member.name
- construct_txt += ' %s = new %s(*in_struct->%s);\n' % (member.name, m_type, member.name)
- construct_txt += ' }\n'
- destruct_txt += ' if (%s)\n' % member.name
- destruct_txt += ' delete %s;\n' % member.name
- else:
- construct_txt += ' if (in_struct->%s) {\n' % member.name
- construct_txt += ' %s = new %s[in_struct->%s];\n' % (member.name, m_type, member.len)
- construct_txt += ' memcpy ((void *)%s, (void *)in_struct->%s, sizeof(%s)*in_struct->%s);\n' % (member.name, member.name, m_type, member.len)
- construct_txt += ' }\n'
- destruct_txt += ' if (%s)\n' % member.name
- destruct_txt += ' delete[] %s;\n' % member.name
- elif member.isstaticarray or member.len is not None:
- if member.len is None:
- # Extract length of static array by grabbing val between []
- static_array_size = re.match(r"[^[]*\[([^]]*)\]", member.cdecl)
- construct_txt += ' for (uint32_t i=0; i<%s; ++i) {\n' % static_array_size.group(1)
- construct_txt += ' %s[i] = in_struct->%s[i];\n' % (member.name, member.name)
- construct_txt += ' }\n'
- else:
- # Init array ptr to NULL
- default_init_list += '\n %s(nullptr),' % member.name
- init_list += '\n %s(nullptr),' % member.name
- init_func_txt += ' %s = nullptr;\n' % member.name
- array_element = 'in_struct->%s[i]' % member.name
- if member.type in self.structNames:
- member_index = next((i for i, v in enumerate(self.structMembers) if v[0] == member.type), None)
- if member_index is not None and self.NeedSafeStruct(self.structMembers[member_index]) == True:
- array_element = '%s(&in_struct->safe_%s[i])' % (member.type, member.name)
- construct_txt += ' if (%s && in_struct->%s) {\n' % (member.len, member.name)
- construct_txt += ' %s = new %s[%s];\n' % (member.name, m_type, member.len)
- destruct_txt += ' if (%s)\n' % member.name
- destruct_txt += ' delete[] %s;\n' % member.name
- construct_txt += ' for (uint32_t i=0; i<%s; ++i) {\n' % (member.len)
- if 'safe_' in m_type:
- construct_txt += ' %s[i].initialize(&in_struct->%s[i]);\n' % (member.name, member.name)
- else:
- construct_txt += ' %s[i] = %s;\n' % (member.name, array_element)
- construct_txt += ' }\n'
- construct_txt += ' }\n'
- elif member.ispointer == True:
- construct_txt += ' if (in_struct->%s)\n' % member.name
- construct_txt += ' %s = new %s(in_struct->%s);\n' % (member.name, m_type, member.name)
- construct_txt += ' else\n'
- construct_txt += ' %s = NULL;\n' % member.name
- destruct_txt += ' if (%s)\n' % member.name
- destruct_txt += ' delete %s;\n' % member.name
- elif 'safe_' in m_type:
- init_list += '\n %s(&in_struct->%s),' % (member.name, member.name)
- init_func_txt += ' %s.initialize(&in_struct->%s);\n' % (member.name, member.name)
- else:
- init_list += '\n %s(in_struct->%s),' % (member.name, member.name)
- init_func_txt += ' %s = in_struct->%s;\n' % (member.name, member.name)
- if '' != init_list:
- init_list = init_list[:-1] # hack off final comma
- if item.name in custom_construct_txt:
- construct_txt = custom_construct_txt[item.name]
- if item.name in custom_destruct_txt:
- destruct_txt = custom_destruct_txt[item.name]
- safe_struct_body.append("\n%s::%s(const %s* in_struct%s) :%s\n{\n%s}" % (ss_name, ss_name, item.name, self.custom_construct_params.get(item.name, ''), init_list, construct_txt))
- if '' != default_init_list:
- default_init_list = " :%s" % (default_init_list[:-1])
- safe_struct_body.append("\n%s::%s()%s\n{}" % (ss_name, ss_name, default_init_list))
- # Create slight variation of init and construct txt for copy constructor that takes a src object reference vs. struct ptr
- copy_construct_init = init_func_txt.replace('in_struct->', 'src.')
- copy_construct_txt = construct_txt.replace(' (in_struct->', ' (src.') # Exclude 'if' blocks from next line
- copy_construct_txt = copy_construct_txt.replace('(in_struct->', '(*src.') # Pass object to copy constructors
- copy_construct_txt = copy_construct_txt.replace('in_struct->', 'src.') # Modify remaining struct refs for src object
- if item.name in custom_copy_txt:
- copy_construct_txt = custom_copy_txt[item.name]
- copy_assign_txt = ' if (&src == this) return *this;\n\n' + destruct_txt + '\n' + copy_construct_init + copy_construct_txt + '\n return *this;'
- safe_struct_body.append("\n%s::%s(const %s& src)\n{\n%s%s}" % (ss_name, ss_name, ss_name, copy_construct_init, copy_construct_txt)) # Copy constructor
- safe_struct_body.append("\n%s& %s::operator=(const %s& src)\n{\n%s\n}" % (ss_name, ss_name, ss_name, copy_assign_txt)) # Copy assignment operator
- safe_struct_body.append("\n%s::~%s()\n{\n%s}" % (ss_name, ss_name, destruct_txt))
- safe_struct_body.append("\nvoid %s::initialize(const %s* in_struct%s)\n{\n%s%s}" % (ss_name, item.name, self.custom_construct_params.get(item.name, ''), init_func_txt, construct_txt))
- # Copy initializer uses same txt as copy constructor but has a ptr and not a reference
- init_copy = copy_construct_init.replace('src.', 'src->')
- init_construct = copy_construct_txt.replace('src.', 'src->')
- safe_struct_body.append("\nvoid %s::initialize(const %s* src)\n{\n%s%s}" % (ss_name, ss_name, init_copy, init_construct))
- if item.ifdef_protect is not None:
- safe_struct_body.append("#endif // %s\n" % item.ifdef_protect)
- return "\n".join(safe_struct_body)
- #
- # Generate the type map
- def GenerateTypeMapHelperHeader(self):
- prefix = 'Lvl'
- fprefix = 'lvl_'
- typemap = prefix + 'TypeMap'
- idmap = prefix + 'STypeMap'
- type_member = 'Type'
- id_member = 'kSType'
- id_decl = 'static const VkStructureType '
- generic_header = prefix + 'GenericHeader'
- typename_func = fprefix + 'typename'
- idname_func = fprefix + 'stype_name'
- find_func = fprefix + 'find_in_chain'
- init_func = fprefix + 'init_struct'
-
- explanatory_comment = '\n'.join((
- '// These empty generic templates are specialized for each type with sType',
- '// members and for each sType -- providing a two way map between structure',
- '// types and sTypes'))
-
- empty_typemap = 'template <typename T> struct ' + typemap + ' {};'
- typemap_format = 'template <> struct {template}<{typename}> {{\n'
- typemap_format += ' {id_decl}{id_member} = {id_value};\n'
- typemap_format += '}};\n'
-
- empty_idmap = 'template <VkStructureType id> struct ' + idmap + ' {};'
- idmap_format = ''.join((
- 'template <> struct {template}<{id_value}> {{\n',
- ' typedef {typename} {typedef};\n',
- '}};\n'))
-
- # Define the utilities (here so any renaming stays consistent), if this grows large, refactor to a fixed .h file
- utilities_format = '\n'.join((
- '// Header "base class" for pNext chain traversal',
- 'struct {header} {{',
- ' VkStructureType sType;',
- ' const {header} *pNext;',
- '}};',
- '',
- '// Find an entry of the given type in the pNext chain',
- 'template <typename T> const T *{find_func}(const void *next) {{',
- ' const {header} *current = reinterpret_cast<const {header} *>(next);',
- ' const T *found = nullptr;',
- ' while (current) {{',
- ' if ({type_map}<T>::{id_member} == current->sType) {{',
- ' found = reinterpret_cast<const T*>(current);',
- ' current = nullptr;',
- ' }} else {{',
- ' current = current->pNext;',
- ' }}',
- ' }}',
- ' return found;',
- '}}',
- '',
- '// Init the header of an sType struct with pNext',
- 'template <typename T> T {init_func}(void *p_next) {{',
- ' T out = {{}};',
- ' out.sType = {type_map}<T>::kSType;',
- ' out.pNext = p_next;',
- ' return out;',
- '}}',
- '',
- '// Init the header of an sType struct',
- 'template <typename T> T {init_func}() {{',
- ' T out = {{}};',
- ' out.sType = {type_map}<T>::kSType;',
- ' return out;',
- '}}',
-
- ''))
-
- code = []
-
- # Generate header
- code.append('\n'.join((
- '#pragma once',
- '#include <vulkan/vulkan.h>\n',
- explanatory_comment, '',
- empty_idmap,
- empty_typemap, '')))
-
- # Generate the specializations for each type and stype
- for item in self.structMembers:
- typename = item.name
- info = self.structTypes.get(typename)
- if not info:
- continue
-
- if item.ifdef_protect is not None:
- code.append('#ifdef %s' % item.ifdef_protect)
-
- code.append('// Map type {} to id {}'.format(typename, info.value))
- code.append(typemap_format.format(template=typemap, typename=typename, id_value=info.value,
- id_decl=id_decl, id_member=id_member))
- code.append(idmap_format.format(template=idmap, typename=typename, id_value=info.value, typedef=type_member))
-
- if item.ifdef_protect is not None:
- code.append('#endif // %s' % item.ifdef_protect)
-
- # Generate utilities for all types
- code.append('\n'.join((
- utilities_format.format(id_member=id_member, id_map=idmap, type_map=typemap,
- type_member=type_member, header=generic_header, typename_func=typename_func, idname_func=idname_func,
- find_func=find_func, init_func=init_func), ''
- )))
-
- return "\n".join(code)
#
# Create a helper file and return it as a string
def OutputDestFile(self):
- if self.helper_file_type == 'enum_string_header':
- return self.GenerateEnumStringHelperHeader()
- elif self.helper_file_type == 'safe_struct_header':
- return self.GenerateSafeStructHelperHeader()
- elif self.helper_file_type == 'safe_struct_source':
- return self.GenerateSafeStructHelperSource()
- elif self.helper_file_type == 'object_types_header':
+ if self.helper_file_type == 'object_types_header':
return self.GenerateObjectTypesHelperHeader()
- elif self.helper_file_type == 'extension_helper_header':
- return self.GenerateExtensionHelperHeader()
- elif self.helper_file_type == 'typemap_helper_header':
- return self.GenerateTypeMapHelperHeader()
else:
return 'Bad Helper File Generator Option %s' % self.helper_file_type
