scripts/vulkan_tools_helper_file_generator.py

   1 #!/usr/bin/python3 -i
   2 #
   3 # Copyright (c) 2015-2017 The Khronos Group Inc.
   4 # Copyright (c) 2015-2017 Valve Corporation
   5 # Copyright (c) 2015-2017 LunarG, Inc.
   6 # Copyright (c) 2015-2017 Google Inc.
   7 #
   8 # Licensed under the Apache License, Version 2.0 (the "License");
   9 # you may not use this file except in compliance with the License.
  10 # You may obtain a copy of the License at
  11 #
  12 #     http://www.apache.org/licenses/LICENSE-2.0
  13 #
  14 # Unless required by applicable law or agreed to in writing, software
  15 # distributed under the License is distributed on an "AS IS" BASIS,
  16 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17 # See the License for the specific language governing permissions and
  18 # limitations under the License.
  19 #
  20 # Author: Mark Lobodzinski <mark@lunarg.com>
  21 # Author: Tobin Ehlis <tobine@google.com>
  22 # Author: John Zulauf <jzulauf@lunarg.com>
  23
  24 import os,re,sys
  25 import xml.etree.ElementTree as etree
  26 from generator import *
  27 from collections import namedtuple
  28 from common_codegen import *
  29
  30 #
  31 # HelperFileOutputGeneratorOptions - subclass of GeneratorOptions.
  32 class HelperFileOutputGeneratorOptions(GeneratorOptions):
  33     def __init__(self,
  34                  conventions = None,
  35                  filename = None,
  36                  directory = '.',
  37                  apiname = None,
  38                  profile = None,
  39                  versions = '.*',
  40                  emitversions = '.*',
  41                  defaultExtensions = None,
  42                  addExtensions = None,
  43                  removeExtensions = None,
  44                  emitExtensions = None,
  45                  sortProcedure = regSortFeatures,
  46                  prefixText = "",
  47                  genFuncPointers = True,
  48                  protectFile = True,
  49                  protectFeature = True,
  50                  apicall = '',
  51                  apientry = '',
  52                  apientryp = '',
  53                  alignFuncParam = 0,
  54                  library_name = '',
  55                  expandEnumerants = True,
  56                  helper_file_type = ''):
  57         GeneratorOptions.__init__(self,
  58                  conventions = conventions,
  59                  filename = filename,
  60                  directory = directory,
  61                  apiname = apiname,
  62                  profile = profile,
  63                  versions = versions,
  64                  emitversions = emitversions,
  65                  defaultExtensions = defaultExtensions,
  66                  addExtensions = addExtensions,
  67                  removeExtensions = removeExtensions,
  68                  emitExtensions = emitExtensions,
  69                  sortProcedure = sortProcedure)
  70         self.prefixText       = prefixText
  71         self.genFuncPointers  = genFuncPointers
  72         self.protectFile      = protectFile
  73         self.protectFeature   = protectFeature
  74         self.apicall          = apicall
  75         self.apientry         = apientry
  76         self.apientryp        = apientryp
  77         self.alignFuncParam   = alignFuncParam
  78         self.library_name     = library_name
  79         self.helper_file_type = helper_file_type
  80 #
  81 # HelperFileOutputGenerator - subclass of OutputGenerator. Outputs Vulkan helper files
  82 class HelperFileOutputGenerator(OutputGenerator):
  83     """Generate helper file based on XML element attributes"""
  84     def __init__(self,
  85                  errFile = sys.stderr,
  86                  warnFile = sys.stderr,
  87                  diagFile = sys.stdout):
  88         OutputGenerator.__init__(self, errFile, warnFile, diagFile)
  89         # Internal state - accumulators for different inner block text
  90         self.enum_output = ''                             # string built up of enum string routines
  91         # Internal state - accumulators for different inner block text
  92         self.structNames = []                             # List of Vulkan struct typenames
  93         self.structTypes = dict()                         # Map of Vulkan struct typename to required VkStructureType
  94         self.structMembers = []                           # List of StructMemberData records for all Vulkan structs
  95         self.object_types = []                            # List of all handle types
  96         self.object_type_aliases = []                     # Aliases to handles types (for handles that were extensions)
  97         self.debug_report_object_types = []               # Handy copy of debug_report_object_type enum data
  98         self.core_object_types = []                       # Handy copy of core_object_type enum data
  99         self.device_extension_info = dict()               # Dict of device extension name defines and ifdef values
 100         self.instance_extension_info = dict()             # Dict of instance extension name defines and ifdef values
 101
 102         # Named tuples to store struct and command data
 103         self.StructType = namedtuple('StructType', ['name', 'value'])
 104         self.CommandParam = namedtuple('CommandParam', ['type', 'name', 'ispointer', 'isstaticarray', 'isconst', 'iscount', 'len', 'extstructs', 'cdecl'])
 105         self.StructMemberData = namedtuple('StructMemberData', ['name', 'members', 'ifdef_protect'])
 106
 107         self.custom_construct_params = {
 108             # safe_VkGraphicsPipelineCreateInfo needs to know if subpass has color and\or depth\stencil attachments to use its pointers
 109             'VkGraphicsPipelineCreateInfo' :
 110                 ', const bool uses_color_attachment, const bool uses_depthstencil_attachment',
 111             # safe_VkPipelineViewportStateCreateInfo needs to know if viewport and scissor is dynamic to use its pointers
 112             'VkPipelineViewportStateCreateInfo' :
 113                 ', const bool is_dynamic_viewports, const bool is_dynamic_scissors',
 114         }
 115     #
 116     # Called once at the beginning of each run
 117     def beginFile(self, genOpts):
 118         OutputGenerator.beginFile(self, genOpts)
 119         # User-supplied prefix text, if any (list of strings)
 120         self.helper_file_type = genOpts.helper_file_type
 121         self.library_name = genOpts.library_name
 122         # File Comment
 123         file_comment = '// *** THIS FILE IS GENERATED - DO NOT EDIT ***\n'
 124         file_comment += '// See vulkan_tools_helper_file_generator.py for modifications\n'
 125         write(file_comment, file=self.outFile)
 126         # Copyright Notice
 127         copyright = ''
 128         copyright += '\n'
 129         copyright += '/***************************************************************************\n'
 130         copyright += ' *\n'
 131         copyright += ' * Copyright (c) 2015-2017 The Khronos Group Inc.\n'
 132         copyright += ' * Copyright (c) 2015-2017 Valve Corporation\n'
 133         copyright += ' * Copyright (c) 2015-2017 LunarG, Inc.\n'
 134         copyright += ' * Copyright (c) 2015-2017 Google Inc.\n'
 135         copyright += ' *\n'
 136         copyright += ' * Licensed under the Apache License, Version 2.0 (the "License");\n'
 137         copyright += ' * you may not use this file except in compliance with the License.\n'
 138         copyright += ' * You may obtain a copy of the License at\n'
 139         copyright += ' *\n'
 140         copyright += ' *     http://www.apache.org/licenses/LICENSE-2.0\n'
 141         copyright += ' *\n'
 142         copyright += ' * Unless required by applicable law or agreed to in writing, software\n'
 143         copyright += ' * distributed under the License is distributed on an "AS IS" BASIS,\n'
 144         copyright += ' * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n'
 145         copyright += ' * See the License for the specific language governing permissions and\n'
 146         copyright += ' * limitations under the License.\n'
 147         copyright += ' *\n'
 148         copyright += ' * Author: Mark Lobodzinski <mark@lunarg.com>\n'
 149         copyright += ' * Author: Courtney Goeltzenleuchter <courtneygo@google.com>\n'
 150         copyright += ' * Author: Tobin Ehlis <tobine@google.com>\n'
 151         copyright += ' * Author: Chris Forbes <chrisforbes@google.com>\n'
 152         copyright += ' * Author: John Zulauf<jzulauf@lunarg.com>\n'
 153         copyright += ' *\n'
 154         copyright += ' ****************************************************************************/\n'
 155         write(copyright, file=self.outFile)
 156     #
 157     # Write generated file content to output file
 158     def endFile(self):
 159         dest_file = ''
 160         dest_file += self.OutputDestFile()
 161         # Remove blank lines at EOF
 162         if dest_file.endswith('\n'):
 163             dest_file = dest_file[:-1]
 164         write(dest_file, file=self.outFile);
 165         # Finish processing in superclass
 166         OutputGenerator.endFile(self)
 167     #
 168     # Override parent class to be notified of the beginning of an extension
 169     def beginFeature(self, interface, emit):
 170         # Start processing in superclass
 171         OutputGenerator.beginFeature(self, interface, emit)
 172         self.featureExtraProtect = GetFeatureProtect(interface)
 173
 174         if interface.tag != 'extension':
 175             return
 176         name = self.featureName
 177         nameElem = interface[0][1]
 178         name_define = nameElem.get('name')
 179         if 'EXTENSION_NAME' not in name_define:
 180             print("Error in vk.xml file -- extension name is not available")
 181         requires = interface.get('requires')
 182         if requires is not None:
 183             required_extensions = requires.split(',')
 184         else:
 185             required_extensions = list()
 186         info = { 'define': name_define, 'ifdef':self.featureExtraProtect, 'reqs':required_extensions }
 187         if interface.get('type') == 'instance':
 188             self.instance_extension_info[name] = info
 189         else:
 190             self.device_extension_info[name] = info
 191
 192     #
 193     # Override parent class to be notified of the end of an extension
 194     def endFeature(self):
 195         # Finish processing in superclass
 196         OutputGenerator.endFeature(self)
 197     #
 198     # Grab group (e.g. C "enum" type) info to output for enum-string conversion helper
 199     def genGroup(self, groupinfo, groupName, alias):
 200         OutputGenerator.genGroup(self, groupinfo, groupName, alias)
 201         groupElem = groupinfo.elem
 202         # For enum_string_header
 203         if self.helper_file_type == 'enum_string_header':
 204             value_set = set()
 205             for elem in groupElem.findall('enum'):
 206                 if elem.get('supported') != 'disabled' and elem.get('alias') == None:
 207                     value_set.add(elem.get('name'))
 208             self.enum_output += self.GenerateEnumStringConversion(groupName, value_set)
 209         elif self.helper_file_type == 'object_types_header':
 210             if groupName == 'VkDebugReportObjectTypeEXT':
 211                 for elem in groupElem.findall('enum'):
 212                     if elem.get('supported') != 'disabled':
 213                         item_name = elem.get('name')
 214                         self.debug_report_object_types.append(item_name)
 215             elif groupName == 'VkObjectType':
 216                 for elem in groupElem.findall('enum'):
 217                     if elem.get('supported') != 'disabled':
 218                         item_name = elem.get('name')
 219                         self.core_object_types.append(item_name)
 220
 221     #
 222     # Called for each type -- if the type is a struct/union, grab the metadata
 223     def genType(self, typeinfo, name, alias):
 224         OutputGenerator.genType(self, typeinfo, name, alias)
 225         typeElem = typeinfo.elem
 226         # If the type is a struct type, traverse the imbedded <member> tags generating a structure.
 227         # Otherwise, emit the tag text.
 228         category = typeElem.get('category')
 229         if category == 'handle':
 230             if alias:
 231                 self.object_type_aliases.append((name,alias))
 232             else:
 233                 self.object_types.append(name)
 234         elif (category == 'struct' or category == 'union'):
 235             self.structNames.append(name)
 236             self.genStruct(typeinfo, name, alias)
 237     #
 238     # Check if the parameter passed in is a pointer
 239     def paramIsPointer(self, param):
 240         ispointer = False
 241         for elem in param:
 242             if ((elem.tag is not 'type') and (elem.tail is not None)) and '*' in elem.tail:
 243                 ispointer = True
 244         return ispointer
 245     #
 246     # Check if the parameter passed in is a static array
 247     def paramIsStaticArray(self, param):
 248         isstaticarray = 0
 249         paramname = param.find('name')
 250         if (paramname.tail is not None) and ('[' in paramname.tail):
 251             isstaticarray = paramname.tail.count('[')
 252         return isstaticarray
 253     #
 254     # Retrieve the type and name for a parameter
 255     def getTypeNameTuple(self, param):
 256         type = ''
 257         name = ''
 258         for elem in param:
 259             if elem.tag == 'type':
 260                 type = noneStr(elem.text)
 261             elif elem.tag == 'name':
 262                 name = noneStr(elem.text)
 263         return (type, name)
 264     # Extract length values from latexmath.  Currently an inflexible solution that looks for specific
 265     # patterns that are found in vk.xml.  Will need to be updated when new patterns are introduced.
 266     def parseLateXMath(self, source):
 267         name = 'ERROR'
 268         decoratedName = 'ERROR'
 269         if 'mathit' in source:
 270             # Matches expressions similar to 'latexmath:[\lceil{\mathit{rasterizationSamples} \over 32}\rceil]'
 271             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)
 272             if not match or match.group(1) != match.group(4):
 273                 raise 'Unrecognized latexmath expression'
 274             name = match.group(2)
 275             # Need to add 1 for ceiling function; otherwise, the allocated packet
 276             # size will be less than needed during capture for some title which use
 277             # this in VkPipelineMultisampleStateCreateInfo. based on ceiling function
 278             # definition,it is '{0}%{1}?{0}/{1} + 1:{0}/{1}'.format(*match.group(2, 3)),
 279             # its value <= '{}/{} + 1'.
 280             if match.group(1) == 'ceil':
 281                 decoratedName = '{}/{} + 1'.format(*match.group(2, 3))
 282             else:
 283                 decoratedName = '{}/{}'.format(*match.group(2, 3))
 284         else:
 285             # Matches expressions similar to 'latexmath : [dataSize \over 4]'
 286             match = re.match(r'latexmath\s*\:\s*\[\s*(\\textrm\{)?(\w+)\}?\s*\\over\s*(\d+)\s*\]', source)
 287             name = match.group(2)
 288             decoratedName = '{}/{}'.format(*match.group(2, 3))
 289         return name, decoratedName
 290     #
 291     # Retrieve the value of the len tag
 292     def getLen(self, param):
 293         result = None
 294         len = param.attrib.get('len')
 295         if len and len != 'null-terminated':
 296             # For string arrays, 'len' can look like 'count,null-terminated', indicating that we
 297             # have a null terminated array of strings.  We strip the null-terminated from the
 298             # 'len' field and only return the parameter specifying the string count
 299             if 'null-terminated' in len:
 300                 result = len.split(',')[0]
 301             else:
 302                 result = len
 303             if 'latexmath' in len:
 304                 param_type, param_name = self.getTypeNameTuple(param)
 305                 len_name, result = self.parseLateXMath(len)
 306             # Spec has now notation for len attributes, using :: instead of platform specific pointer symbol
 307             result = str(result).replace('::', '->')
 308         return result
 309     #
 310     # Check if a structure is or contains a dispatchable (dispatchable = True) or
 311     # non-dispatchable (dispatchable = False) handle
 312     def TypeContainsObjectHandle(self, handle_type, dispatchable):
 313         if dispatchable:
 314             type_key = 'VK_DEFINE_HANDLE'
 315         else:
 316             type_key = 'VK_DEFINE_NON_DISPATCHABLE_HANDLE'
 317         handle = self.registry.tree.find("types/type/[name='" + handle_type + "'][@category='handle']")
 318         if handle is not None and handle.find('type').text == type_key:
 319             return True
 320         # if handle_type is a struct, search its members
 321         if handle_type in self.structNames:
 322             member_index = next((i for i, v in enumerate(self.structMembers) if v[0] == handle_type), None)
 323             if member_index is not None:
 324                 for item in self.structMembers[member_index].members:
 325                     handle = self.registry.tree.find("types/type/[name='" + item.type + "'][@category='handle']")
 326                     if handle is not None and handle.find('type').text == type_key:
 327                         return True
 328         return False
 329     #
 330     # Generate local ready-access data describing Vulkan structures and unions from the XML metadata
 331     def genStruct(self, typeinfo, typeName, alias):
 332         OutputGenerator.genStruct(self, typeinfo, typeName, alias)
 333         members = typeinfo.elem.findall('.//member')
 334         # Iterate over members once to get length parameters for arrays
 335         lens = set()
 336         for member in members:
 337             len = self.getLen(member)
 338             if len:
 339                 lens.add(len)
 340         # Generate member info
 341         membersInfo = []
 342         for member in members:
 343             # Get the member's type and name
 344             info = self.getTypeNameTuple(member)
 345             type = info[0]
 346             name = info[1]
 347             cdecl = self.makeCParamDecl(member, 1)
 348             # Process VkStructureType
 349             if type == 'VkStructureType':
 350                 # Extract the required struct type value from the comments
 351                 # embedded in the original text defining the 'typeinfo' element
 352                 rawXml = etree.tostring(typeinfo.elem).decode('ascii')
 353                 result = re.search(r'VK_STRUCTURE_TYPE_\w+', rawXml)
 354                 if result:
 355                     value = result.group(0)
 356                     # Store the required type value
 357                     self.structTypes[typeName] = self.StructType(name=name, value=value)
 358             # Store pointer/array/string info
 359             isstaticarray = self.paramIsStaticArray(member)
 360             membersInfo.append(self.CommandParam(type=type,
 361                                                  name=name,
 362                                                  ispointer=self.paramIsPointer(member),
 363                                                  isstaticarray=isstaticarray,
 364                                                  isconst=True if 'const' in cdecl else False,
 365                                                  iscount=True if name in lens else False,
 366                                                  len=self.getLen(member),
 367                                                  extstructs=self.registry.validextensionstructs[typeName] if name == 'pNext' else None,
 368                                                  cdecl=cdecl))
 369         self.structMembers.append(self.StructMemberData(name=typeName, members=membersInfo, ifdef_protect=self.featureExtraProtect))
 370     #
 371     # Enum_string_header: Create a routine to convert an enumerated value into a string
 372     def GenerateEnumStringConversion(self, groupName, value_list):
 373         outstring = '\n'
 374         outstring += 'static inline const char* string_%s(%s input_value)\n' % (groupName, groupName)
 375         outstring += '{\n'
 376         outstring += '    switch ((%s)input_value)\n' % groupName
 377         outstring += '    {\n'
 378         for item in value_list:
 379             outstring += '        case %s:\n' % item
 380             outstring += '            return "%s";\n' % item
 381         outstring += '        default:\n'
 382         outstring += '            return "Unhandled %s";\n' % groupName
 383         outstring += '    }\n'
 384         outstring += '}\n'
 385         return outstring
 386     #
 387     # Tack on a helper which, given an index into a VkPhysicalDeviceFeatures structure, will print the corresponding feature name
 388     def DeIndexPhysDevFeatures(self):
 389         pdev_members = None
 390         for name, members, ifdef in self.structMembers:
 391             if name == 'VkPhysicalDeviceFeatures':
 392                 pdev_members = members
 393                 break
 394         deindex = '\n'
 395         deindex += 'static inline const char * GetPhysDevFeatureString(uint32_t index) {\n'
 396         deindex += '    const char * IndexToPhysDevFeatureString[] = {\n'
 397         for feature in pdev_members:
 398             deindex += '        "%s",\n' % feature.name
 399         deindex += '    };\n\n'
 400         deindex += '    return IndexToPhysDevFeatureString[index];\n'
 401         deindex += '}\n'
 402         return deindex
 403     #
 404     # Combine enum string helper header file preamble with body text and return
 405     def GenerateEnumStringHelperHeader(self):
 406             enum_string_helper_header = '\n'
 407             enum_string_helper_header += '#pragma once\n'
 408             enum_string_helper_header += '#ifdef _WIN32\n'
 409             enum_string_helper_header += '#pragma warning( disable : 4065 )\n'
 410             enum_string_helper_header += '#endif\n'
 411             enum_string_helper_header += '\n'
 412             enum_string_helper_header += '#include <vulkan/vulkan.h>\n'
 413             enum_string_helper_header += '\n'
 414             enum_string_helper_header += self.enum_output
 415             enum_string_helper_header += self.DeIndexPhysDevFeatures()
 416             return enum_string_helper_header
 417     #
 418     # Helper function for declaring a counter variable only once
 419     def DeclareCounter(self, string_var, declare_flag):
 420         if declare_flag == False:
 421             string_var += '        uint32_t i = 0;\n'
 422             declare_flag = True
 423         return string_var, declare_flag
 424     #
 425     # Combine safe struct helper header file preamble with body text and return
 426     def GenerateSafeStructHelperHeader(self):
 427         safe_struct_helper_header = '\n'
 428         safe_struct_helper_header += '#pragma once\n'
 429         safe_struct_helper_header += '#include <vulkan/vulkan.h>\n'
 430         safe_struct_helper_header += '\n'
 431         safe_struct_helper_header += self.GenerateSafeStructHeader()
 432         return safe_struct_helper_header
 433     #
 434     # safe_struct header: build function prototypes for header file
 435     def GenerateSafeStructHeader(self):
 436         safe_struct_header = ''
 437         for item in self.structMembers:
 438             if self.NeedSafeStruct(item) == True:
 439                 safe_struct_header += '\n'
 440                 if item.ifdef_protect != None:
 441                     safe_struct_header += '#ifdef %s\n' % item.ifdef_protect
 442                 safe_struct_header += 'struct safe_%s {\n' % (item.name)
 443                 for member in item.members:
 444                     if member.type in self.structNames:
 445                         member_index = next((i for i, v in enumerate(self.structMembers) if v[0] == member.type), None)
 446                         if member_index is not None and self.NeedSafeStruct(self.structMembers[member_index]) == True:
 447                             if member.ispointer:
 448                                 safe_struct_header += '    safe_%s* %s;\n' % (member.type, member.name)
 449                             else:
 450                                 safe_struct_header += '    safe_%s %s;\n' % (member.type, member.name)
 451                             continue
 452                     if member.len is not None and (self.TypeContainsObjectHandle(member.type, True) or self.TypeContainsObjectHandle(member.type, False)):
 453                             safe_struct_header += '    %s* %s;\n' % (member.type, member.name)
 454                     else:
 455                         safe_struct_header += '%s;\n' % member.cdecl
 456                 safe_struct_header += '    safe_%s(const %s* in_struct%s);\n' % (item.name, item.name, self.custom_construct_params.get(item.name, ''))
 457                 safe_struct_header += '    safe_%s(const safe_%s& src);\n' % (item.name, item.name)
 458                 safe_struct_header += '    safe_%s& operator=(const safe_%s& src);\n' % (item.name, item.name)
 459                 safe_struct_header += '    safe_%s();\n' % item.name
 460                 safe_struct_header += '    ~safe_%s();\n' % item.name
 461                 safe_struct_header += '    void initialize(const %s* in_struct%s);\n' % (item.name, self.custom_construct_params.get(item.name, ''))
 462                 safe_struct_header += '    void initialize(const safe_%s* src);\n' % (item.name)
 463                 safe_struct_header += '    %s *ptr() { return reinterpret_cast<%s *>(this); }\n' % (item.name, item.name)
 464                 safe_struct_header += '    %s const *ptr() const { return reinterpret_cast<%s const *>(this); }\n' % (item.name, item.name)
 465                 safe_struct_header += '};\n'
 466                 if item.ifdef_protect != None:
 467                     safe_struct_header += '#endif // %s\n' % item.ifdef_protect
 468         return safe_struct_header
 469     #
 470     # Generate extension helper header file
 471     def GenerateExtensionHelperHeader(self):
 472
 473         V_1_0_instance_extensions_promoted_to_core = [
 474             'vk_khr_device_group_creation',
 475             'vk_khr_external_fence_capabilities',
 476             'vk_khr_external_memory_capabilities',
 477             'vk_khr_external_semaphore_capabilities',
 478             'vk_khr_get_physical_device_properties_2',
 479             ]
 480
 481         V_1_0_device_extensions_promoted_to_core = [
 482             'vk_khr_16bit_storage',
 483             'vk_khr_bind_memory_2',
 484             'vk_khr_dedicated_allocation',
 485             'vk_khr_descriptor_update_template',
 486             'vk_khr_device_group',
 487             'vk_khr_external_fence',
 488             'vk_khr_external_memory',
 489             'vk_khr_external_semaphore',
 490             'vk_khr_get_memory_requirements_2',
 491             'vk_khr_maintenance1',
 492             'vk_khr_maintenance2',
 493             'vk_khr_maintenance3',
 494             'vk_khr_multiview',
 495             'vk_khr_relaxed_block_layout',
 496             'vk_khr_sampler_ycbcr_conversion',
 497             'vk_khr_shader_draw_parameters',
 498             'vk_khr_storage_buffer_storage_class',
 499             'vk_khr_variable_pointers',
 500             ]
 501
 502         output = [
 503             '',
 504             '#ifndef VK_EXTENSION_HELPER_H_',
 505             '#define VK_EXTENSION_HELPER_H_',
 506             '#include <string>',
 507             '#include <unordered_map>',
 508             '#include <utility>',
 509             '',
 510             '#include <vulkan/vulkan.h>',
 511             '']
 512
 513         def guarded(ifdef, value):
 514             if ifdef is not None:
 515                 return '\n'.join([ '#ifdef %s' % ifdef, value, '#endif' ])
 516             else:
 517                 return value
 518
 519         for type in ['Instance', 'Device']:
 520             struct_type = '%sExtensions' % type
 521             if type == 'Instance':
 522                 extension_dict = self.instance_extension_info
 523                 promoted_ext_list = V_1_0_instance_extensions_promoted_to_core
 524                 struct_decl = 'struct %s {' % struct_type
 525                 instance_struct_type = struct_type
 526             else:
 527                 extension_dict = self.device_extension_info
 528                 promoted_ext_list = V_1_0_device_extensions_promoted_to_core
 529                 struct_decl = 'struct %s : public %s {' % (struct_type, instance_struct_type)
 530
 531             extension_items = sorted(extension_dict.items())
 532
 533             field_name = { ext_name: re.sub('_extension_name', '', info['define'].lower()) for ext_name, info in extension_items }
 534             if type == 'Instance':
 535                 instance_field_name = field_name
 536                 instance_extension_dict = extension_dict
 537             else:
 538                 # Get complete field name and extension data for both Instance and Device extensions
 539                 field_name.update(instance_field_name)
 540                 extension_dict = extension_dict.copy()  # Don't modify the self.<dict> we're pointing to
 541                 extension_dict.update(instance_extension_dict)
 542
 543             # Output the data member list
 544             struct  = [struct_decl]
 545             struct.extend([ '    bool %s{false};' % field_name[ext_name] for ext_name, info in extension_items])
 546
 547             # Construct the extension information map -- mapping name to data member (field), and required extensions
 548             # The map is contained within a static function member for portability reasons.
 549             info_type = '%sInfo' % type
 550             info_map_type = '%sMap' % info_type
 551             req_type = '%sReq' % type
 552             req_vec_type = '%sVec' % req_type
 553             struct.extend([
 554                 '',
 555                 '    struct %s {' % req_type,
 556                 '        const bool %s::* enabled;' % struct_type,
 557                 '        const char *name;',
 558                 '    };',
 559                 '    typedef std::vector<%s> %s;' % (req_type, req_vec_type),
 560                 '    struct %s {' % info_type,
 561                 '       %s(bool %s::* state_, const %s requires_): state(state_), requires(requires_) {}' % ( info_type, struct_type, req_vec_type),
 562                 '       bool %s::* state;' % struct_type,
 563                 '       %s requires;' % req_vec_type,
 564                 '    };',
 565                 '',
 566                 '    typedef std::unordered_map<std::string,%s> %s;' % (info_type, info_map_type),
 567                 '    static const %s &get_info(const char *name) {' %info_type,
 568                 '        static const %s info_map = {' % info_map_type ])
 569
 570             field_format = '&' + struct_type + '::%s'
 571             req_format = '{' + field_format+ ', %s}'
 572             req_indent = '\n                           '
 573             req_join = ',' + req_indent
 574             info_format = ('            std::make_pair(%s, ' + info_type + '(' + field_format + ', {%s})),')
 575             def format_info(ext_name, info):
 576                 reqs = req_join.join([req_format % (field_name[req], extension_dict[req]['define']) for req in info['reqs']])
 577                 return info_format % (info['define'], field_name[ext_name], '{%s}' % (req_indent + reqs) if reqs else '')
 578
 579             struct.extend([guarded(info['ifdef'], format_info(ext_name, info)) for ext_name, info in extension_items])
 580             struct.extend([
 581                 '        };',
 582                 '',
 583                 '        static const %s empty_info {nullptr, %s()};' % (info_type, req_vec_type),
 584                 '        %s::const_iterator info = info_map.find(name);' % info_map_type,
 585                 '        if ( info != info_map.cend()) {',
 586                 '            return info->second;',
 587                 '        }',
 588                 '        return empty_info;',
 589                 '    }',
 590                 ''])
 591
 592             if type == 'Instance':
 593                 struct.extend([
 594                     '    uint32_t NormalizeApiVersion(uint32_t specified_version) {',
 595                     '        uint32_t api_version = (specified_version < VK_API_VERSION_1_1) ? VK_API_VERSION_1_0 : VK_API_VERSION_1_1;',
 596                     '        return api_version;',
 597                     '    }',
 598                     '',
 599                     '    uint32_t InitFromInstanceCreateInfo(uint32_t requested_api_version, const VkInstanceCreateInfo *pCreateInfo) {'])
 600             else:
 601                 struct.extend([
 602                     '    %s() = default;' % struct_type,
 603                     '    %s(const %s& instance_ext) : %s(instance_ext) {}' % (struct_type, instance_struct_type, instance_struct_type),
 604                     '',
 605                     '    uint32_t InitFromDeviceCreateInfo(const %s *instance_extensions, uint32_t requested_api_version,' % instance_struct_type,
 606                     '                                      const VkDeviceCreateInfo *pCreateInfo) {',
 607                     '        // Initialize: this to defaults,  base class fields to input.',
 608                     '        assert(instance_extensions);',
 609                     '        *this = %s(*instance_extensions);' % struct_type])
 610
 611             struct.extend([
 612                 '',
 613                 '        static const std::vector<const char *> V_1_0_promoted_%s_extensions = {' % type.lower() ])
 614             struct.extend(['            %s_EXTENSION_NAME,' % ext_name.upper() for ext_name in promoted_ext_list])
 615             struct.extend([
 616                 '        };',
 617                 '',
 618                 '        // Initialize struct data, robust to invalid pCreateInfo',
 619                 '        if (pCreateInfo->ppEnabledExtensionNames) {',
 620                 '            for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {',
 621                 '                if (!pCreateInfo->ppEnabledExtensionNames[i]) continue;',
 622                 '                auto info = get_info(pCreateInfo->ppEnabledExtensionNames[i]);',
 623                 '                if(info.state) this->*(info.state) = true;',
 624                 '            }',
 625                 '        }',
 626                 '        uint32_t api_version = NormalizeApiVersion(requested_api_version);',
 627                 '        if (api_version >= VK_API_VERSION_1_1) {',
 628                 '            for (auto promoted_ext : V_1_0_promoted_%s_extensions) {' % type.lower(),
 629                 '                auto info = get_info(promoted_ext);',
 630                 '                assert(info.state);',
 631                 '                if (info.state) this->*(info.state) = true;',
 632                 '            }',
 633                 '        }',
 634                 '        return api_version;',
 635                 '    }',
 636                 '};'])
 637
 638             # Output reference lists of instance/device extension names
 639             struct.extend(['', 'static const char * const k%sExtensionNames = ' % type])
 640             struct.extend([guarded(info['ifdef'], '    %s' % info['define']) for ext_name, info in extension_items])
 641             struct.extend([';', ''])
 642             output.extend(struct)
 643
 644         output.extend(['', '#endif // VK_EXTENSION_HELPER_H_'])
 645         return '\n'.join(output)
 646     #
 647     # Combine object types helper header file preamble with body text and return
 648     def GenerateObjectTypesHelperHeader(self):
 649         object_types_helper_header = '\n'
 650         object_types_helper_header += '#pragma once\n'
 651         object_types_helper_header += '\n'
 652         object_types_helper_header += '#include <vulkan/vulkan.h>\n\n'
 653         object_types_helper_header += self.GenerateObjectTypesHeader()
 654         return object_types_helper_header
 655     #
 656     # Object types header: create object enum type header file
 657     def GenerateObjectTypesHeader(self):
 658         object_types_header = ''
 659         object_types_header += '// Object Type enum for validation layer internal object handling\n'
 660         object_types_header += 'typedef enum VulkanObjectType {\n'
 661         object_types_header += '    kVulkanObjectTypeUnknown = 0,\n'
 662         enum_num = 1
 663         type_list = [];
 664         enum_entry_map = {}
 665
 666         # Output enum definition as each handle is processed, saving the names to use for the conversion routine
 667         for item in self.object_types:
 668             fixup_name = item[2:]
 669             enum_entry = 'kVulkanObjectType%s' % fixup_name
 670             enum_entry_map[item] = enum_entry
 671             object_types_header += '    ' + enum_entry
 672             object_types_header += ' = %d,\n' % enum_num
 673             enum_num += 1
 674             type_list.append(enum_entry)
 675         object_types_header += '    kVulkanObjectTypeMax = %d,\n' % enum_num
 676         object_types_header += '    // Aliases for backwards compatibilty of "promoted" types\n'
 677         for (name, alias) in self.object_type_aliases:
 678             fixup_name = name[2:]
 679             object_types_header += '    kVulkanObjectType{} = {},\n'.format(fixup_name, enum_entry_map[alias])
 680         object_types_header += '} VulkanObjectType;\n\n'
 681
 682         # Output name string helper
 683         object_types_header += '// Array of object name strings for OBJECT_TYPE enum conversion\n'
 684         object_types_header += 'static const char * const object_string[kVulkanObjectTypeMax] = {\n'
 685         object_types_header += '    "Unknown",\n'
 686         for item in self.object_types:
 687             fixup_name = item[2:]
 688             object_types_header += '    "%s",\n' % fixup_name
 689         object_types_header += '};\n'
 690
 691         # Key creation helper for map comprehensions that convert between k<Name> and VK<Name> symbols
 692         def to_key(regex, raw_key): return re.search(regex, raw_key).group(1).lower().replace("_","")
 693
 694         # Output a conversion routine from the layer object definitions to the debug report definitions
 695         # As the VK_DEBUG_REPORT types are not being updated, specify UNKNOWN for unmatched types
 696         object_types_header += '\n'
 697         object_types_header += '// Helper array to get Vulkan VK_EXT_debug_report object type enum from the internal layers version\n'
 698         object_types_header += 'const VkDebugReportObjectTypeEXT get_debug_report_enum[] = {\n'
 699         object_types_header += '    VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, // kVulkanObjectTypeUnknown\n'
 700
 701         dbg_re = '^VK_DEBUG_REPORT_OBJECT_TYPE_(.*)_EXT$'
 702         dbg_map = {to_key(dbg_re, dbg) : dbg for dbg in self.debug_report_object_types}
 703         dbg_default = 'VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT'
 704         for object_type in type_list:
 705             vk_object_type = dbg_map.get(object_type.replace("kVulkanObjectType", "").lower(), dbg_default)
 706             object_types_header += '    %s,   // %s\n' % (vk_object_type, object_type)
 707         object_types_header += '};\n'
 708
 709         # Output a conversion routine from the layer object definitions to the core object type definitions
 710         # This will intentionally *fail* for unmatched types as the VK_OBJECT_TYPE list should match the kVulkanObjectType list
 711         object_types_header += '\n'
 712         object_types_header += '// Helper array to get Official Vulkan VkObjectType enum from the internal layers version\n'
 713         object_types_header += 'const VkObjectType get_object_type_enum[] = {\n'
 714         object_types_header += '    VK_OBJECT_TYPE_UNKNOWN, // kVulkanObjectTypeUnknown\n'
 715
 716         vko_re = '^VK_OBJECT_TYPE_(.*)'
 717         vko_map = {to_key(vko_re, vko) : vko for vko in self.core_object_types}
 718         for object_type in type_list:
 719             vk_object_type = vko_map[object_type.replace("kVulkanObjectType", "").lower()]
 720             object_types_header += '    %s,   // %s\n' % (vk_object_type, object_type)
 721         object_types_header += '};\n'
 722
 723         # Create a function to convert from VkDebugReportObjectTypeEXT to VkObjectType
 724         object_types_header += '\n'
 725         object_types_header += '// Helper function to convert from VkDebugReportObjectTypeEXT to VkObjectType\n'
 726         object_types_header += 'static inline VkObjectType convertDebugReportObjectToCoreObject(VkDebugReportObjectTypeEXT debug_report_obj){\n'
 727         object_types_header += '    if (debug_report_obj == VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT) {\n'
 728         object_types_header += '        return VK_OBJECT_TYPE_UNKNOWN;\n'
 729         for core_object_type in self.core_object_types:
 730             core_target_type = core_object_type.replace("VK_OBJECT_TYPE_", "").lower()
 731             core_target_type = core_target_type.replace("_", "")
 732             for dr_object_type in self.debug_report_object_types:
 733                 dr_target_type = dr_object_type.replace("VK_DEBUG_REPORT_OBJECT_TYPE_", "").lower()
 734                 dr_target_type = dr_target_type[:-4]
 735                 dr_target_type = dr_target_type.replace("_", "")
 736                 if core_target_type == dr_target_type:
 737                     object_types_header += '    } else if (debug_report_obj == %s) {\n' % dr_object_type
 738                     object_types_header += '        return %s;\n' % core_object_type
 739                     break
 740         object_types_header += '    }\n'
 741         object_types_header += '    return VK_OBJECT_TYPE_UNKNOWN;\n'
 742         object_types_header += '}\n'
 743
 744         # Create a function to convert from VkObjectType to VkDebugReportObjectTypeEXT
 745         object_types_header += '\n'
 746         object_types_header += '// Helper function to convert from VkDebugReportObjectTypeEXT to VkObjectType\n'
 747         object_types_header += 'static inline VkDebugReportObjectTypeEXT convertCoreObjectToDebugReportObject(VkObjectType core_report_obj){\n'
 748         object_types_header += '    if (core_report_obj == VK_OBJECT_TYPE_UNKNOWN) {\n'
 749         object_types_header += '        return VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT;\n'
 750         for core_object_type in self.core_object_types:
 751             core_target_type = core_object_type.replace("VK_OBJECT_TYPE_", "").lower()
 752             core_target_type = core_target_type.replace("_", "")
 753             for dr_object_type in self.debug_report_object_types:
 754                 dr_target_type = dr_object_type.replace("VK_DEBUG_REPORT_OBJECT_TYPE_", "").lower()
 755                 dr_target_type = dr_target_type[:-4]
 756                 dr_target_type = dr_target_type.replace("_", "")
 757                 if core_target_type == dr_target_type:
 758                     object_types_header += '    } else if (core_report_obj == %s) {\n' % core_object_type
 759                     object_types_header += '        return %s;\n' % dr_object_type
 760                     break
 761         object_types_header += '    }\n'
 762         object_types_header += '    return VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT;\n'
 763         object_types_header += '}\n'
 764         return object_types_header
 765     #
 766     # Determine if a structure needs a safe_struct helper function
 767     # That is, it has an sType or one of its members is a pointer
 768     def NeedSafeStruct(self, structure):
 769         if 'sType' == structure.name:
 770             return True
 771         for member in structure.members:
 772             if member.ispointer == True:
 773                 return True
 774         return False
 775     #
 776     # Combine safe struct helper source file preamble with body text and return
 777     def GenerateSafeStructHelperSource(self):
 778         safe_struct_helper_source = '\n'
 779         safe_struct_helper_source += '#include "vk_safe_struct.h"\n'
 780         safe_struct_helper_source += '#include <string.h>\n'
 781         safe_struct_helper_source += '#ifdef VK_USE_PLATFORM_ANDROID_KHR\n'
 782         safe_struct_helper_source += '#if __ANDROID_API__ < __ANDROID_API_O__\n'
 783         safe_struct_helper_source += 'struct AHardwareBuffer {};\n'
 784         safe_struct_helper_source += '#endif\n'
 785         safe_struct_helper_source += '#endif\n'
 786
 787         safe_struct_helper_source += '\n'
 788         safe_struct_helper_source += self.GenerateSafeStructSource()
 789         return safe_struct_helper_source
 790     #
 791     # safe_struct source -- create bodies of safe struct helper functions
 792     def GenerateSafeStructSource(self):
 793         safe_struct_body = []
 794         wsi_structs = ['VkXlibSurfaceCreateInfoKHR',
 795                        'VkXcbSurfaceCreateInfoKHR',
 796                        'VkWaylandSurfaceCreateInfoKHR',
 797                        'VkMirSurfaceCreateInfoKHR',
 798                        'VkAndroidSurfaceCreateInfoKHR',
 799                        'VkWin32SurfaceCreateInfoKHR'
 800                        ]
 801         for item in self.structMembers:
 802             if self.NeedSafeStruct(item) == False:
 803                 continue
 804             if item.name in wsi_structs:
 805                 continue
 806             if item.ifdef_protect != None:
 807                 safe_struct_body.append("#ifdef %s\n" % item.ifdef_protect)
 808             ss_name = "safe_%s" % item.name
 809             init_list = ''          # list of members in struct constructor initializer
 810             default_init_list = ''  # Default constructor just inits ptrs to nullptr in initializer
 811             init_func_txt = ''      # Txt for initialize() function that takes struct ptr and inits members
 812             construct_txt = ''      # Body of constuctor as well as body of initialize() func following init_func_txt
 813             destruct_txt = ''
 814
 815             custom_construct_txt = {
 816                 # VkWriteDescriptorSet is special case because pointers may be non-null but ignored
 817                 'VkWriteDescriptorSet' :
 818                     '    switch (descriptorType) {\n'
 819                     '        case VK_DESCRIPTOR_TYPE_SAMPLER:\n'
 820                     '        case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:\n'
 821                     '        case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:\n'
 822                     '        case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:\n'
 823                     '        case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:\n'
 824                     '        if (descriptorCount && in_struct->pImageInfo) {\n'
 825                     '            pImageInfo = new VkDescriptorImageInfo[descriptorCount];\n'
 826                     '            for (uint32_t i=0; i<descriptorCount; ++i) {\n'
 827                     '                pImageInfo[i] = in_struct->pImageInfo[i];\n'
 828                     '            }\n'
 829                     '        }\n'
 830                     '        break;\n'
 831                     '        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:\n'
 832                     '        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:\n'
 833                     '        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:\n'
 834                     '        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:\n'
 835                     '        if (descriptorCount && in_struct->pBufferInfo) {\n'
 836                     '            pBufferInfo = new VkDescriptorBufferInfo[descriptorCount];\n'
 837                     '            for (uint32_t i=0; i<descriptorCount; ++i) {\n'
 838                     '                pBufferInfo[i] = in_struct->pBufferInfo[i];\n'
 839                     '            }\n'
 840                     '        }\n'
 841                     '        break;\n'
 842                     '        case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:\n'
 843                     '        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:\n'
 844                     '        if (descriptorCount && in_struct->pTexelBufferView) {\n'
 845                     '            pTexelBufferView = new VkBufferView[descriptorCount];\n'
 846                     '            for (uint32_t i=0; i<descriptorCount; ++i) {\n'
 847                     '                pTexelBufferView[i] = in_struct->pTexelBufferView[i];\n'
 848                     '            }\n'
 849                     '        }\n'
 850                     '        break;\n'
 851                     '        default:\n'
 852                     '        break;\n'
 853                     '    }\n',
 854                 'VkShaderModuleCreateInfo' :
 855                     '    if (in_struct->pCode) {\n'
 856                     '        pCode = reinterpret_cast<uint32_t *>(new uint8_t[codeSize]);\n'
 857                     '        memcpy((void *)pCode, (void *)in_struct->pCode, codeSize);\n'
 858                     '    }\n',
 859                 # VkGraphicsPipelineCreateInfo is special case because its pointers may be non-null but ignored
 860                 'VkGraphicsPipelineCreateInfo' :
 861                     '    if (stageCount && in_struct->pStages) {\n'
 862                     '        pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];\n'
 863                     '        for (uint32_t i=0; i<stageCount; ++i) {\n'
 864                     '            pStages[i].initialize(&in_struct->pStages[i]);\n'
 865                     '        }\n'
 866                     '    }\n'
 867                     '    if (in_struct->pVertexInputState)\n'
 868                     '        pVertexInputState = new safe_VkPipelineVertexInputStateCreateInfo(in_struct->pVertexInputState);\n'
 869                     '    else\n'
 870                     '        pVertexInputState = NULL;\n'
 871                     '    if (in_struct->pInputAssemblyState)\n'
 872                     '        pInputAssemblyState = new safe_VkPipelineInputAssemblyStateCreateInfo(in_struct->pInputAssemblyState);\n'
 873                     '    else\n'
 874                     '        pInputAssemblyState = NULL;\n'
 875                     '    bool has_tessellation_stage = false;\n'
 876                     '    if (stageCount && pStages)\n'
 877                     '        for (uint32_t i=0; i<stageCount && !has_tessellation_stage; ++i)\n'
 878                     '            if (pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT || pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT)\n'
 879                     '                has_tessellation_stage = true;\n'
 880                     '    if (in_struct->pTessellationState && has_tessellation_stage)\n'
 881                     '        pTessellationState = new safe_VkPipelineTessellationStateCreateInfo(in_struct->pTessellationState);\n'
 882                     '    else\n'
 883                     '        pTessellationState = NULL; // original pTessellationState pointer ignored\n'
 884                     '    bool has_rasterization = in_struct->pRasterizationState ? !in_struct->pRasterizationState->rasterizerDiscardEnable : false;\n'
 885                     '    if (in_struct->pViewportState && has_rasterization) {\n'
 886                     '        bool is_dynamic_viewports = false;\n'
 887                     '        bool is_dynamic_scissors = false;\n'
 888                     '        if (in_struct->pDynamicState && in_struct->pDynamicState->pDynamicStates) {\n'
 889                     '            for (uint32_t i = 0; i < in_struct->pDynamicState->dynamicStateCount && !is_dynamic_viewports; ++i)\n'
 890                     '                if (in_struct->pDynamicState->pDynamicStates[i] == VK_DYNAMIC_STATE_VIEWPORT)\n'
 891                     '                    is_dynamic_viewports = true;\n'
 892                     '            for (uint32_t i = 0; i < in_struct->pDynamicState->dynamicStateCount && !is_dynamic_scissors; ++i)\n'
 893                     '                if (in_struct->pDynamicState->pDynamicStates[i] == VK_DYNAMIC_STATE_SCISSOR)\n'
 894                     '                    is_dynamic_scissors = true;\n'
 895                     '        }\n'
 896                     '        pViewportState = new safe_VkPipelineViewportStateCreateInfo(in_struct->pViewportState, is_dynamic_viewports, is_dynamic_scissors);\n'
 897                     '    } else\n'
 898                     '        pViewportState = NULL; // original pViewportState pointer ignored\n'
 899                     '    if (in_struct->pRasterizationState)\n'
 900                     '        pRasterizationState = new safe_VkPipelineRasterizationStateCreateInfo(in_struct->pRasterizationState);\n'
 901                     '    else\n'
 902                     '        pRasterizationState = NULL;\n'
 903                     '    if (in_struct->pMultisampleState && has_rasterization)\n'
 904                     '        pMultisampleState = new safe_VkPipelineMultisampleStateCreateInfo(in_struct->pMultisampleState);\n'
 905                     '    else\n'
 906                     '        pMultisampleState = NULL; // original pMultisampleState pointer ignored\n'
 907                     '    // needs a tracked subpass state uses_depthstencil_attachment\n'
 908                     '    if (in_struct->pDepthStencilState && has_rasterization && uses_depthstencil_attachment)\n'
 909                     '        pDepthStencilState = new safe_VkPipelineDepthStencilStateCreateInfo(in_struct->pDepthStencilState);\n'
 910                     '    else\n'
 911                     '        pDepthStencilState = NULL; // original pDepthStencilState pointer ignored\n'
 912                     '    // needs a tracked subpass state usesColorAttachment\n'
 913                     '    if (in_struct->pColorBlendState && has_rasterization && uses_color_attachment)\n'
 914                     '        pColorBlendState = new safe_VkPipelineColorBlendStateCreateInfo(in_struct->pColorBlendState);\n'
 915                     '    else\n'
 916                     '        pColorBlendState = NULL; // original pColorBlendState pointer ignored\n'
 917                     '    if (in_struct->pDynamicState)\n'
 918                     '        pDynamicState = new safe_VkPipelineDynamicStateCreateInfo(in_struct->pDynamicState);\n'
 919                     '    else\n'
 920                     '        pDynamicState = NULL;\n',
 921                  # VkPipelineViewportStateCreateInfo is special case because its pointers may be non-null but ignored
 922                 'VkPipelineViewportStateCreateInfo' :
 923                     '    if (in_struct->pViewports && !is_dynamic_viewports) {\n'
 924                     '        pViewports = new VkViewport[in_struct->viewportCount];\n'
 925                     '        memcpy ((void *)pViewports, (void *)in_struct->pViewports, sizeof(VkViewport)*in_struct->viewportCount);\n'
 926                     '    }\n'
 927                     '    else\n'
 928                     '        pViewports = NULL;\n'
 929                     '    if (in_struct->pScissors && !is_dynamic_scissors) {\n'
 930                     '        pScissors = new VkRect2D[in_struct->scissorCount];\n'
 931                     '        memcpy ((void *)pScissors, (void *)in_struct->pScissors, sizeof(VkRect2D)*in_struct->scissorCount);\n'
 932                     '    }\n'
 933                     '    else\n'
 934                     '        pScissors = NULL;\n',
 935                 # VkDescriptorSetLayoutBinding is special case because its pImmutableSamplers pointer may be non-null but ignored
 936                 'VkDescriptorSetLayoutBinding' :
 937                     '    const bool sampler_type = in_struct->descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER || in_struct->descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;\n'
 938                     '    if (descriptorCount && in_struct->pImmutableSamplers && sampler_type) {\n'
 939                     '        pImmutableSamplers = new VkSampler[descriptorCount];\n'
 940                     '        for (uint32_t i=0; i<descriptorCount; ++i) {\n'
 941                     '            pImmutableSamplers[i] = in_struct->pImmutableSamplers[i];\n'
 942                     '        }\n'
 943                     '    }\n',
 944             }
 945
 946             custom_copy_txt = {
 947                 # VkGraphicsPipelineCreateInfo is special case because it has custom construct parameters
 948                 'VkGraphicsPipelineCreateInfo' :
 949                     '    if (stageCount && src.pStages) {\n'
 950                     '        pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];\n'
 951                     '        for (uint32_t i=0; i<stageCount; ++i) {\n'
 952                     '            pStages[i].initialize(&src.pStages[i]);\n'
 953                     '        }\n'
 954                     '    }\n'
 955                     '    if (src.pVertexInputState)\n'
 956                     '        pVertexInputState = new safe_VkPipelineVertexInputStateCreateInfo(*src.pVertexInputState);\n'
 957                     '    else\n'
 958                     '        pVertexInputState = NULL;\n'
 959                     '    if (src.pInputAssemblyState)\n'
 960                     '        pInputAssemblyState = new safe_VkPipelineInputAssemblyStateCreateInfo(*src.pInputAssemblyState);\n'
 961                     '    else\n'
 962                     '        pInputAssemblyState = NULL;\n'
 963                     '    bool has_tessellation_stage = false;\n'
 964                     '    if (stageCount && pStages)\n'
 965                     '        for (uint32_t i=0; i<stageCount && !has_tessellation_stage; ++i)\n'
 966                     '            if (pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT || pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT)\n'
 967                     '                has_tessellation_stage = true;\n'
 968                     '    if (src.pTessellationState && has_tessellation_stage)\n'
 969                     '        pTessellationState = new safe_VkPipelineTessellationStateCreateInfo(*src.pTessellationState);\n'
 970                     '    else\n'
 971                     '        pTessellationState = NULL; // original pTessellationState pointer ignored\n'
 972                     '    bool has_rasterization = src.pRasterizationState ? !src.pRasterizationState->rasterizerDiscardEnable : false;\n'
 973                     '    if (src.pViewportState && has_rasterization) {\n'
 974                     '        pViewportState = new safe_VkPipelineViewportStateCreateInfo(*src.pViewportState);\n'
 975                     '    } else\n'
 976                     '        pViewportState = NULL; // original pViewportState pointer ignored\n'
 977                     '    if (src.pRasterizationState)\n'
 978                     '        pRasterizationState = new safe_VkPipelineRasterizationStateCreateInfo(*src.pRasterizationState);\n'
 979                     '    else\n'
 980                     '        pRasterizationState = NULL;\n'
 981                     '    if (src.pMultisampleState && has_rasterization)\n'
 982                     '        pMultisampleState = new safe_VkPipelineMultisampleStateCreateInfo(*src.pMultisampleState);\n'
 983                     '    else\n'
 984                     '        pMultisampleState = NULL; // original pMultisampleState pointer ignored\n'
 985                     '    if (src.pDepthStencilState && has_rasterization)\n'
 986                     '        pDepthStencilState = new safe_VkPipelineDepthStencilStateCreateInfo(*src.pDepthStencilState);\n'
 987                     '    else\n'
 988                     '        pDepthStencilState = NULL; // original pDepthStencilState pointer ignored\n'
 989                     '    if (src.pColorBlendState && has_rasterization)\n'
 990                     '        pColorBlendState = new safe_VkPipelineColorBlendStateCreateInfo(*src.pColorBlendState);\n'
 991                     '    else\n'
 992                     '        pColorBlendState = NULL; // original pColorBlendState pointer ignored\n'
 993                     '    if (src.pDynamicState)\n'
 994                     '        pDynamicState = new safe_VkPipelineDynamicStateCreateInfo(*src.pDynamicState);\n'
 995                     '    else\n'
 996                     '        pDynamicState = NULL;\n',
 997                  # VkPipelineViewportStateCreateInfo is special case because it has custom construct parameters
 998                 'VkPipelineViewportStateCreateInfo' :
 999                     '    if (src.pViewports) {\n'
1000                     '        pViewports = new VkViewport[src.viewportCount];\n'
1001                     '        memcpy ((void *)pViewports, (void *)src.pViewports, sizeof(VkViewport)*src.viewportCount);\n'
1002                     '    }\n'
1003                     '    else\n'
1004                     '        pViewports = NULL;\n'
1005                     '    if (src.pScissors) {\n'
1006                     '        pScissors = new VkRect2D[src.scissorCount];\n'
1007                     '        memcpy ((void *)pScissors, (void *)src.pScissors, sizeof(VkRect2D)*src.scissorCount);\n'
1008                     '    }\n'
1009                     '    else\n'
1010                     '        pScissors = NULL;\n',
1011             }
1012
1013             custom_destruct_txt = {'VkShaderModuleCreateInfo' :
1014                                    '    if (pCode)\n'
1015                                    '        delete[] reinterpret_cast<const uint8_t *>(pCode);\n' }
1016
1017             for member in item.members:
1018                 m_type = member.type
1019                 if member.type in self.structNames:
1020                     member_index = next((i for i, v in enumerate(self.structMembers) if v[0] == member.type), None)
1021                     if member_index is not None and self.NeedSafeStruct(self.structMembers[member_index]) == True:
1022                         m_type = 'safe_%s' % member.type
1023                 if member.ispointer and 'safe_' not in m_type and self.TypeContainsObjectHandle(member.type, False) == False:
1024                     # Ptr types w/o a safe_struct, for non-null case need to allocate new ptr and copy data in
1025                     if m_type in ['void', 'char']:
1026                         # For these exceptions just copy initial value over for now
1027                         init_list += '\n    %s(in_struct->%s),' % (member.name, member.name)
1028                         init_func_txt += '    %s = in_struct->%s;\n' % (member.name, member.name)
1029                     else:
1030                         default_init_list += '\n    %s(nullptr),' % (member.name)
1031                         init_list += '\n    %s(nullptr),' % (member.name)
1032                         init_func_txt += '    %s = nullptr;\n' % (member.name)
1033                         if 'pNext' != member.name and 'void' not in m_type:
1034                             if not member.isstaticarray and (member.len is None or '/' in member.len):
1035                                 construct_txt += '    if (in_struct->%s) {\n' % member.name
1036                                 construct_txt += '        %s = new %s(*in_struct->%s);\n' % (member.name, m_type, member.name)
1037                                 construct_txt += '    }\n'
1038                                 destruct_txt += '    if (%s)\n' % member.name
1039                                 destruct_txt += '        delete %s;\n' % member.name
1040                             else:
1041                                 construct_txt += '    if (in_struct->%s) {\n' % member.name
1042                                 construct_txt += '        %s = new %s[in_struct->%s];\n' % (member.name, m_type, member.len)
1043                                 construct_txt += '        memcpy ((void *)%s, (void *)in_struct->%s, sizeof(%s)*in_struct->%s);\n' % (member.name, member.name, m_type, member.len)
1044                                 construct_txt += '    }\n'
1045                                 destruct_txt += '    if (%s)\n' % member.name
1046                                 destruct_txt += '        delete[] %s;\n' % member.name
1047                 elif member.isstaticarray or member.len is not None:
1048                     if member.len is None:
1049                         # Extract length of static array by grabbing val between []
1050                         static_array_size = re.match(r"[^[]*\[([^]]*)\]", member.cdecl)
1051                         construct_txt += '    for (uint32_t i=0; i<%s; ++i) {\n' % static_array_size.group(1)
1052                         construct_txt += '        %s[i] = in_struct->%s[i];\n' % (member.name, member.name)
1053                         construct_txt += '    }\n'
1054                     else:
1055                         # Init array ptr to NULL
1056                         default_init_list += '\n    %s(nullptr),' % member.name
1057                         init_list += '\n    %s(nullptr),' % member.name
1058                         init_func_txt += '    %s = nullptr;\n' % member.name
1059                         array_element = 'in_struct->%s[i]' % member.name
1060                         if member.type in self.structNames:
1061                             member_index = next((i for i, v in enumerate(self.structMembers) if v[0] == member.type), None)
1062                             if member_index is not None and self.NeedSafeStruct(self.structMembers[member_index]) == True:
1063                                 array_element = '%s(&in_struct->safe_%s[i])' % (member.type, member.name)
1064                         construct_txt += '    if (%s && in_struct->%s) {\n' % (member.len, member.name)
1065                         construct_txt += '        %s = new %s[%s];\n' % (member.name, m_type, member.len)
1066                         destruct_txt += '    if (%s)\n' % member.name
1067                         destruct_txt += '        delete[] %s;\n' % member.name
1068                         construct_txt += '        for (uint32_t i=0; i<%s; ++i) {\n' % (member.len)
1069                         if 'safe_' in m_type:
1070                             construct_txt += '            %s[i].initialize(&in_struct->%s[i]);\n' % (member.name, member.name)
1071                         else:
1072                             construct_txt += '            %s[i] = %s;\n' % (member.name, array_element)
1073                         construct_txt += '        }\n'
1074                         construct_txt += '    }\n'
1075                 elif member.ispointer == True:
1076                     construct_txt += '    if (in_struct->%s)\n' % member.name
1077                     construct_txt += '        %s = new %s(in_struct->%s);\n' % (member.name, m_type, member.name)
1078                     construct_txt += '    else\n'
1079                     construct_txt += '        %s = NULL;\n' % member.name
1080                     destruct_txt += '    if (%s)\n' % member.name
1081                     destruct_txt += '        delete %s;\n' % member.name
1082                 elif 'safe_' in m_type:
1083                     init_list += '\n    %s(&in_struct->%s),' % (member.name, member.name)
1084                     init_func_txt += '    %s.initialize(&in_struct->%s);\n' % (member.name, member.name)
1085                 else:
1086                     init_list += '\n    %s(in_struct->%s),' % (member.name, member.name)
1087                     init_func_txt += '    %s = in_struct->%s;\n' % (member.name, member.name)
1088             if '' != init_list:
1089                 init_list = init_list[:-1] # hack off final comma
1090             if item.name in custom_construct_txt:
1091                 construct_txt = custom_construct_txt[item.name]
1092             if item.name in custom_destruct_txt:
1093                 destruct_txt = custom_destruct_txt[item.name]
1094             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))
1095             if '' != default_init_list:
1096                 default_init_list = " :%s" % (default_init_list[:-1])
1097             safe_struct_body.append("\n%s::%s()%s\n{}" % (ss_name, ss_name, default_init_list))
1098             # Create slight variation of init and construct txt for copy constructor that takes a src object reference vs. struct ptr
1099             copy_construct_init = init_func_txt.replace('in_struct->', 'src.')
1100             copy_construct_txt = construct_txt.replace(' (in_struct->', ' (src.')     # Exclude 'if' blocks from next line
1101             copy_construct_txt = copy_construct_txt.replace('(in_struct->', '(*src.') # Pass object to copy constructors
1102             copy_construct_txt = copy_construct_txt.replace('in_struct->', 'src.')    # Modify remaining struct refs for src object
1103             if item.name in custom_copy_txt:
1104                 copy_construct_txt = custom_copy_txt[item.name]
1105             copy_assign_txt = '    if (&src == this) return *this;\n\n' + destruct_txt + '\n' + copy_construct_init + copy_construct_txt + '\n    return *this;'
1106             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
1107             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
1108             safe_struct_body.append("\n%s::~%s()\n{\n%s}" % (ss_name, ss_name, destruct_txt))
1109             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))
1110             # Copy initializer uses same txt as copy constructor but has a ptr and not a reference
1111             init_copy = copy_construct_init.replace('src.', 'src->')
1112             init_construct = copy_construct_txt.replace('src.', 'src->')
1113             safe_struct_body.append("\nvoid %s::initialize(const %s* src)\n{\n%s%s}" % (ss_name, ss_name, init_copy, init_construct))
1114             if item.ifdef_protect != None:
1115                 safe_struct_body.append("#endif // %s\n" % item.ifdef_protect)
1116         return "\n".join(safe_struct_body)
1117     #
1118     # Generate the type map
1119     def GenerateTypeMapHelperHeader(self):
1120         prefix = 'Lvl'
1121         fprefix = 'lvl_'
1122         typemap = prefix + 'TypeMap'
1123         idmap = prefix + 'STypeMap'
1124         type_member = 'Type'
1125         id_member = 'kSType'
1126         id_decl = 'static const VkStructureType '
1127         generic_header = prefix + 'GenericHeader'
1128         typename_func = fprefix + 'typename'
1129         idname_func = fprefix + 'stype_name'
1130         find_func = fprefix + 'find_in_chain'
1131         init_func = fprefix + 'init_struct'
1132
1133         explanatory_comment = '\n'.join((
1134                 '// These empty generic templates are specialized for each type with sType',
1135                 '// members and for each sType -- providing a two way map between structure',
1136                 '// types and sTypes'))
1137
1138         empty_typemap = 'template <typename T> struct ' + typemap + ' {};'
1139         typemap_format  = 'template <> struct {template}<{typename}> {{\n'
1140         typemap_format += '    {id_decl}{id_member} = {id_value};\n'
1141         typemap_format += '}};\n'
1142
1143         empty_idmap = 'template <VkStructureType id> struct ' + idmap + ' {};'
1144         idmap_format = ''.join((
1145             'template <> struct {template}<{id_value}> {{\n',
1146             '    typedef {typename} {typedef};\n',
1147             '}};\n'))
1148
1149         # Define the utilities (here so any renaming stays consistent), if this grows large, refactor to a fixed .h file
1150         utilities_format = '\n'.join((
1151             '// Header "base class" for pNext chain traversal',
1152             'struct {header} {{',
1153             '   VkStructureType sType;',
1154             '   const {header} *pNext;',
1155             '}};',
1156             '',
1157             '// Find an entry of the given type in the pNext chain',
1158             'template <typename T> const T *{find_func}(const void *next) {{',
1159             '    const {header} *current = reinterpret_cast<const {header} *>(next);',
1160             '    const T *found = nullptr;',
1161             '    while (current) {{',
1162             '        if ({type_map}<T>::{id_member} == current->sType) {{',
1163             '            found = reinterpret_cast<const T*>(current);',
1164             '            current = nullptr;',
1165             '        }} else {{',
1166             '            current = current->pNext;',
1167             '        }}',
1168             '    }}',
1169             '    return found;',
1170             '}}',
1171             '',
1172             '// Init the header of an sType struct with pNext',
1173             'template <typename T> T {init_func}(void *p_next) {{',
1174             '    T out = {{}};',
1175             '    out.sType = {type_map}<T>::kSType;',
1176             '    out.pNext = p_next;',
1177             '    return out;',
1178             '}}',
1179                         '',
1180             '// Init the header of an sType struct',
1181             'template <typename T> T {init_func}() {{',
1182             '    T out = {{}};',
1183             '    out.sType = {type_map}<T>::kSType;',
1184             '    return out;',
1185             '}}',
1186
1187             ''))
1188
1189         code = []
1190
1191         # Generate header
1192         code.append('\n'.join((
1193             '#pragma once',
1194             '#include <vulkan/vulkan.h>\n',
1195             explanatory_comment, '',
1196             empty_idmap,
1197             empty_typemap, '')))
1198
1199         # Generate the specializations for each type and stype
1200         for item in self.structMembers:
1201             typename = item.name
1202             info = self.structTypes.get(typename)
1203             if not info:
1204                 continue
1205
1206             if item.ifdef_protect != None:
1207                 code.append('#ifdef %s' % item.ifdef_protect)
1208
1209             code.append('// Map type {} to id {}'.format(typename, info.value))
1210             code.append(typemap_format.format(template=typemap, typename=typename, id_value=info.value,
1211                 id_decl=id_decl, id_member=id_member))
1212             code.append(idmap_format.format(template=idmap, typename=typename, id_value=info.value, typedef=type_member))
1213
1214             if item.ifdef_protect != None:
1215                 code.append('#endif // %s' % item.ifdef_protect)
1216
1217         # Generate utilities for all types
1218         code.append('\n'.join((
1219             utilities_format.format(id_member=id_member, id_map=idmap, type_map=typemap,
1220                 type_member=type_member, header=generic_header, typename_func=typename_func, idname_func=idname_func,
1221                 find_func=find_func, init_func=init_func), ''
1222             )))
1223
1224         return "\n".join(code)
1225
1226     #
1227     # Create a helper file and return it as a string
1228     def OutputDestFile(self):
1229         if self.helper_file_type == 'enum_string_header':
1230             return self.GenerateEnumStringHelperHeader()
1231         elif self.helper_file_type == 'safe_struct_header':
1232             return self.GenerateSafeStructHelperHeader()
1233         elif self.helper_file_type == 'safe_struct_source':
1234             return self.GenerateSafeStructHelperSource()
1235         elif self.helper_file_type == 'object_types_header':
1236             return self.GenerateObjectTypesHelperHeader()
1237         elif self.helper_file_type == 'extension_helper_header':
1238             return self.GenerateExtensionHelperHeader()
1239         elif self.helper_file_type == 'typemap_helper_header':
1240             return self.GenerateTypeMapHelperHeader()
1241         else:
1242             return 'Bad Helper File Generator Option %s' % self.helper_file_type