| #!/usr/bin/python3 -i |
| # |
| # Copyright (c) 2015-2017 The Khronos Group Inc. |
| # Copyright (c) 2015-2017 Valve Corporation |
| # Copyright (c) 2015-2017 LunarG, Inc. |
| # Copyright (c) 2015-2017 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: Mark Lobodzinski <mark@lunarg.com> |
| # Author: Tobin Ehlis <tobine@google.com> |
| |
| import os,re,sys |
| import xml.etree.ElementTree as etree |
| from generator import * |
| from collections import namedtuple |
| |
| # |
| # HelperFileOutputGeneratorOptions - subclass of GeneratorOptions. |
| class HelperFileOutputGeneratorOptions(GeneratorOptions): |
| def __init__(self, |
| filename = None, |
| directory = '.', |
| apiname = None, |
| profile = None, |
| versions = '.*', |
| emitversions = '.*', |
| defaultExtensions = None, |
| addExtensions = None, |
| removeExtensions = None, |
| sortProcedure = regSortFeatures, |
| prefixText = "", |
| genFuncPointers = True, |
| protectFile = True, |
| protectFeature = True, |
| protectProto = None, |
| protectProtoStr = None, |
| apicall = '', |
| apientry = '', |
| apientryp = '', |
| alignFuncParam = 0, |
| library_name = '', |
| helper_file_type = ''): |
| GeneratorOptions.__init__(self, filename, directory, apiname, profile, |
| versions, emitversions, defaultExtensions, |
| addExtensions, removeExtensions, sortProcedure) |
| self.prefixText = prefixText |
| self.genFuncPointers = genFuncPointers |
| self.protectFile = protectFile |
| self.protectFeature = protectFeature |
| self.protectProto = protectProto |
| self.protectProtoStr = protectProtoStr |
| self.apicall = apicall |
| self.apientry = apientry |
| self.apientryp = apientryp |
| self.alignFuncParam = alignFuncParam |
| self.library_name = library_name |
| self.helper_file_type = helper_file_type |
| # |
| # HelperFileOutputGenerator - subclass of OutputGenerator. Outputs Vulkan helper files |
| class HelperFileOutputGenerator(OutputGenerator): |
| """Generate helper file based on XML element attributes""" |
| def __init__(self, |
| errFile = sys.stderr, |
| warnFile = sys.stderr, |
| diagFile = sys.stdout): |
| OutputGenerator.__init__(self, errFile, warnFile, diagFile) |
| # Internal state - accumulators for different inner block text |
| self.enum_output = '' # string built up of enum string routines |
| self.struct_size_h_output = '' # string built up of struct size header output |
| self.struct_size_c_output = '' # string built up of struct size source output |
| # Internal state - accumulators for different inner block text |
| self.structNames = [] # List of Vulkan struct typenames |
| self.structTypes = dict() # Map of Vulkan struct typename to required VkStructureType |
| self.structMembers = [] # List of StructMemberData records for all Vulkan structs |
| self.object_types = [] # List of all handle types |
| self.debug_report_object_types = [] # Handy copy of debug_report_object_type enum data |
| self.core_object_types = [] # Handy copy of core_object_type enum data |
| self.device_extension_info = dict() # Dict of device extension name defines and ifdef values |
| self.instance_extension_info = dict() # Dict of instance extension name defines and ifdef values |
| |
| # Named tuples to store struct and command data |
| self.StructType = namedtuple('StructType', ['name', 'value']) |
| self.CommandParam = namedtuple('CommandParam', ['type', 'name', 'ispointer', 'isstaticarray', 'isconst', 'iscount', 'len', 'extstructs', 'cdecl']) |
| self.StructMemberData = namedtuple('StructMemberData', ['name', 'members', 'ifdef_protect']) |
| |
| self.custom_construct_params = { |
| # safe_VkGraphicsPipelineCreateInfo needs to know if subpass has color and\or depth\stencil attachments to use its pointers |
| 'VkGraphicsPipelineCreateInfo' : |
| ', const bool uses_color_attachment, const bool uses_depthstencil_attachment', |
| # safe_VkPipelineViewportStateCreateInfo needs to know if viewport and scissor is dynamic to use its pointers |
| 'VkPipelineViewportStateCreateInfo' : |
| ', const bool is_dynamic_viewports, const bool is_dynamic_scissors', |
| } |
| # |
| # Called once at the beginning of each run |
| def beginFile(self, genOpts): |
| OutputGenerator.beginFile(self, genOpts) |
| # User-supplied prefix text, if any (list of strings) |
| self.helper_file_type = genOpts.helper_file_type |
| self.library_name = genOpts.library_name |
| # File Comment |
| file_comment = '// *** THIS FILE IS GENERATED - DO NOT EDIT ***\n' |
| file_comment += '// See helper_file_generator.py for modifications\n' |
| write(file_comment, file=self.outFile) |
| # Copyright Notice |
| copyright = '' |
| copyright += '\n' |
| copyright += '/***************************************************************************\n' |
| copyright += ' *\n' |
| copyright += ' * Copyright (c) 2015-2017 The Khronos Group Inc.\n' |
| copyright += ' * Copyright (c) 2015-2017 Valve Corporation\n' |
| copyright += ' * Copyright (c) 2015-2017 LunarG, Inc.\n' |
| copyright += ' * Copyright (c) 2015-2017 Google Inc.\n' |
| copyright += ' *\n' |
| copyright += ' * Licensed under the Apache License, Version 2.0 (the "License");\n' |
| copyright += ' * you may not use this file except in compliance with the License.\n' |
| copyright += ' * You may obtain a copy of the License at\n' |
| copyright += ' *\n' |
| copyright += ' * http://www.apache.org/licenses/LICENSE-2.0\n' |
| copyright += ' *\n' |
| copyright += ' * Unless required by applicable law or agreed to in writing, software\n' |
| copyright += ' * distributed under the License is distributed on an "AS IS" BASIS,\n' |
| copyright += ' * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n' |
| copyright += ' * See the License for the specific language governing permissions and\n' |
| copyright += ' * limitations under the License.\n' |
| copyright += ' *\n' |
| copyright += ' * Author: Mark Lobodzinski <mark@lunarg.com>\n' |
| copyright += ' * Author: Courtney Goeltzenleuchter <courtneygo@google.com>\n' |
| copyright += ' * Author: Tobin Ehlis <tobine@google.com>\n' |
| copyright += ' * Author: Chris Forbes <chrisforbes@google.com>\n' |
| copyright += ' * Author: John Zulauf<jzulauf@lunarg.com>\n' |
| copyright += ' *\n' |
| copyright += ' ****************************************************************************/\n' |
| write(copyright, file=self.outFile) |
| # |
| # Write generated file content to output file |
| def endFile(self): |
| dest_file = '' |
| dest_file += self.OutputDestFile() |
| # Remove blank lines at EOF |
| if dest_file.endswith('\n'): |
| dest_file = dest_file[:-1] |
| write(dest_file, file=self.outFile); |
| # Finish processing in superclass |
| OutputGenerator.endFile(self) |
| # |
| # Override parent class to be notified of the beginning of an extension |
| def beginFeature(self, interface, emit): |
| # Start processing in superclass |
| OutputGenerator.beginFeature(self, interface, emit) |
| if self.featureName == 'VK_VERSION_1_0': |
| return |
| nameElem = interface[0][1] |
| name = nameElem.get('name') |
| if 'EXTENSION_NAME' not in name: |
| print("Error in vk.xml file -- extension name is not available") |
| if interface.get('type') == 'instance': |
| self.instance_extension_info[name] = self.featureExtraProtect |
| else: |
| self.device_extension_info[name] = self.featureExtraProtect |
| # |
| # Override parent class to be notified of the end of an extension |
| def endFeature(self): |
| # Finish processing in superclass |
| OutputGenerator.endFeature(self) |
| # |
| # Grab group (e.g. C "enum" type) info to output for enum-string conversion helper |
| def genGroup(self, groupinfo, groupName): |
| OutputGenerator.genGroup(self, groupinfo, groupName) |
| groupElem = groupinfo.elem |
| # For enum_string_header |
| if self.helper_file_type == 'enum_string_header': |
| value_list = [] |
| for elem in groupElem.findall('enum'): |
| if elem.get('supported') != 'disabled': |
| item_name = elem.get('name') |
| value_list.append(item_name) |
| if value_list is not None: |
| self.enum_output += self.GenerateEnumStringConversion(groupName, value_list) |
| elif self.helper_file_type == 'object_types_header': |
| if groupName == 'VkDebugReportObjectTypeEXT': |
| for elem in groupElem.findall('enum'): |
| if elem.get('supported') != 'disabled': |
| item_name = elem.get('name') |
| self.debug_report_object_types.append(item_name) |
| elif groupName == 'VkObjectType': |
| for elem in groupElem.findall('enum'): |
| if elem.get('supported') != 'disabled': |
| item_name = elem.get('name') |
| self.core_object_types.append(item_name) |
| |
| # |
| # Called for each type -- if the type is a struct/union, grab the metadata |
| def genType(self, typeinfo, name): |
| OutputGenerator.genType(self, typeinfo, name) |
| typeElem = typeinfo.elem |
| # If the type is a struct type, traverse the imbedded <member> tags generating a structure. |
| # Otherwise, emit the tag text. |
| category = typeElem.get('category') |
| if category == 'handle': |
| self.object_types.append(name) |
| elif (category == 'struct' or category == 'union'): |
| self.structNames.append(name) |
| self.genStruct(typeinfo, name) |
| # |
| # Generate a VkStructureType based on a structure typename |
| def genVkStructureType(self, typename): |
| # Add underscore between lowercase then uppercase |
| value = re.sub('([a-z0-9])([A-Z])', r'\1_\2', typename) |
| # Change to uppercase |
| value = value.upper() |
| # Add STRUCTURE_TYPE_ |
| return re.sub('VK_', 'VK_STRUCTURE_TYPE_', value) |
| # |
| # Check if the parameter passed in is a pointer |
| def paramIsPointer(self, param): |
| ispointer = False |
| for elem in param: |
| if ((elem.tag is not 'type') and (elem.tail is not None)) and '*' in elem.tail: |
| ispointer = True |
| return ispointer |
| # |
| # Check if the parameter passed in is a static array |
| def paramIsStaticArray(self, param): |
| isstaticarray = 0 |
| paramname = param.find('name') |
| if (paramname.tail is not None) and ('[' in paramname.tail): |
| isstaticarray = paramname.tail.count('[') |
| return isstaticarray |
| # |
| # Retrieve the type and name for a parameter |
| def getTypeNameTuple(self, param): |
| type = '' |
| name = '' |
| for elem in param: |
| if elem.tag == 'type': |
| type = noneStr(elem.text) |
| elif elem.tag == 'name': |
| name = noneStr(elem.text) |
| return (type, name) |
| # Extract length values from latexmath. Currently an inflexible solution that looks for specific |
| # patterns that are found in vk.xml. Will need to be updated when new patterns are introduced. |
| def parseLateXMath(self, source): |
| name = 'ERROR' |
| decoratedName = 'ERROR' |
| if 'mathit' in source: |
| # Matches expressions similar to 'latexmath:[\lceil{\mathit{rasterizationSamples} \over 32}\rceil]' |
| match = re.match(r'latexmath\s*\:\s*\[\s*\\l(\w+)\s*\{\s*\\mathit\s*\{\s*(\w+)\s*\}\s*\\over\s*(\d+)\s*\}\s*\\r(\w+)\s*\]', source) |
| if not match or match.group(1) != match.group(4): |
| raise 'Unrecognized latexmath expression' |
| name = match.group(2) |
| # Need to add 1 for ceiling function; otherwise, the allocated packet |
| # size will be less than needed during capture for some title which use |
| # this in VkPipelineMultisampleStateCreateInfo. based on ceiling function |
| # definition,it is '{0}%{1}?{0}/{1} + 1:{0}/{1}'.format(*match.group(2, 3)), |
| # its value <= '{}/{} + 1'. |
| if match.group(1) == 'ceil': |
| decoratedName = '{}/{} + 1'.format(*match.group(2, 3)) |
| else: |
| decoratedName = '{}/{}'.format(*match.group(2, 3)) |
| else: |
| # Matches expressions similar to 'latexmath : [dataSize \over 4]' |
| match = re.match(r'latexmath\s*\:\s*\[\s*(\w+)\s*\\over\s*(\d+)\s*\]', source) |
| name = match.group(1) |
| decoratedName = '{}/{}'.format(*match.group(1, 2)) |
| return name, decoratedName |
| # |
| # Retrieve the value of the len tag |
| def getLen(self, param): |
| result = None |
| len = param.attrib.get('len') |
| if len and len != 'null-terminated': |
| # For string arrays, 'len' can look like 'count,null-terminated', indicating that we |
| # have a null terminated array of strings. We strip the null-terminated from the |
| # 'len' field and only return the parameter specifying the string count |
| if 'null-terminated' in len: |
| result = len.split(',')[0] |
| else: |
| result = len |
| if 'latexmath' in len: |
| param_type, param_name = self.getTypeNameTuple(param) |
| len_name, result = self.parseLateXMath(len) |
| # Spec has now notation for len attributes, using :: instead of platform specific pointer symbol |
| result = str(result).replace('::', '->') |
| return result |
| # |
| # Check if a structure is or contains a dispatchable (dispatchable = True) or |
| # non-dispatchable (dispatchable = False) handle |
| def TypeContainsObjectHandle(self, handle_type, dispatchable): |
| if dispatchable: |
| type_key = 'VK_DEFINE_HANDLE' |
| else: |
| type_key = 'VK_DEFINE_NON_DISPATCHABLE_HANDLE' |
| handle = self.registry.tree.find("types/type/[name='" + handle_type + "'][@category='handle']") |
| if handle is not None and handle.find('type').text == type_key: |
| return True |
| # if handle_type is a struct, search its members |
| if handle_type in self.structNames: |
| member_index = next((i for i, v in enumerate(self.structMembers) if v[0] == handle_type), None) |
| if member_index is not None: |
| for item in self.structMembers[member_index].members: |
| handle = self.registry.tree.find("types/type/[name='" + item.type + "'][@category='handle']") |
| if handle is not None and handle.find('type').text == type_key: |
| return True |
| return False |
| # |
| # Generate local ready-access data describing Vulkan structures and unions from the XML metadata |
| def genStruct(self, typeinfo, typeName): |
| OutputGenerator.genStruct(self, typeinfo, typeName) |
| members = typeinfo.elem.findall('.//member') |
| # Iterate over members once to get length parameters for arrays |
| lens = set() |
| for member in members: |
| len = self.getLen(member) |
| if len: |
| lens.add(len) |
| # Generate member info |
| membersInfo = [] |
| for member in members: |
| # Get the member's type and name |
| info = self.getTypeNameTuple(member) |
| type = info[0] |
| name = info[1] |
| cdecl = self.makeCParamDecl(member, 1) |
| # Process VkStructureType |
| if type == 'VkStructureType': |
| # Extract the required struct type value from the comments |
| # embedded in the original text defining the 'typeinfo' element |
| rawXml = etree.tostring(typeinfo.elem).decode('ascii') |
| result = re.search(r'VK_STRUCTURE_TYPE_\w+', rawXml) |
| if result: |
| value = result.group(0) |
| else: |
| value = self.genVkStructureType(typeName) |
| # Store the required type value |
| self.structTypes[typeName] = self.StructType(name=name, value=value) |
| # Store pointer/array/string info |
| isstaticarray = self.paramIsStaticArray(member) |
| membersInfo.append(self.CommandParam(type=type, |
| name=name, |
| ispointer=self.paramIsPointer(member), |
| isstaticarray=isstaticarray, |
| isconst=True if 'const' in cdecl else False, |
| iscount=True if name in lens else False, |
| len=self.getLen(member), |
| extstructs=self.registry.validextensionstructs[typeName] if name == 'pNext' else None, |
| cdecl=cdecl)) |
| self.structMembers.append(self.StructMemberData(name=typeName, members=membersInfo, ifdef_protect=self.featureExtraProtect)) |
| # |
| # Enum_string_header: Create a routine to convert an enumerated value into a string |
| def GenerateEnumStringConversion(self, groupName, value_list): |
| outstring = '\n' |
| outstring += 'static inline const char* string_%s(%s input_value)\n' % (groupName, groupName) |
| outstring += '{\n' |
| outstring += ' switch ((%s)input_value)\n' % groupName |
| outstring += ' {\n' |
| for item in value_list: |
| outstring += ' case %s:\n' % item |
| outstring += ' return "%s";\n' % item |
| outstring += ' default:\n' |
| outstring += ' return "Unhandled %s";\n' % groupName |
| outstring += ' }\n' |
| 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 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 |
| # |
| # struct_size_header: build function prototypes for header file |
| def GenerateStructSizeHeader(self): |
| outstring = '' |
| outstring += 'size_t get_struct_chain_size(const void* struct_ptr);\n' |
| outstring += 'size_t get_struct_size(const void* struct_ptr);\n' |
| for item in self.structMembers: |
| lower_case_name = item.name.lower() |
| if item.ifdef_protect != None: |
| outstring += '#ifdef %s\n' % item.ifdef_protect |
| outstring += 'size_t vk_size_%s(const %s* struct_ptr);\n' % (item.name.lower(), item.name) |
| if item.ifdef_protect != None: |
| outstring += '#endif // %s\n' % item.ifdef_protect |
| outstring += '#ifdef __cplusplus\n' |
| outstring += '}\n' |
| outstring += '#endif' |
| return outstring |
| # |
| # Combine struct size helper header file preamble with body text and return |
| def GenerateStructSizeHelperHeader(self): |
| struct_size_helper_header = '\n' |
| struct_size_helper_header += '#ifdef __cplusplus\n' |
| struct_size_helper_header += 'extern "C" {\n' |
| struct_size_helper_header += '#endif\n' |
| struct_size_helper_header += '\n' |
| struct_size_helper_header += '#include <stdio.h>\n' |
| struct_size_helper_header += '#include <stdlib.h>\n' |
| struct_size_helper_header += '#include <vulkan/vulkan.h>\n' |
| struct_size_helper_header += '\n' |
| struct_size_helper_header += '// Function Prototypes\n' |
| struct_size_helper_header += self.GenerateStructSizeHeader() |
| return struct_size_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 |
| # |
| # Build the header of the get_struct_chain_size function |
| def GenerateChainSizePreamble(self): |
| preamble = '\nsize_t get_struct_chain_size(const void* struct_ptr) {\n' |
| preamble += ' // Use VkApplicationInfo as struct until actual type is resolved\n' |
| preamble += ' VkApplicationInfo* pNext = (VkApplicationInfo*)struct_ptr;\n' |
| preamble += ' size_t struct_size = 0;\n' |
| preamble += ' while (pNext) {\n' |
| preamble += ' switch (pNext->sType) {\n' |
| return preamble |
| # |
| # Build the footer of the get_struct_chain_size function |
| def GenerateChainSizePostamble(self): |
| postamble = ' default:\n' |
| postamble += ' struct_size += 0;\n' |
| postamble += ' break;' |
| postamble += ' }\n' |
| postamble += ' pNext = (VkApplicationInfo*)pNext->pNext;\n' |
| postamble += ' }\n' |
| postamble += ' return struct_size;\n' |
| postamble += '}\n' |
| return postamble |
| # |
| # Build the header of the get_struct_size function |
| def GenerateStructSizePreamble(self): |
| preamble = '\nsize_t get_struct_size(const void* struct_ptr) {\n' |
| preamble += ' switch (((VkApplicationInfo*)struct_ptr)->sType) {\n' |
| return preamble |
| # |
| # Build the footer of the get_struct_size function |
| def GenerateStructSizePostamble(self): |
| postamble = ' default:\n' |
| postamble += ' return(0);\n' |
| postamble += ' }\n' |
| postamble += '}' |
| return postamble |
| # |
| # struct_size_helper source -- create bodies of struct size helper functions |
| def GenerateStructSizeSource(self): |
| # Construct the bodies of the struct size functions, get_struct_chain_size(), |
| # and get_struct_size() simultaneously |
| struct_size_funcs = '' |
| chain_size = self.GenerateChainSizePreamble() |
| struct_size = self.GenerateStructSizePreamble() |
| for item in self.structMembers: |
| struct_size_funcs += '\n' |
| lower_case_name = item.name.lower() |
| if item.ifdef_protect != None: |
| struct_size_funcs += '#ifdef %s\n' % item.ifdef_protect |
| struct_size += '#ifdef %s\n' % item.ifdef_protect |
| chain_size += '#ifdef %s\n' % item.ifdef_protect |
| if item.name in self.structTypes: |
| chain_size += ' case %s: {\n' % self.structTypes[item.name].value |
| chain_size += ' struct_size += vk_size_%s((%s*)pNext);\n' % (item.name.lower(), item.name) |
| chain_size += ' break;\n' |
| chain_size += ' }\n' |
| struct_size += ' case %s: \n' % self.structTypes[item.name].value |
| struct_size += ' return vk_size_%s((%s*)struct_ptr);\n' % (item.name.lower(), item.name) |
| struct_size_funcs += 'size_t vk_size_%s(const %s* struct_ptr) { \n' % (item.name.lower(), item.name) |
| struct_size_funcs += ' size_t struct_size = 0;\n' |
| struct_size_funcs += ' if (struct_ptr) {\n' |
| struct_size_funcs += ' struct_size = sizeof(%s);\n' % item.name |
| counter_declared = False |
| for member in item.members: |
| vulkan_type = next((i for i, v in enumerate(self.structMembers) if v[0] == member.type), None) |
| if member.ispointer == True: |
| if vulkan_type is not None: |
| # If this is another Vulkan structure call generated size function |
| if member.len is not None: |
| struct_size_funcs, counter_declared = self.DeclareCounter(struct_size_funcs, counter_declared) |
| struct_size_funcs += ' for (i = 0; i < struct_ptr->%s; i++) {\n' % member.len |
| struct_size_funcs += ' struct_size += vk_size_%s(&struct_ptr->%s[i]);\n' % (member.type.lower(), member.name) |
| struct_size_funcs += ' }\n' |
| else: |
| struct_size_funcs += ' struct_size += vk_size_%s(struct_ptr->%s);\n' % (member.type.lower(), member.name) |
| else: |
| if member.type == 'char': |
| # Deal with sizes of character strings |
| if member.len is not None: |
| struct_size_funcs, counter_declared = self.DeclareCounter(struct_size_funcs, counter_declared) |
| struct_size_funcs += ' for (i = 0; i < struct_ptr->%s; i++) {\n' % member.len |
| struct_size_funcs += ' struct_size += (sizeof(char*) + (sizeof(char) * (1 + strlen(struct_ptr->%s[i]))));\n' % (member.name) |
| struct_size_funcs += ' }\n' |
| else: |
| struct_size_funcs += ' struct_size += (struct_ptr->%s != NULL) ? sizeof(char)*(1+strlen(struct_ptr->%s)) : 0;\n' % (member.name, member.name) |
| else: |
| if member.len is not None: |
| # Avoid using 'sizeof(void)', which generates compile-time warnings/errors |
| checked_type = member.type |
| if checked_type == 'void': |
| checked_type = 'void*' |
| struct_size_funcs += ' struct_size += (struct_ptr->%s ) * sizeof(%s);\n' % (member.len, checked_type) |
| struct_size_funcs += ' }\n' |
| struct_size_funcs += ' return struct_size;\n' |
| struct_size_funcs += '}\n' |
| if item.ifdef_protect != None: |
| struct_size_funcs += '#endif // %s\n' % item.ifdef_protect |
| struct_size += '#endif // %s\n' % item.ifdef_protect |
| chain_size += '#endif // %s\n' % item.ifdef_protect |
| chain_size += self.GenerateChainSizePostamble() |
| struct_size += self.GenerateStructSizePostamble() |
| return_value = struct_size_funcs + chain_size + struct_size; |
| return return_value |
| # |
| # Combine struct size helper source file preamble with body text and return |
| def GenerateStructSizeHelperSource(self): |
| struct_size_helper_source = '\n' |
| struct_size_helper_source += '#include "vk_struct_size_helper.h"\n' |
| struct_size_helper_source += '#include <string.h>\n' |
| struct_size_helper_source += '#include <assert.h>\n' |
| struct_size_helper_source += '\n' |
| struct_size_helper_source += '// Function Definitions\n' |
| struct_size_helper_source += self.GenerateStructSizeSource() |
| return struct_size_helper_source |
| # |
| # 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 != 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 != None: |
| safe_struct_header += '#endif // %s\n' % item.ifdef_protect |
| return safe_struct_header |
| # |
| # Generate extension helper header file |
| def GenerateExtensionHelperHeader(self): |
| extension_helper_header = '\n' |
| extension_helper_header += '#ifndef VK_EXTENSION_HELPER_H_\n' |
| extension_helper_header += '#define VK_EXTENSION_HELPER_H_\n' |
| struct = '\n' |
| extension_helper_header += '#include <vulkan/vulkan.h>\n' |
| extension_helper_header += '#include <string.h>\n' |
| extension_helper_header += '#include <utility>\n' |
| extension_helper_header += '\n' |
| extension_dict = dict() |
| for type in ['Instance', 'Device']: |
| if type == 'Instance': |
| extension_dict = self.instance_extension_info |
| struct += 'struct InstanceExtensions { \n' |
| else: |
| extension_dict = self.device_extension_info |
| struct += 'struct DeviceExtensions : public InstanceExtensions { \n' |
| for ext_name, ifdef in extension_dict.items(): |
| bool_name = ext_name.lower() |
| bool_name = re.sub('_extension_name', '', bool_name) |
| struct += ' bool %s{false};\n' % bool_name |
| struct += '\n' |
| if type == 'Instance': |
| struct += ' void InitFromInstanceCreateInfo(const VkInstanceCreateInfo *pCreateInfo) {\n' |
| else: |
| struct += ' void InitFromDeviceCreateInfo(const InstanceExtensions *instance_extensions, const VkDeviceCreateInfo *pCreateInfo) {\n' |
| struct += '\n' |
| struct += ' static const std::pair<char const *, bool %sExtensions::*> known_extensions[]{\n' % type |
| for ext_name, ifdef in extension_dict.items(): |
| if ifdef is not None: |
| struct += '#ifdef %s\n' % ifdef |
| bool_name = ext_name.lower() |
| bool_name = re.sub('_extension_name', '', bool_name) |
| struct += ' {%s, &%sExtensions::%s},\n' % (ext_name, type, bool_name) |
| if ifdef is not None: |
| struct += '#endif\n' |
| struct += ' };\n' |
| struct += '\n' |
| struct += ' // Initialize struct data\n' |
| for ext_name, ifdef in self.instance_extension_info.items(): |
| bool_name = ext_name.lower() |
| bool_name = re.sub('_extension_name', '', bool_name) |
| if type == 'Device': |
| struct += ' %s = instance_extensions->%s;\n' % (bool_name, bool_name) |
| struct += '\n' |
| struct += ' for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {\n' |
| struct += ' for (auto ext : known_extensions) {\n' |
| struct += ' if (!strcmp(ext.first, pCreateInfo->ppEnabledExtensionNames[i])) {\n' |
| struct += ' this->*(ext.second) = true;\n' |
| struct += ' break;\n' |
| struct += ' }\n' |
| struct += ' }\n' |
| struct += ' }\n' |
| struct += ' }\n' |
| struct += '};\n' |
| struct += '\n' |
| # Output reference lists of instance/device extension names |
| struct += 'static const char * const k%sExtensionNames = \n' % type |
| for ext_name, ifdef in extension_dict.items(): |
| if ifdef is not None: |
| struct += '#ifdef %s\n' % ifdef |
| struct += ' %s\n' % ext_name |
| if ifdef is not None: |
| struct += '#endif\n' |
| struct += ';\n\n' |
| extension_helper_header += struct |
| extension_helper_header += '\n' |
| extension_helper_header += '#endif // VK_EXTENSION_HELPER_H_\n' |
| return extension_helper_header |
| # |
| # Combine object types helper header file preamble with body text and return |
| def GenerateObjectTypesHelperHeader(self): |
| object_types_helper_header = '\n' |
| object_types_helper_header += '#pragma once\n' |
| object_types_helper_header += '\n' |
| object_types_helper_header += '#include <vulkan/vulkan.h>\n\n' |
| object_types_helper_header += self.GenerateObjectTypesHeader() |
| return object_types_helper_header |
| # |
| # Object types header: create object enum type header file |
| def GenerateObjectTypesHeader(self): |
| object_types_header = '// Object Type enum for validation layer internal object handling\n' |
| object_types_header += 'typedef enum VulkanObjectType {\n' |
| object_types_header += ' kVulkanObjectTypeUnknown = 0,\n' |
| enum_num = 1 |
| type_list = []; |
| |
| # Output enum definition as each handle is processed, saving the names to use for the conversion routine |
| for item in self.object_types: |
| fixup_name = item[2:] |
| enum_entry = 'kVulkanObjectType%s' % fixup_name |
| object_types_header += ' ' + enum_entry |
| object_types_header += ' = %d,\n' % enum_num |
| enum_num += 1 |
| type_list.append(enum_entry) |
| object_types_header += ' kVulkanObjectTypeMax = %d,\n' % enum_num |
| object_types_header += '} VulkanObjectType;\n\n' |
| |
| # Output name string helper |
| object_types_header += '// Array of object name strings for OBJECT_TYPE enum conversion\n' |
| object_types_header += 'static const char * const object_string[kVulkanObjectTypeMax] = {\n' |
| object_types_header += ' "Unknown",\n' |
| for item in self.object_types: |
| fixup_name = item[2:] |
| object_types_header += ' "%s",\n' % fixup_name |
| object_types_header += '};\n' |
| |
| # Output a conversion routine from the layer object definitions to the debug report definitions |
| object_types_header += '\n' |
| object_types_header += '// Helper array to get Vulkan VK_EXT_debug_report object type enum from the internal layers version\n' |
| object_types_header += 'const VkDebugReportObjectTypeEXT get_debug_report_enum[] = {\n' |
| object_types_header += ' VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, // No Match\n' |
| for object_type in type_list: |
| search_type = object_type.replace("kVulkanObjectType", "").lower() |
| for vk_object_type in self.debug_report_object_types: |
| target_type = vk_object_type.replace("VK_DEBUG_REPORT_OBJECT_TYPE_", "").lower() |
| target_type = target_type[:-4] |
| target_type = target_type.replace("_", "") |
| if search_type == target_type: |
| object_types_header += ' %s, // %s\n' % (vk_object_type, object_type) |
| break |
| object_types_header += '};\n' |
| |
| # Output a conversion routine from the layer object definitions to the core object type definitions |
| object_types_header += '\n' |
| object_types_header += '// Helper array to get Official Vulkan VkObjectType enum from the internal layers version\n' |
| object_types_header += 'const VkObjectType get_object_type_enum[] = {\n' |
| object_types_header += ' VK_OBJECT_TYPE_UNKNOWN, // No Match\n' |
| for object_type in type_list: |
| search_type = object_type.replace("kVulkanObjectType", "").lower() |
| for vk_object_type in self.core_object_types: |
| target_type = vk_object_type.replace("VK_OBJECT_TYPE_", "").lower() |
| target_type = target_type.replace("_", "") |
| if search_type == target_type: |
| object_types_header += ' %s, // %s\n' % (vk_object_type, object_type) |
| break |
| 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 += '\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 != 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 != 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 != 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 != 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 == 'struct_size_header': |
| return self.GenerateStructSizeHelperHeader() |
| elif self.helper_file_type == 'struct_size_source': |
| return self.GenerateStructSizeHelperSource() |
| 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': |
| 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 |
| |
