vulkan: update to header 1.0.42

Updated all necessary files to 1.0.42. This includes the various headers as well as the loader, and the parameter validation, object tracking, and threading layers. Additionally, bump all layer JSON files to 1.0.42. Also, in this change: - Enable loader extension automation so that the loader now generates all extension entry-points automatically during build to reduce likelihood of missing a critical piece on header update. - Enable layer dispatch table extension automation for the same reason. - Fixes from Mark Lobodzinski and Tony Barbour to resolve crash in loader when working with Intel's Windows driver due to GetInstanceProcAddr getting called on inappropriate command names. Change-Id: Ic18d3fac2e145c386c0192031deb5089c91a00d8
author: Mark Young <marky@lunarg.com> 2017-02-28 09:58:04 -0700
committer: Mark Young <marky@lunarg.com> 2017-03-01 08:20:22 -0700
commit: e2ebfd58c6cfbafbee172093b22e06867e1c3fe6 (patch)
tree: 7617f642ef2cee90b334b8e58455296c0f47df59 /scripts
parent: 9172c7bf11a3dbb663e170f57692e68891e891c9 (diff)
download: usermoji-e2ebfd58c6cfbafbee172093b22e06867e1c3fe6.tar.xz
6 files changed, 2505 insertions, 115 deletions
diff --git a/scripts/dispatch_table_generator.py b/scripts/dispatch_table_helper_generator.py
index 09b9f016..971eba7c 100644
--- a/scripts/dispatch_table_generator.py
+++ b/scripts/dispatch_table_helper_generator.py
@@ -1,9 +1,9 @@
 #!/usr/bin/python3 -i
 #
-# Copyright (c) 2015-2016 The Khronos Group Inc.
-# Copyright (c) 2015-2016 Valve Corporation
-# Copyright (c) 2015-2016 LunarG, Inc.
-# Copyright (c) 2015-2016 Google Inc.
+# 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.
@@ -25,8 +25,8 @@ from generator import *
 from collections import namedtuple
 
 #
-# DispatchTableOutputGeneratorOptions - subclass of GeneratorOptions.
-class DispatchTableOutputGeneratorOptions(GeneratorOptions):
+# DispatchTableHelperOutputGeneratorOptions - subclass of GeneratorOptions.
+class DispatchTableHelperOutputGeneratorOptions(GeneratorOptions):
     def __init__(self,
                  filename = None,
                  directory = '.',
@@ -63,9 +63,9 @@ class DispatchTableOutputGeneratorOptions(GeneratorOptions):
         self.apientryp       = apientryp
         self.alignFuncParam  = alignFuncParam
 #
-# DispatchTableOutputGenerator - subclass of OutputGenerator.
+# DispatchTableHelperOutputGenerator - subclass of OutputGenerator.
 # Generates dispatch table helper header files for LVL
-class DispatchTableOutputGenerator(OutputGenerator):
+class DispatchTableHelperOutputGenerator(OutputGenerator):
     """Generate dispatch table helper header based on XML element attributes"""
     def __init__(self,
                  errFile = sys.stderr,
@@ -85,13 +85,13 @@ class DispatchTableOutputGenerator(OutputGenerator):
                 write(s, file=self.outFile)
         # File Comment
         file_comment = '// *** THIS FILE IS GENERATED - DO NOT EDIT ***\n'
-        file_comment += '// See dispatch_table_generator.py for modifications\n'
+        file_comment += '// See dispatch_helper_generator.py for modifications\n'
         write(file_comment, file=self.outFile)
         # Copyright Notice
         copyright =  '/*\n'
-        copyright += ' * Copyright (c) 2015-2016 The Khronos Group Inc.\n'
-        copyright += ' * Copyright (c) 2015-2016 Valve Corporation\n'
-        copyright += ' * Copyright (c) 2015-2016 LunarG, Inc.\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 += ' *\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'
@@ -123,8 +123,8 @@ class DispatchTableOutputGenerator(OutputGenerator):
         device_table = ''
         instance_table = ''
 
-        device_table += self.OutputDispatchTable('device')
-        instance_table += self.OutputDispatchTable('instance')
+        device_table += self.OutputDispatchTableHelper('device')
+        instance_table += self.OutputDispatchTableHelper('instance')
 
         write(device_table, file=self.outFile);
         write("\n", file=self.outFile)
@@ -170,7 +170,7 @@ class DispatchTableOutputGenerator(OutputGenerator):
         return (type, name)
     #
     # Create a dispatch table from the appropriate list and return it as a string
-    def OutputDispatchTable(self, table_type):
+    def OutputDispatchTableHelper(self, table_type):
         entries = []
         table = ''
         if table_type == 'device':
diff --git a/scripts/helper_file_generator.py b/scripts/helper_file_generator.py
index 39a9aa8c..97fde4be 100644
--- a/scripts/helper_file_generator.py
+++ b/scripts/helper_file_generator.py
@@ -212,7 +212,7 @@ class HelperFileOutputGenerator(OutputGenerator):
             decoratedName = '{}/{}'.format(*match.group(2, 3))
         else:
             # Matches expressions similar to 'latexmath : [dataSize \over 4]'
-            match = re.match(r'latexmath\s*\:\s*\[\s*\s*(\w+)\s*\\over\s*(\d+)\s*\s*\]', source)
+            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
diff --git a/scripts/loader_extension_generator.py b/scripts/loader_extension_generator.py
new file mode 100644
index 00000000..105073d1
--- /dev/null
+++ b/scripts/loader_extension_generator.py
@@ -0,0 +1,1470 @@
+#!/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 Young <marky@lunarg.com>
+
+import os,re,sys
+import xml.etree.ElementTree as etree
+from generator import *
+from collections import namedtuple
+
+WSI_EXT_NAMES = ['VK_KHR_surface',
+                 'VK_KHR_display',
+                 'VK_KHR_xlib_surface',
+                 'VK_KHR_xcb_surface',
+                 'VK_KHR_wayland_surface',
+                 'VK_KHR_mir_surface',
+                 'VK_KHR_win32_surface',
+                 'VK_KHR_android_surface',
+                 'VK_KHR_swapchain',
+                 'VK_KHR_display_swapchain']
+
+AVOID_EXT_NAMES = ['VK_EXT_debug_report']
+
+DEVICE_CMDS_NEED_TERM = ['vkGetDeviceProcAddr',
+                         'vkCreateSwapchainKHR',
+                         'vkCreateSharedSwapchainsKHR',
+                         'vkGetDeviceGroupSurfacePresentModesKHX',
+                         'vkDebugMarkerSetObjectTagEXT',
+                         'vkDebugMarkerSetObjectNameEXT']
+
+#
+# LoaderExtensionGeneratorOptions - subclass of GeneratorOptions.
+class LoaderExtensionGeneratorOptions(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,
+                 currentExtension = '',
+                 extensionOfInterest = 0):
+        GeneratorOptions.__init__(self, filename, directory, apiname, profile,
+                                  versions, emitversions, defaultExtensions,
+                                  addExtensions, removeExtensions, sortProcedure)
+        self.prefixText      = prefixText
+        self.genFuncPointers = genFuncPointers
+        self.prefixText      = None
+        self.protectFile     = protectFile
+        self.protectFeature  = protectFeature
+        self.protectProto    = protectProto
+        self.protectProtoStr = protectProtoStr
+        self.apicall         = apicall
+        self.apientry        = apientry
+        self.apientryp       = apientryp
+        self.alignFuncParam  = alignFuncParam
+#
+# LoaderExtensionOutputGenerator - subclass of OutputGenerator.
+# Generates dispatch table helper header files for LVL
+class LoaderExtensionOutputGenerator(OutputGenerator):
+    """Generate dispatch table helper header 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.ext_instance_dispatch_list = []  # List of extension entries for instance dispatch list
+        self.ext_device_dispatch_list = []    # List of extension entries for device dispatch list
+        self.core_commands = []               # List of CommandData records for core Vulkan commands
+        self.ext_commands = []                # List of CommandData records for extension Vulkan commands
+        self.CommandParam = namedtuple('CommandParam', ['type', 'name', 'cdecl'])
+        self.CommandData = namedtuple('CommandData', ['name', 'ext_name', 'ext_type', 'protect', 'return_type', 'handle_type', 'params', 'cdecl'])
+        self.instanceExtensions = []
+        self.ExtensionData = namedtuple('ExtensionData', ['name', 'type', 'protect', 'num_commands'])
+
+    #
+    # 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)
+        if (genOpts.prefixText):
+            for s in genOpts.prefixText:
+                write(s, file=self.outFile)
+
+        # File Comment
+        file_comment = '// *** THIS FILE IS GENERATED - DO NOT EDIT ***\n'
+        file_comment += '// See loader_extension_generator.py for modifications\n'
+        write(file_comment, file=self.outFile)
+
+        # Copyright Notice
+        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 += ' *\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: Mark Young <marky@lunarg.com>\n'
+        copyright += ' */\n'
+
+        preamble = ''
+
+        if self.genOpts.filename == 'vk_loader_extensions.h':
+            preamble += '#pragma once\n'
+
+        elif self.genOpts.filename == 'vk_loader_extensions.c':
+            preamble += '#define _GNU_SOURCE\n'
+            preamble += '#include <stdio.h>\n'
+            preamble += '#include <stdlib.h>\n'
+            preamble += '#include <string.h>\n'
+            preamble += '#include "vk_loader_platform.h"\n'
+            preamble += '#include "loader.h"\n'
+            preamble += '#include "vk_loader_extensions.h"\n'
+            preamble += '#include <vulkan/vk_icd.h>\n'
+            preamble += '#include "wsi.h"\n'
+            preamble += '#include "debug_report.h"\n'
+
+        elif self.genOpts.filename == 'vk_layer_dispatch_table.h':
+            preamble += '#pragma once\n'
+            preamble += '\n'
+            preamble += 'typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_GetPhysicalDeviceProcAddr)(VkInstance instance, const char* pName);\n'
+
+        write(copyright, file=self.outFile)
+        write(preamble, file=self.outFile)
+
+    #
+    # Write generate and write dispatch tables to output file
+    def endFile(self):
+        file_data = ''
+
+        if self.genOpts.filename == 'vk_loader_extensions.h':
+            file_data += self.OutputPrototypesInHeader()
+            file_data += self.OutputLoaderTerminators()
+            file_data += self.OutputIcdDispatchTable()
+            file_data += self.OutputIcdExtensionEnableUnion()
+
+        elif self.genOpts.filename == 'vk_loader_extensions.c':
+            file_data += self.OutputUtilitiesInSource()
+            file_data += self.OutputIcdDispatchTableInit()
+            file_data += self.OutputLoaderDispatchTables()
+            file_data += self.OutputLoaderLookupFunc()
+            file_data += self.CreateTrampTermFuncs()
+            file_data += self.InstExtensionGPA()
+            file_data += self.InstantExtensionCreate()
+            file_data += self.DeviceExtensionGetTerminator()
+            file_data += self.InitInstLoaderExtensionDispatchTable()
+            file_data += self.OutputInstantExtensionWhitelistArray()
+
+        elif self.genOpts.filename == 'vk_layer_dispatch_table.h':
+            file_data += self.OutputLayerInstanceDispatchTable()
+            file_data += self.OutputLayerDeviceDispatchTable()
+
+        write(file_data, file=self.outFile);
+
+        # Finish processing in superclass
+        OutputGenerator.endFile(self)
+
+    def beginFeature(self, interface, emit):
+        # Start processing in superclass
+        OutputGenerator.beginFeature(self, interface, emit)
+
+        self.currentExtension = ''
+        self.type = interface.get('type')
+        self.num_commands = 0
+
+        name = interface.get('name')
+        self.currentExtension = name 
+
+    #
+    # Process commands, adding to appropriate dispatch tables
+    def genCmd(self, cmdinfo, name):
+        OutputGenerator.genCmd(self, cmdinfo, name)
+
+        # Get first param type
+        params = cmdinfo.elem.findall('param')
+        info = self.getTypeNameTuple(params[0])
+
+        self.num_commands += 1
+
+        if 'android' not in name:
+            self.AddCommandToDispatchList(self.currentExtension, self.type, name, cmdinfo, info[0])
+
+    def endFeature(self):
+
+        if 'android' not in self.currentExtension:
+            self.instanceExtensions.append(self.ExtensionData(name=self.currentExtension,
+                                                              type=self.type,
+                                                              protect=self.featureExtraProtect,
+                                                              num_commands=self.num_commands))
+
+        # Finish processing in superclass
+        OutputGenerator.endFeature(self)
+
+    #
+    # 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
+            result = str(result).replace('::', '->')
+        return result
+
+    #
+    # Determine if this API should be ignored or added to the instance or device dispatch table
+    def AddCommandToDispatchList(self, extension_name, extension_type, name, cmdinfo, handle_type):
+        handle = self.registry.tree.find("types/type/[name='" + handle_type + "'][@category='handle']")
+
+        return_type =  cmdinfo.elem.find('proto/type')
+        if (return_type != None and return_type.text == 'void'):
+           return_type = None
+
+        cmd_params = []
+
+        # Generate a list of commands for use in printing the necessary
+        # core instance terminator prototypes
+        params = cmdinfo.elem.findall('param')
+        lens = set()
+        for param in params:
+            len = self.getLen(param)
+            if len:
+                lens.add(len)
+        paramsInfo = []
+        for param in params:
+            paramInfo = self.getTypeNameTuple(param)
+            param_type = paramInfo[0]
+            param_name = paramInfo[1]
+            param_cdecl = self.makeCParamDecl(param, 0)
+            cmd_params.append(self.CommandParam(type=param_type, name=param_name,
+                                                cdecl=param_cdecl))
+
+        if handle != None and handle_type != 'VkInstance' and handle_type != 'VkPhysicalDevice':
+            # The Core Vulkan code will be wrapped in a feature called VK_VERSION_#_#
+            # For example: VK_VERSION_1_0 wraps the core 1.0 Vulkan functionality
+            if 'VK_VERSION_' in extension_name:
+                self.core_commands.append(
+                    self.CommandData(name=name, ext_name=extension_name,
+                                     ext_type='device',
+                                     protect=self.featureExtraProtect,
+                                     return_type = return_type,
+                                     handle_type = handle_type,
+                                     params = cmd_params,
+                                     cdecl=self.makeCDecls(cmdinfo.elem)[0]))
+            else:
+                self.ext_device_dispatch_list.append((name, self.featureExtraProtect))
+                self.ext_commands.append(
+                    self.CommandData(name=name, ext_name=extension_name,
+                                     ext_type=extension_type,
+                                     protect=self.featureExtraProtect,
+                                     return_type = return_type,
+                                     handle_type = handle_type,
+                                     params = cmd_params,
+                                     cdecl=self.makeCDecls(cmdinfo.elem)[0]))
+        else:
+            # The Core Vulkan code will be wrapped in a feature called VK_VERSION_#_#
+            # For example: VK_VERSION_1_0 wraps the core 1.0 Vulkan functionality
+            if 'VK_VERSION_' in extension_name:
+                self.core_commands.append(
+                    self.CommandData(name=name, ext_name=extension_name,
+                                     ext_type='instance',
+                                     protect=self.featureExtraProtect,
+                                     return_type = return_type,
+                                     handle_type = handle_type,
+                                     params = cmd_params,
+                                     cdecl=self.makeCDecls(cmdinfo.elem)[0]))
+
+            else:
+                self.ext_instance_dispatch_list.append((name, self.featureExtraProtect))
+                self.ext_commands.append(
+                    self.CommandData(name=name, ext_name=extension_name,
+                                     ext_type=extension_type,
+                                     protect=self.featureExtraProtect,
+                                     return_type = return_type,
+                                     handle_type = handle_type,
+                                     params = cmd_params,
+                                     cdecl=self.makeCDecls(cmdinfo.elem)[0]))
+
+    #
+    # 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)
+
+    def OutputPrototypesInHeader(self):
+        protos = ''
+        protos += '// Structures defined externally, but used here\n'
+        protos += 'struct loader_instance;\n'
+        protos += 'struct loader_icd_term;\n'
+        protos += 'struct loader_dev_dispatch_table;\n'
+        protos += '\n'
+        protos += '// Device extension error function\n'
+        protos += 'VKAPI_ATTR VkResult VKAPI_CALL vkDevExtError(VkDevice dev);\n'
+        protos += '\n'
+        protos += '// Extension interception for vkGetInstanceProcAddr function, so we can return\n'
+        protos += '// the appropriate information for any instance extensions we know about.\n'
+        protos += 'bool extension_instance_gpa(struct loader_instance *ptr_instance, const char *name, void **addr);\n'
+        protos += '\n'
+        protos += '// Extension interception for vkCreateInstance function, so we can properly\n'
+        protos += '// detect and enable any instance extension information for extensions we know\n'
+        protos += '// about.\n'
+        protos += 'void extensions_create_instance(struct loader_instance *ptr_instance, const VkInstanceCreateInfo *pCreateInfo);\n'
+        protos += '\n'
+        protos += '// Extension interception for vkGetDeviceProcAddr function, so we can return\n'
+        protos += '// an appropriate terminator if this is one of those few device commands requiring\n'
+        protos += '// a terminator.\n'
+        protos += 'PFN_vkVoidFunction get_extension_device_proc_terminator(const char *pName);\n'
+        protos += '\n'
+        protos += '// Dispatch table properly filled in with appropriate terminators for the\n'
+        protos += '// supported extensions.\n'
+        protos += 'extern const VkLayerInstanceDispatchTable instance_disp;\n'
+        protos += '\n'
+        protos += '// Array of extension strings for instance extensions we support.\n'
+        protos += 'extern const char *const LOADER_INSTANCE_EXTENSIONS[];\n'
+        protos += '\n'
+        protos += 'VKAPI_ATTR bool VKAPI_CALL loader_icd_init_entries(struct loader_icd_term *icd_term, VkInstance inst,\n'
+        protos += '                                                   const PFN_vkGetInstanceProcAddr fp_gipa);\n'
+        protos += '\n'
+        protos += '// Init Device function pointer dispatch table with core commands\n'
+        protos += 'VKAPI_ATTR void VKAPI_CALL loader_init_device_dispatch_table(struct loader_dev_dispatch_table *dev_table, PFN_vkGetDeviceProcAddr gpa,\n'
+        protos += '                                                             VkDevice dev);\n'
+        protos += '\n'
+        protos += '// Init Device function pointer dispatch table with extension commands\n'
+        protos += 'VKAPI_ATTR void VKAPI_CALL loader_init_device_extension_dispatch_table(struct loader_dev_dispatch_table *dev_table,\n'
+        protos += '                                                                       PFN_vkGetDeviceProcAddr gpa, VkDevice dev);\n'
+        protos += '\n'
+        protos += '// Init Instance function pointer dispatch table with core commands\n'
+        protos += 'VKAPI_ATTR void VKAPI_CALL loader_init_instance_core_dispatch_table(VkLayerInstanceDispatchTable *table, PFN_vkGetInstanceProcAddr gpa,\n'
+        protos += '                                                                    VkInstance inst);\n'
+        protos += '\n'
+        protos += '// Init Instance function pointer dispatch table with core commands\n'
+        protos += 'VKAPI_ATTR void VKAPI_CALL loader_init_instance_extension_dispatch_table(VkLayerInstanceDispatchTable *table, PFN_vkGetInstanceProcAddr gpa,\n'
+        protos += '                                                                         VkInstance inst);\n'
+        protos += '\n'
+        protos += '// Device command lookup function\n'
+        protos += 'VKAPI_ATTR void* VKAPI_CALL loader_lookup_device_dispatch_table(const VkLayerDispatchTable *table, const char *name);\n'
+        protos += '\n'
+        protos += '// Instance command lookup function\n'
+        protos += 'VKAPI_ATTR void* VKAPI_CALL loader_lookup_instance_dispatch_table(const VkLayerInstanceDispatchTable *table, const char *name,\n'
+        protos += '                                                                  bool *found_name);\n'
+        protos += '\n'
+        protos += 'VKAPI_ATTR bool VKAPI_CALL loader_icd_init_entries(struct loader_icd_term *icd_term, VkInstance inst,\n'
+        protos += '                                                   const PFN_vkGetInstanceProcAddr fp_gipa);\n'
+        protos += '\n'
+        return protos
+
+    def OutputUtilitiesInSource(self):
+        protos = ''
+        protos += '// Device extension error function\n'
+        protos += 'VKAPI_ATTR VkResult VKAPI_CALL vkDevExtError(VkDevice dev) {\n'
+        protos += '    struct loader_device *found_dev;\n'
+        protos += '    // The device going in is a trampoline device\n'
+        protos += '    struct loader_icd_term *icd_term = loader_get_icd_and_device(dev, &found_dev, NULL);\n'
+        protos += '\n'
+        protos += '    if (icd_term)\n'
+        protos += '        loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,\n'
+        protos += '                   "Bad destination in loader trampoline dispatch,"\n'
+        protos += '                   "Are layers and extensions that you are calling enabled?");\n'
+        protos += '    return VK_ERROR_EXTENSION_NOT_PRESENT;\n'
+        protos += '}\n\n'
+        return protos
+
+    #
+    # Create a layer instance dispatch table from the appropriate list and return it as a string
+    def OutputLayerInstanceDispatchTable(self):
+        commands = []
+        table = ''
+        cur_extension_name = ''
+
+        table += '// Instance function pointer dispatch table\n'
+        table += 'typedef struct VkLayerInstanceDispatchTable_ {\n'
+
+        # First add in an entry for GetPhysicalDeviceProcAddr.  This will not
+        # ever show up in the XML or header, so we have to manually add it.
+        table += '    // Manually add in GetPhysicalDeviceProcAddr entry\n'
+        table += '    PFN_GetPhysicalDeviceProcAddr GetPhysicalDeviceProcAddr;\n'
+
+        for x in range(0, 2):
+            if x == 0:
+                commands = self.core_commands
+            else:
+                commands = self.ext_commands
+
+            for cur_cmd in commands:
+                is_inst_handle_type = cur_cmd.ext_type == 'instance' or cur_cmd.handle_type == 'VkInstance' or cur_cmd.handle_type == 'VkPhysicalDevice'
+                if is_inst_handle_type:
+
+                    if cur_cmd.ext_name != cur_extension_name:
+                        if 'VK_VERSION_' in cur_cmd.ext_name:
+                            table += '\n    // ---- Core %s commands\n' % cur_cmd.ext_name[11:]
+                        else:
+                            table += '\n    // ---- %s extension commands\n' % cur_cmd.ext_name
+                        cur_extension_name = cur_cmd.ext_name
+
+                    # Remove 'vk' from proto name
+                    base_name = cur_cmd.name[2:]
+
+                    if cur_cmd.protect is not None:
+                        table += '#ifdef %s\n' % cur_cmd.protect
+
+                    table += '    PFN_%s %s;\n' % (cur_cmd.name, base_name)
+
+                    if cur_cmd.protect is not None:
+                        table += '#endif // %s\n' % cur_cmd.protect
+
+        table += '} VkLayerInstanceDispatchTable;\n\n'
+        return table
+
+    #
+    # Create a layer device dispatch table from the appropriate list and return it as a string
+    def OutputLayerDeviceDispatchTable(self):
+        commands = []
+        table = ''
+        cur_extension_name = ''
+
+        table += '// Device function pointer dispatch table\n'
+        table += 'typedef struct VkLayerDispatchTable_ {\n'
+
+        for x in range(0, 2):
+            if x == 0:
+                commands = self.core_commands
+            else:
+                commands = self.ext_commands
+
+            for cur_cmd in commands:
+                is_inst_handle_type = cur_cmd.ext_type == 'instance' or cur_cmd.handle_type == 'VkInstance' or cur_cmd.handle_type == 'VkPhysicalDevice'
+                if not is_inst_handle_type:
+
+                    if cur_cmd.ext_name != cur_extension_name:
+                        if 'VK_VERSION_' in cur_cmd.ext_name:
+                            table += '\n    // ---- Core %s commands\n' % cur_cmd.ext_name[11:]
+                        else:
+                            table += '\n    // ---- %s extension commands\n' % cur_cmd.ext_name
+                        cur_extension_name = cur_cmd.ext_name
+
+                    # Remove 'vk' from proto name
+                    base_name = cur_cmd.name[2:]
+
+                    if cur_cmd.protect is not None:
+                        table += '#ifdef %s\n' % cur_cmd.protect
+
+                    table += '    PFN_%s %s;\n' % (cur_cmd.name, base_name)
+
+                    if cur_cmd.protect is not None:
+                        table += '#endif // %s\n' % cur_cmd.protect
+
+        table += '} VkLayerDispatchTable;\n\n'
+        return table
+
+    #
+    # Create a dispatch table from the appropriate list and return it as a string
+    def OutputIcdDispatchTable(self):
+        commands = []
+        table = ''
+        cur_extension_name = ''
+
+        table += '// ICD function pointer dispatch table\n'
+        table += 'struct loader_icd_term_dispatch {\n'
+
+        for x in range(0, 2):
+            if x == 0:
+                commands = self.core_commands
+            else:
+                commands = self.ext_commands
+
+            for cur_cmd in commands:
+                is_inst_handle_type = cur_cmd.ext_type == 'instance' or cur_cmd.handle_type == 'VkInstance' or cur_cmd.handle_type == 'VkPhysicalDevice'
+                if ((is_inst_handle_type or cur_cmd.name in DEVICE_CMDS_NEED_TERM) and
+                    (cur_cmd.name != 'vkGetInstanceProcAddr' and cur_cmd.name != 'vkEnumerateDeviceLayerProperties')):
+
+                    if cur_cmd.ext_name != cur_extension_name:
+                        if 'VK_VERSION_' in cur_cmd.ext_name:
+                            table += '\n    // ---- Core %s commands\n' % cur_cmd.ext_name[11:]
+                        else:
+                            table += '\n    // ---- %s extension commands\n' % cur_cmd.ext_name
+                        cur_extension_name = cur_cmd.ext_name
+
+                    # Remove 'vk' from proto name
+                    base_name = cur_cmd.name[2:]
+
+                    if cur_cmd.protect is not None:
+                        table += '#ifdef %s\n' % cur_cmd.protect
+
+                    table += '    PFN_%s %s;\n' % (cur_cmd.name, base_name)
+
+                    if cur_cmd.protect is not None:
+                        table += '#endif // %s\n' % cur_cmd.protect
+
+        table += '};\n\n'
+        return table
+
+    #
+    # Init a dispatch table from the appropriate list and return it as a string
+    def OutputIcdDispatchTableInit(self):
+        commands = []
+        cur_extension_name = ''
+
+        table = ''
+        table += 'VKAPI_ATTR bool VKAPI_CALL loader_icd_init_entries(struct loader_icd_term *icd_term, VkInstance inst,\n'
+        table += '                                                   const PFN_vkGetInstanceProcAddr fp_gipa) {\n'
+        table += '\n'
+        table += '#define LOOKUP_GIPA(func, required)                                                        \\\n'
+        table += '    do {                                                                                   \\\n'
+        table += '        icd_term->dispatch.func = (PFN_vk##func)fp_gipa(inst, "vk" #func);                 \\\n'
+        table += '        if (!icd_term->dispatch.func && required) {                                        \\\n'
+        table += '            loader_log((struct loader_instance *)inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, \\\n'
+        table += '                       loader_platform_get_proc_address_error("vk" #func));                \\\n'
+        table += '            return false;                                                                  \\\n'
+        table += '        }                                                                                  \\\n'
+        table += '    } while (0)\n'
+        table += '\n'
+
+        skip_gipa_commands = ['vkGetInstanceProcAddr',
+                              'vkEnumerateDeviceLayerProperties',
+                              'vkCreateInstance',
+                              'vkEnumerateInstanceExtensionProperties',
+                              'vkEnumerateInstanceLayerProperties',
+                             ]
+
+        for x in range(0, 2):
+            if x == 0:
+                commands = self.core_commands
+            else:
+                commands = self.ext_commands
+
+            for cur_cmd in commands:
+                is_inst_handle_type = cur_cmd.ext_type == 'instance' or cur_cmd.handle_type == 'VkInstance' or cur_cmd.handle_type == 'VkPhysicalDevice'
+                if ((is_inst_handle_type or cur_cmd.name in DEVICE_CMDS_NEED_TERM) and (cur_cmd.name not in skip_gipa_commands)):
+
+                    if cur_cmd.ext_name != cur_extension_name:
+                        if 'VK_VERSION_' in cur_cmd.ext_name:
+                            table += '\n    // ---- Core %s\n' % cur_cmd.ext_name[11:]
+                        else:
+                            table += '\n    // ---- %s extension commands\n' % cur_cmd.ext_name
+                        cur_extension_name = cur_cmd.ext_name
+
+                    # Remove 'vk' from proto name
+                    base_name = cur_cmd.name[2:]
+
+                    if cur_cmd.protect is not None:
+                        table += '#ifdef %s\n' % cur_cmd.protect
+
+                    # The Core Vulkan code will be wrapped in a feature called VK_VERSION_#_#
+                    # For example: VK_VERSION_1_0 wraps the core 1.0 Vulkan functionality
+                    if x == 0:
+                        table += '    LOOKUP_GIPA(%s, true);\n' % (base_name)
+                    else:
+                        table += '    LOOKUP_GIPA(%s, false);\n' % (base_name)
+
+                    if cur_cmd.protect is not None:
+                        table += '#endif // %s\n' % cur_cmd.protect
+
+        table += '\n'
+        table += '#undef LOOKUP_GIPA\n'
+        table += '\n'
+        table += '    return true;\n'
+        table += '};\n\n'
+        return table
+
+    #
+    # Create the extension enable union
+    def OutputIcdExtensionEnableUnion(self):
+        extensions = self.instanceExtensions
+
+        union = ''
+        union += 'union loader_instance_extension_enables {\n'
+        union += '    struct {\n'
+        for ext in extensions:
+            if ('VK_VERSION_' in ext.name or ext.name in WSI_EXT_NAMES or
+                ext.type == 'device' or ext.num_commands == 0):
+                continue
+
+            union += '        uint8_t %s : 1;\n' % ext.name[3:].lower()
+
+        union += '    };\n'
+        union += '    uint64_t padding[4];\n'
+        union += '};\n\n'
+        return union
+
+    #
+    # Creates the prototypes for the loader's core instance command terminators
+    def OutputLoaderTerminators(self):
+        terminators = ''
+        terminators += '// Loader core instance terminators\n'
+
+        for cur_cmd in self.core_commands:
+            is_inst_handle_type = cur_cmd.ext_type == 'instance' or cur_cmd.handle_type == 'VkInstance' or cur_cmd.handle_type == 'VkPhysicalDevice'
+            if is_inst_handle_type:
+                mod_string = ''
+                new_terminator = cur_cmd.cdecl
+                mod_string = new_terminator.replace("VKAPI_CALL vk", "VKAPI_CALL terminator_")
+
+                if (cur_cmd.protect != None):
+                    terminators += '#ifdef %s\n' % cur_cmd.protect
+
+                terminators += mod_string
+                terminators += '\n'
+
+                if (cur_cmd.protect != None):
+                    terminators += '#endif // %s\n' % cur_cmd.protect
+
+        terminators += '\n'
+        return terminators
+
+    #
+    # Creates code to initialize the various dispatch tables
+    def OutputLoaderDispatchTables(self):
+        commands = []
+        tables = ''
+        gpa_param = ''
+        cur_type = ''
+        cur_extension_name = ''
+
+        for x in range(0, 4):
+            if x == 0:
+                cur_type = 'device'
+                gpa_param = 'dev'
+                commands = self.core_commands
+
+                tables += '// Init Device function pointer dispatch table with core commands\n'
+                tables += 'VKAPI_ATTR void VKAPI_CALL loader_init_device_dispatch_table(struct loader_dev_dispatch_table *dev_table, PFN_vkGetDeviceProcAddr gpa,\n'
+                tables += '                                                             VkDevice dev) {\n'
+                tables += '    VkLayerDispatchTable *table = &dev_table->core_dispatch;\n'
+                tables += '    for (uint32_t i = 0; i < MAX_NUM_UNKNOWN_EXTS; i++) dev_table->ext_dispatch.dev_ext[i] = (PFN_vkDevExt)vkDevExtError;\n'
+                tables += '\n'
+
+            elif x == 1:
+                cur_type = 'device'
+                gpa_param = 'dev'
+                commands = self.ext_commands
+
+                tables += '// Init Device function pointer dispatch table with extension commands\n'
+                tables += 'VKAPI_ATTR void VKAPI_CALL loader_init_device_extension_dispatch_table(struct loader_dev_dispatch_table *dev_table,\n'
+                tables += '                                                                       PFN_vkGetDeviceProcAddr gpa, VkDevice dev) {\n'
+                tables += '    VkLayerDispatchTable *table = &dev_table->core_dispatch;\n'
+                tables += '\n'
+
+            elif x == 2:
+                cur_type = 'instance'
+                gpa_param = 'inst'
+                commands = self.core_commands
+
+                tables += '// Init Instance function pointer dispatch table with core commands\n'
+                tables += 'VKAPI_ATTR void VKAPI_CALL loader_init_instance_core_dispatch_table(VkLayerInstanceDispatchTable *table, PFN_vkGetInstanceProcAddr gpa,\n'
+                tables += '                                                                    VkInstance inst) {\n'
+
+            else:
+                cur_type = 'instance'
+                gpa_param = 'inst'
+                commands = self.ext_commands
+
+                tables += '// Init Instance function pointer dispatch table with core commands\n'
+                tables += 'VKAPI_ATTR void VKAPI_CALL loader_init_instance_extension_dispatch_table(VkLayerInstanceDispatchTable *table, PFN_vkGetInstanceProcAddr gpa,\n'
+                tables += '                                                                        VkInstance inst) {\n'
+
+            for cur_cmd in commands:
+                is_inst_handle_type = cur_cmd.ext_type == 'instance' or cur_cmd.handle_type == 'VkInstance' or cur_cmd.handle_type == 'VkPhysicalDevice'
+                if ((cur_type == 'instance' and is_inst_handle_type) or (cur_type == 'device' and not is_inst_handle_type)):
+                    if cur_cmd.ext_name != cur_extension_name:
+                        if 'VK_VERSION_' in cur_cmd.ext_name:
+                            tables += '\n    // ---- Core %s commands\n' % cur_cmd.ext_name[11:]
+                        else:
+                            tables += '\n    // ---- %s extension commands\n' % cur_cmd.ext_name
+                        cur_extension_name = cur_cmd.ext_name
+
+                    # Remove 'vk' from proto name
+                    base_name = cur_cmd.name[2:]
+
+                    # Names to skip
+                    if (base_name == 'CreateInstance' or base_name == 'CreateDevice' or
+                        base_name == 'EnumerateInstanceExtensionProperties' or
+                        base_name == 'EnumerateInstanceLayerProperties'):
+                        continue
+
+                    if cur_cmd.protect is not None:
+                        tables += '#ifdef %s\n' % cur_cmd.protect
+
+                    tables += '    table->%s = (PFN_%s)gpa(%s, "%s");\n' % (base_name, cur_cmd.name, gpa_param, cur_cmd.name)
+
+                    if cur_cmd.protect is not None:
+                        tables += '#endif // %s\n' % cur_cmd.protect
+
+            tables += '}\n\n'
+        return tables
+
+    #
+    # Create a lookup table function from the appropriate list of entrypoints and
+    # return it as a string
+    def OutputLoaderLookupFunc(self):
+        commands = []
+        tables = ''
+        cur_type = ''
+        cur_extension_name = ''
+
+        for x in range(0, 2):
+            if x == 0:
+                cur_type = 'device'
+
+                tables += '// Device command lookup function\n'
+                tables += 'VKAPI_ATTR void* VKAPI_CALL loader_lookup_device_dispatch_table(const VkLayerDispatchTable *table, const char *name) {\n'
+                tables += '    if (!name || name[0] != \'v\' || name[1] != \'k\') return NULL;\n'
+                tables += '\n'
+                tables += '    name += 2;\n'
+            else:
+                cur_type = 'instance'
+
+                tables += '// Instance command lookup function\n'
+                tables += 'VKAPI_ATTR void* VKAPI_CALL loader_lookup_instance_dispatch_table(const VkLayerInstanceDispatchTable *table, const char *name,\n'
+                tables += '                                                                 bool *found_name) {\n'
+                tables += '    if (!name || name[0] != \'v\' || name[1] != \'k\') {\n'
+                tables += '        *found_name = false;\n'
+                tables += '        return NULL;\n'
+                tables += '    }\n'
+                tables += '\n'
+                tables += '    *found_name = true;\n'
+                tables += '    name += 2;\n'
+
+            for y in range(0, 2):
+                if y == 0:
+                    commands = self.core_commands
+                else:
+                    commands = self.ext_commands
+
+                for cur_cmd in commands:
+                    is_inst_handle_type = cur_cmd.ext_type == 'instance' or cur_cmd.handle_type == 'VkInstance' or cur_cmd.handle_type == 'VkPhysicalDevice'
+                    if ((cur_type == 'instance' and is_inst_handle_type) or (cur_type == 'device' and not is_inst_handle_type)):
+
+                        if cur_cmd.ext_name != cur_extension_name:
+                            if 'VK_VERSION_' in cur_cmd.ext_name:
+                                tables += '\n    // ---- Core %s commands\n' % cur_cmd.ext_name[11:]
+                            else:
+                                tables += '\n    // ---- %s extension commands\n' % cur_cmd.ext_name
+                            cur_extension_name = cur_cmd.ext_name
+
+                        # Remove 'vk' from proto name
+                        base_name = cur_cmd.name[2:]
+
+                        if (base_name == 'CreateInstance' or base_name == 'CreateDevice' or
+                            base_name == 'EnumerateInstanceExtensionProperties' or
+                            base_name == 'EnumerateInstanceLayerProperties'):
+                            continue
+
+                        if cur_cmd.protect is not None:
+                            tables += '#ifdef %s\n' % cur_cmd.protect
+
+                        tables += '    if (!strcmp(name, "%s")) return (void *)table->%s;\n' % (base_name, base_name)
+
+                        if cur_cmd.protect is not None:
+                            tables += '#endif // %s\n' % cur_cmd.protect
+
+            tables += '\n'
+            if x == 1:
+                tables += '    *found_name = false;\n'
+            tables += '    return NULL;\n'
+            tables += '}\n\n'
+        return tables
+
+    #
+    # Several functions need a manual trampoline/terminator
+    def AddManualTrampTermFuncs(self):
+        funcs = ''
+
+        # vkEnumeratePhysicalDeviceGroupsKHX
+        funcs += '\n// ---- Manually added trampoline/terminator functison\n\n'
+        funcs += 'VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroupsKHX(\n'
+        funcs += '    VkInstance instance, uint32_t *pPhysicalDeviceGroupCount,\n'
+        funcs += '    VkPhysicalDeviceGroupPropertiesKHX *pPhysicalDeviceGroupProperties) {\n'
+        funcs += '    VkResult res = VK_SUCCESS;\n'
+        funcs += '    struct loader_instance *inst = NULL;\n'
+        funcs += '\n'
+        funcs += '    loader_platform_thread_lock_mutex(&loader_lock);\n'
+        funcs += '\n'
+        funcs += '    inst = loader_get_instance(instance);\n'
+        funcs += '    if (NULL == inst) {\n'
+        funcs += '        res = VK_ERROR_INITIALIZATION_FAILED;\n'
+        funcs += '        goto out;\n'
+        funcs += '    }\n'
+        funcs += '\n'
+        funcs += '    if (pPhysicalDeviceGroupProperties == NULL || 0 == inst->total_gpu_count) {\n'
+        funcs += '        VkResult setup_res = setupLoaderTrampPhysDevs(instance);\n'
+        funcs += '        if (VK_SUCCESS != setup_res) {\n'
+        funcs += '            res = setup_res;\n'
+        funcs += '            goto out;\n'
+        funcs += '        }\n'
+        funcs += '    }\n'
+        funcs += '\n'
+        funcs += '    res = inst->disp->layer_inst_disp.EnumeratePhysicalDeviceGroupsKHX(\n'
+        funcs += '        instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);\n'
+        funcs += '    if ((VK_SUCCESS != res && VK_INCOMPLETE != res) ||\n'
+        funcs += '        NULL == pPhysicalDeviceGroupProperties) {\n'
+        funcs += '        goto out;\n'
+        funcs += '    }\n'
+        funcs += '\n'
+        funcs += '    for (uint32_t group = 0; group < *pPhysicalDeviceGroupCount; group++) {\n'
+        funcs += '        for (uint32_t dev = 0;'
+        funcs += ' dev < pPhysicalDeviceGroupProperties[group].physicalDeviceCount; dev++) {\n'
+        funcs += '            for (uint32_t tramp = 0; tramp < inst->total_gpu_count; tramp++) {\n'
+        funcs += '                if (inst->phys_devs_tramp[tramp]->phys_dev ==\n'
+        funcs += '                        pPhysicalDeviceGroupProperties[group].physicalDevices[dev]) {\n'
+        funcs += '                    pPhysicalDeviceGroupProperties[group].physicalDevices[dev] =\n'
+        funcs += '                        (VkPhysicalDevice)inst->phys_devs_tramp[tramp];\n'
+        funcs += '                }\n'
+        funcs += '            }\n'
+        funcs += '        }\n'
+        funcs += '    }\n'
+        funcs += '\n'
+        funcs += 'out:\n'
+        funcs += '\n'
+        funcs += '    loader_platform_thread_unlock_mutex(&loader_lock);\n'
+        funcs += '    return res;\n'
+        funcs += '}\n\n'
+        funcs += 'VKAPI_ATTR VkResult VKAPI_CALL terminator_EnumeratePhysicalDeviceGroupsKHX(\n'
+        funcs += '    VkInstance instance, uint32_t *pPhysicalDeviceGroupCount,\n'
+        funcs += '    VkPhysicalDeviceGroupPropertiesKHX *pPhysicalDeviceGroupProperties) {\n'
+        funcs += '    struct loader_instance *inst = loader_get_instance(instance);\n'
+        funcs += '    VkResult res = VK_SUCCESS;\n'
+        funcs += '    uint32_t total_group_count = 0;\n'
+        funcs += '    uint32_t max_group_count = *pPhysicalDeviceGroupCount;\n'
+        funcs += '    uint32_t i = 0;\n'
+        funcs += '\n'
+        funcs += '    // We have to loop through all ICDs which may be capable of handling this\n'
+        funcs += '    // call and sum all the possible physical device groups together.\n'
+        funcs += '    struct loader_icd_term *icd_term = inst->icd_terms;\n'
+        funcs += '    while (NULL != icd_term) {\n'
+        funcs += '        if (NULL != icd_term->dispatch.EnumeratePhysicalDeviceGroupsKHX) {\n'
+        funcs += '            uint32_t cur_group_count = 0;\n'
+        funcs += '            res = icd_term->dispatch.EnumeratePhysicalDeviceGroupsKHX(\n'
+        funcs += '                icd_term->instance, &cur_group_count, NULL);\n'
+        funcs += '            if (res != VK_SUCCESS) {\n'
+        funcs += '                break;\n'
+        funcs += '            } else if (NULL != pPhysicalDeviceGroupProperties && max_group_count > total_group_count) {\n'
+        funcs += '\n'
+        funcs += '                uint32_t remain_count = max_group_count - total_group_count;\n'
+        funcs += '                res = icd_term->dispatch.EnumeratePhysicalDeviceGroupsKHX(\n'
+        funcs += '                    icd_term->instance, &remain_count,\n'
+        funcs += '                    &pPhysicalDeviceGroupProperties[total_group_count]);\n'
+        funcs += '                if (res != VK_SUCCESS) {\n'
+        funcs += '                    break;\n'
+        funcs += '                }\n'
+        funcs += '            }\n'
+        funcs += '            total_group_count += cur_group_count;\n'
+        funcs += '        } else {\n'
+        funcs += '            // For ICDs which don\'t directly support this, create a group for each physical device\n'
+        funcs += '            for (uint32_t j = 0; j < inst->total_gpu_count; j++) {\n'
+        funcs += '                if (inst->phys_devs_term[j]->icd_index == i) {\n'
+        funcs += '                    if (NULL != pPhysicalDeviceGroupProperties && max_group_count > total_group_count) {\n'
+        funcs += '                        pPhysicalDeviceGroupProperties[total_group_count].physicalDeviceCount = 1;\n'
+        funcs += '                        pPhysicalDeviceGroupProperties[total_group_count].physicalDevices[0] =\n'
+        funcs += '                            inst->phys_devs_term[j]->phys_dev;\n'
+        funcs += '                    }\n'
+        funcs += '                    total_group_count++;\n'
+        funcs += '                }\n'
+        funcs += '            }\n'
+        funcs += '        }\n'
+        funcs += '        icd_term = icd_term->next;\n'
+        funcs += '        i++;\n'
+        funcs += '    }\n'
+        funcs += '\n'
+        funcs += '    *pPhysicalDeviceGroupCount = total_group_count;\n'
+        funcs += '\n'
+        funcs += '    // Replace the physical devices with the value from the loader terminator\n'
+        funcs += '    // so we can de-reference them if needed.\n'
+        funcs += '    if (NULL != pPhysicalDeviceGroupProperties) {\n'
+        funcs += '        for (uint32_t group = 0; group < max_group_count; group++) {\n'
+        funcs += '            VkPhysicalDeviceGroupPropertiesKHX *cur_props = &pPhysicalDeviceGroupProperties[group];\n'
+        funcs += '            for (i = 0; i < cur_props->physicalDeviceCount; i++) {\n'
+        funcs += '                for (uint32_t term = 0; term < inst->total_gpu_count; term++) {\n'
+        funcs += '                    if (inst->phys_devs_term[term]->phys_dev == cur_props->physicalDevices[i]) {\n'
+        funcs += '                        cur_props->physicalDevices[i] = (VkPhysicalDevice)inst->phys_devs_term[term];\n'
+        funcs += '                    }\n'
+        funcs += '                }\n'
+        funcs += '            }\n'
+        funcs += '        }\n'
+        funcs += '\n'
+        funcs += '        if (VK_SUCCESS == res && max_group_count < total_group_count) {\n'
+        funcs += '            res = VK_INCOMPLETE;\n'
+        funcs += '        }\n'
+        funcs += '    }\n'
+        funcs += '\n'
+        funcs += '    return res;\n'
+        funcs += '}\n\n'
+        funcs += 'VKAPI_ATTR VkResult VKAPI_CALL\n'
+        funcs += 'vkGetPhysicalDeviceExternalImageFormatPropertiesNV(\n'
+        funcs += '    VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type,\n'
+        funcs += '    VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags,\n'
+        funcs += '    VkExternalMemoryHandleTypeFlagsNV externalHandleType,\n'
+        funcs += '    VkExternalImageFormatPropertiesNV *pExternalImageFormatProperties) {\n'
+        funcs += '    const VkLayerInstanceDispatchTable *disp;\n'
+        funcs += '    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);\n'
+        funcs += '    disp = loader_get_instance_layer_dispatch(physicalDevice);\n'
+        funcs += '\n'
+        funcs += '    return disp->GetPhysicalDeviceExternalImageFormatPropertiesNV(\n'
+        funcs += '        unwrapped_phys_dev, format, type, tiling, usage, flags,\n'
+        funcs += '        externalHandleType, pExternalImageFormatProperties);\n'
+        funcs += '}\n'
+        funcs += '\n'
+        funcs += 'VKAPI_ATTR VkResult VKAPI_CALL\n'
+        funcs += 'terminator_GetPhysicalDeviceExternalImageFormatPropertiesNV(\n'
+        funcs += '    VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type,\n'
+        funcs += '    VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags,\n'
+        funcs += '    VkExternalMemoryHandleTypeFlagsNV externalHandleType,\n'
+        funcs += '    VkExternalImageFormatPropertiesNV *pExternalImageFormatProperties) {\n'
+        funcs += '    struct loader_physical_device_term *phys_dev_term =\n'
+        funcs += '        (struct loader_physical_device_term *)physicalDevice;\n'
+        funcs += '    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;\n'
+        funcs += '\n'
+        funcs += '    if (!icd_term->dispatch.GetPhysicalDeviceExternalImageFormatPropertiesNV) {\n'
+        funcs += '        if (externalHandleType) {\n'
+        funcs += '            return VK_ERROR_FORMAT_NOT_SUPPORTED;\n'
+        funcs += '        }\n'
+        funcs += '\n'
+        funcs += '        if (!icd_term->dispatch.GetPhysicalDeviceImageFormatProperties) {\n'
+        funcs += '            return VK_ERROR_INITIALIZATION_FAILED;\n'
+        funcs += '        }\n'
+        funcs += '\n'
+        funcs += '        pExternalImageFormatProperties->externalMemoryFeatures = 0;\n'
+        funcs += '        pExternalImageFormatProperties->exportFromImportedHandleTypes = 0;\n'
+        funcs += '        pExternalImageFormatProperties->compatibleHandleTypes = 0;\n'
+        funcs += '\n'
+        funcs += '        return icd_term->dispatch.GetPhysicalDeviceImageFormatProperties(\n'
+        funcs += '            phys_dev_term->phys_dev, format, type, tiling, usage, flags,\n'
+        funcs += '            &pExternalImageFormatProperties->imageFormatProperties);\n'
+        funcs += '    }\n'
+        funcs += '\n'
+        funcs += '    return icd_term->dispatch.GetPhysicalDeviceExternalImageFormatPropertiesNV(\n'
+        funcs += '        phys_dev_term->phys_dev, format, type, tiling, usage, flags,\n'
+        funcs += '        externalHandleType, pExternalImageFormatProperties);\n'
+        funcs += '}\n\n'
+        return funcs
+
+    #
+    # Create the appropriate trampoline (and possibly terminator) functinos
+    def CreateTrampTermFuncs(self):
+        entries = []
+        funcs = ''
+        cur_extension_name = ''
+
+        # Some extensions have to be manually added.  Skip those in the automatic
+        # generation.  They will be manually added later.
+        manual_ext_commands = ['vkEnumeratePhysicalDeviceGroupsKHX',
+                               'vkGetPhysicalDeviceExternalImageFormatPropertiesNV']
+
+        for ext_cmd in self.ext_commands:
+            if (ext_cmd.ext_name in WSI_EXT_NAMES or
+                ext_cmd.ext_name in AVOID_EXT_NAMES or
+                ext_cmd.name in manual_ext_commands):
+                continue
+
+            if ext_cmd.ext_name != cur_extension_name:
+                if 'VK_VERSION_' in ext_cmd.ext_name:
+                    funcs += '\n// ---- Core %s trampoline/terminators\n\n' % ext_cmd.ext_name[11:]
+                else:
+                    funcs += '\n// ---- %s extension trampoline/terminators\n\n' % ext_cmd.ext_name
+                cur_extension_name = ext_cmd.ext_name
+
+            if ext_cmd.protect is not None:
+                funcs += '#ifdef %s\n' % ext_cmd.protect
+
+            tramp_header = ext_cmd.cdecl.replace(";", " {\n")
+            return_prefix = '    '
+            base_name = ext_cmd.name[2:]
+            has_surface = 0
+            requires_terminator = 0
+            surface_var_name = ''
+            phys_dev_var_name = ''
+            has_return_type = False
+
+            for param in ext_cmd.params:
+                if param.type == 'VkSurfaceKHR':
+                    has_surface = 1
+                    surface_var_name = param.name
+                    requires_terminator = 1
+                if param.type == 'VkPhysicalDevice':
+                    requires_terminator = 1
+                    phys_dev_var_name = param.name
+
+            if (ext_cmd.return_type != None):
+                return_prefix += 'return '
+                has_return_type = True
+
+            if (ext_cmd.ext_type == 'instance' or ext_cmd.handle_type == 'VkPhysicalDevice' or
+                'DebugMarkerSetObject' in ext_cmd.name or ext_cmd.name in DEVICE_CMDS_NEED_TERM):
+                requires_terminator = 1
+
+            if requires_terminator == 1:
+                term_header = tramp_header.replace("VKAPI_CALL vk", "VKAPI_CALL terminator_")
+
+                funcs += tramp_header
+
+                if ext_cmd.handle_type == 'VkPhysicalDevice':
+                    funcs += '    const VkLayerInstanceDispatchTable *disp;\n'
+                    funcs += '    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(%s);\n' % (phys_dev_var_name)
+                    funcs += '    disp = loader_get_instance_layer_dispatch(%s);\n' % (phys_dev_var_name)
+                elif ext_cmd.handle_type == 'VkInstance':
+                    funcs += '#error("Not implemented. Likely needs to be manually generated!");\n'
+                else:
+                    funcs += '    const VkLayerDispatchTable *disp = loader_get_dispatch('
+                    funcs += ext_cmd.params[0].name
+                    funcs += ');\n'
+
+                if 'DebugMarkerSetObject' in ext_cmd.name:
+                    funcs += '    // If this is a physical device, we have to replace it with the proper one for the next call.\n'
+                    funcs += '    if (%s->objectType == VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT) {\n' % (ext_cmd.params[1].name)
+                    funcs += '        struct loader_physical_device_tramp *phys_dev_tramp = (struct loader_physical_device_tramp *)(uintptr_t)%s->object;\n' % (ext_cmd.params[1].name)
+                    funcs += '        %s->object = (uint64_t)(uintptr_t)phys_dev_tramp->phys_dev;\n' % (ext_cmd.params[1].name)
+                    funcs += '    }\n'
+
+                funcs += return_prefix
+                funcs += 'disp->'
+                funcs += base_name
+                funcs += '('
+                count = 0
+                for param in ext_cmd.params:
+                    if count != 0:
+                        funcs += ', '
+
+                    if param.type == 'VkPhysicalDevice':
+                        funcs += 'unwrapped_phys_dev'
+                    else:
+                        funcs += param.name
+
+                    count += 1
+                funcs += ');\n'
+                funcs += '}\n\n'
+
+                funcs += term_header
+                if ext_cmd.handle_type == 'VkPhysicalDevice':
+                    funcs += '    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)%s;\n' % (phys_dev_var_name)
+                    funcs += '    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;\n'
+                    funcs += '    if (NULL == icd_term->dispatch.'
+                    funcs += base_name
+                    funcs += ') {\n'
+                    funcs += '        loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,\n'
+                    funcs += '                   "ICD associated with VkPhysicalDevice does not support '
+                    funcs += base_name
+                    funcs += '");\n'
+
+                    if has_surface == 1:
+                        funcs += '        VkIcdSurface *icd_surface = (VkIcdSurface *)(surface);\n'
+                        funcs += '        uint8_t icd_index = phys_dev_term->icd_index;\n'
+                        funcs += '        if (NULL != icd_surface->real_icd_surfaces) {\n'
+                        funcs += '            if (NULL != (void *)icd_surface->real_icd_surfaces[icd_index]) {\n'
+                        funcs += '                return icd_term->dispatch.'
+                        funcs += base_name
+                        funcs += '('
+                        count = 0
+                        for param in ext_cmd.params:
+                            if count != 0:
+                                funcs += ', '
+
+                            if param.type == 'VkPhysicalDevice':
+                                funcs += 'phys_dev_term->phys_dev'
+                            elif param.type == 'VkSurfaceKHR':
+                                funcs += 'icd_surface->real_icd_surfaces[icd_index]'
+                            else:
+                                funcs += param.name
+
+                            count += 1
+                        funcs += ');\n'
+                        funcs += '            }\n'
+                        funcs += '        }\n'
+
+                    funcs += '    }\n'
+
+                    funcs += return_prefix
+                    funcs += 'icd_term->dispatch.'
+                    funcs += base_name
+                    funcs += '('
+                    count = 0
+                    for param in ext_cmd.params:
+                        if count != 0:
+                            funcs += ', '
+
+                        if param.type == 'VkPhysicalDevice':
+                            funcs += 'phys_dev_term->phys_dev'
+                        else:
+                            funcs += param.name
+
+                        count += 1
+                    funcs += ');\n'
+
+                elif has_surface == 1 and ext_cmd.ext_type == 'device':
+                    funcs += '    uint32_t icd_index = 0;\n'
+                    funcs += '    struct loader_device *dev;\n'
+                    funcs += '    struct loader_icd_term *icd_term = loader_get_icd_and_device(device, &dev, &icd_index);\n'
+                    funcs += '    if (NULL != icd_term && NULL != icd_term->dispatch.%s) {\n' % base_name
+                    funcs += '        VkIcdSurface *icd_surface = (VkIcdSurface *)(uintptr_t)%s;\n' % (surface_var_name)
+                    funcs += '        if (NULL != icd_surface->real_icd_surfaces) {\n'
+                    funcs += '            if ((VkSurfaceKHR)NULL != icd_surface->real_icd_surfaces[icd_index]) {\n'
+                    funcs += '            %sicd_term->dispatch.%s(' % (return_prefix, base_name)
+                    count = 0
+                    for param in ext_cmd.params:
+                        if count != 0:
+                            funcs += ', '
+
+                        if param.type == 'VkSurfaceKHR':
+                            funcs += 'icd_surface->real_icd_surfaces[icd_index]'
+                        else:
+                            funcs += param.name
+
+                        count += 1
+                    funcs += ');\n'
+                    if not has_return_type:
+                        funcs += '                return;\n'
+                    funcs += '            }\n'
+                    funcs += '        }\n'
+                    funcs += '    %sicd_term->dispatch.%s(' % (return_prefix, base_name)
+                    count = 0
+                    for param in ext_cmd.params:
+                        if count != 0:
+                            funcs += ', '
+                        funcs += param.name
+                        count += 1
+                    funcs += ');\n'
+                    funcs += '     }\n'
+                    if has_return_type:
+                        funcs += '    return VK_SUCCESS;\n'
+
+                elif ext_cmd.handle_type == 'VkInstance':
+                    funcs += '#error("Not implemented. Likely needs to be manually generated!");\n'
+
+                elif 'DebugMarkerSetObject' in ext_cmd.name:
+                    funcs += '    uint32_t icd_index = 0;\n'
+                    funcs += '    struct loader_device *dev;\n'
+                    funcs += '    struct loader_icd_term *icd_term = loader_get_icd_and_device(%s, &dev, &icd_index);\n' % (ext_cmd.params[0].name)
+                    funcs += '    if (NULL != icd_term && NULL != icd_term->dispatch.'
+                    funcs += base_name
+                    funcs += ') {\n'
+                    funcs += '        // If this is a physical device, we have to replace it with the proper one for the next call.\n'
+                    funcs += '        if (%s->objectType == VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT) {\n' % (ext_cmd.params[1].name)
+                    funcs += '            struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)(uintptr_t)%s->object;\n' % (ext_cmd.params[1].name)
+                    funcs += '            %s->object = (uint64_t)(uintptr_t)phys_dev_term->phys_dev;\n' % (ext_cmd.params[1].name)
+                    funcs += '        // If this is a KHR_surface, and the ICD has created its own, we have to replace it with the proper one for the next call.\n'
+                    funcs += '        } else if (%s->objectType == VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT) {\n' % (ext_cmd.params[1].name)
+                    funcs += '            if (NULL != icd_term && NULL != icd_term->dispatch.CreateSwapchainKHR) {\n'
+                    funcs += '                VkIcdSurface *icd_surface = (VkIcdSurface *)(uintptr_t)%s->object;\n' % (ext_cmd.params[1].name)
+                    funcs += '                if (NULL != icd_surface->real_icd_surfaces) {\n'
+                    funcs += '                    %s->object = (uint64_t)icd_surface->real_icd_surfaces[icd_index];\n' % (ext_cmd.params[1].name)
+                    funcs += '                }\n'
+                    funcs += '            }\n'
+                    funcs += '        }\n'
+                    funcs += '        return icd_term->dispatch.'
+                    funcs += base_name
+                    funcs += '('
+                    count = 0
+                    for param in ext_cmd.params:
+                        if count != 0:
+                            funcs += ', '
+
+                        if param.type == 'VkPhysicalDevice':
+                            funcs += 'phys_dev_term->phys_dev'
+                        elif param.type == 'VkSurfaceKHR':
+                            funcs += 'icd_surface->real_icd_surfaces[icd_index]'
+                        else:
+                            funcs += param.name
+                        count += 1
+
+                    funcs += ');\n'
+                    funcs += '    } else {\n'
+                    funcs += '        return VK_SUCCESS;\n'
+                    funcs += '    }\n'
+
+                else:
+                    funcs += '#error("Unknown error path!");\n'
+
+                funcs += '}\n\n'
+            else:
+                funcs += tramp_header
+
+                funcs += '    const VkLayerDispatchTable *disp = loader_get_dispatch('
+                funcs += ext_cmd.params[0].name
+                funcs += ');\n'
+
+                funcs += return_prefix
+                funcs += 'disp->'
+                funcs += base_name
+                funcs += '('
+                count = 0
+                for param in ext_cmd.params:
+                    if count != 0:
+                        funcs += ', '
+                    funcs += param.name
+                    count += 1
+                funcs += ');\n'
+                funcs += '}\n\n'
+
+            if ext_cmd.protect is not None:
+                funcs += '#endif // %s\n' % ext_cmd.protect
+
+        funcs += self.AddManualTrampTermFuncs()
+        return funcs
+
+
+    #
+    # Create a function for the extension GPA call
+    def InstExtensionGPA(self):
+        entries = []
+        gpa_func = ''
+        cur_extension_name = ''
+
+        gpa_func += '// GPA helpers for extensions\n'
+        gpa_func += 'bool extension_instance_gpa(struct loader_instance *ptr_instance, const char *name, void **addr) {\n'
+        gpa_func += '    *addr = NULL;\n\n'
+
+        for cur_cmd in self.ext_commands:
+            if ('VK_VERSION_' in cur_cmd.ext_name or
+                cur_cmd.ext_name in WSI_EXT_NAMES or
+                cur_cmd.ext_name in AVOID_EXT_NAMES):
+                continue
+
+            if cur_cmd.ext_name != cur_extension_name:
+                gpa_func += '\n    // ---- %s extension commands\n' % cur_cmd.ext_name
+                cur_extension_name = cur_cmd.ext_name
+
+            if cur_cmd.protect is not None:
+                gpa_func += '#ifdef %s\n' % cur_cmd.protect
+
+            if (cur_cmd.ext_type == 'instance'):
+                gpa_func += '    if (!strcmp("%s", name)) {\n' % (cur_cmd.name)
+                gpa_func += '        *addr = (ptr_instance->enabled_known_extensions.'
+                gpa_func += cur_cmd.ext_name[3:].lower()
+                gpa_func += ' == 1)\n'
+                gpa_func += '                     ? (void *)%s\n' % (cur_cmd.name)
+                gpa_func += '                     : NULL;\n'
+                gpa_func += '        return true;\n'
+                gpa_func += '    }\n'
+            else:
+                gpa_func += '    if (!strcmp("%s", name)) {\n' % (cur_cmd.name)
+                gpa_func += '        *addr = (void *)%s;\n' % (cur_cmd.name)
+                gpa_func += '        return true;\n'
+                gpa_func += '    }\n'
+
+            if cur_cmd.protect is not None:
+                gpa_func += '#endif // %s\n' % cur_cmd.protect
+
+        gpa_func += '    return false;\n'
+        gpa_func += '}\n\n'
+
+        return gpa_func
+
+    #
+    # Create the extension name init function
+    def InstantExtensionCreate(self):
+        entries = []
+        entries = self.instanceExtensions
+        count = 0
+        cur_extension_name = ''
+
+        create_func = ''
+        create_func += '// A function that can be used to query enabled extensions during a vkCreateInstance call\n'
+        create_func += 'void extensions_create_instance(struct loader_instance *ptr_instance, const VkInstanceCreateInfo *pCreateInfo) {\n'
+        create_func += '    for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {\n'
+        for ext in entries:
+            if ('VK_VERSION_' in ext.name or ext.name in WSI_EXT_NAMES or
+                ext.name in AVOID_EXT_NAMES or ext.type == 'device' or
+                ext.num_commands == 0):
+                continue
+
+            if ext.name != cur_extension_name:
+                create_func += '\n    // ---- %s extension commands\n' % ext.name
+                cur_extension_name = ext.name
+
+            if ext.protect is not None:
+                create_func += '#ifdef %s\n' % ext.protect
+            if count == 0:
+                create_func += '        if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], '
+            else:
+                create_func += '        } else if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], '
+
+            if 'VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES2' == ext.name.upper():
+                create_func += 'VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) {\n'
+            else:
+                create_func += ext.name.upper()
+                create_func += '_EXTENSION_NAME)) {\n'
+
+            create_func += '            ptr_instance->enabled_known_extensions.'
+            create_func += ext.name[3:].lower()
+            create_func += ' = 1;\n'
+
+            if ext.protect is not None:
+                create_func += '#endif // %s\n' % ext.protect
+            count += 1
+
+        create_func += '        }\n'
+        create_func += '    }\n'
+        create_func += '}\n\n'
+        return create_func
+
+    #
+    # Create code to initialize a dispatch table from the appropriate list of
+    # extension entrypoints and return it as a string
+    def DeviceExtensionGetTerminator(self):
+        term_func = ''
+        cur_extension_name = ''
+
+        term_func += '// Some device commands still need a terminator because the loader needs to unwrap something about them.\n'
+        term_func += '// In many cases, the item needing unwrapping is a VkPhysicalDevice or VkSurfaceKHR object.  But there may be other items\n'
+        term_func += '// in the future.\n'
+        term_func += 'PFN_vkVoidFunction get_extension_device_proc_terminator(const char *pName) {\n'
+        term_func += '    PFN_vkVoidFunction addr = NULL;\n'
+
+        count = 0
+        for ext_cmd in self.ext_commands:
+            if ext_cmd.name in DEVICE_CMDS_NEED_TERM:
+                if ext_cmd.ext_name != cur_extension_name:
+                    if 'VK_VERSION_' in ext_cmd.ext_name:
+                        term_func += '\n    // ---- Core %s commands\n' % ext_cmd.ext_name[11:]
+                    else:
+                        term_func += '\n    // ---- %s extension commands\n' % ext_cmd.ext_name
+                    cur_extension_name = ext_cmd.ext_name
+
+                if ext_cmd.protect is not None:
+                    term_func += '#ifdef %s\n' % ext_cmd.protect
+
+                if count == 0:
+                    term_func += '    if'
+                else:
+                    term_func += '    } else if'
+                term_func += '(!strcmp(pName, "%s")) {\n' % (ext_cmd.name)
+                term_func += '        addr = (PFN_vkVoidFunction)terminator_%s;\n' % (ext_cmd.name[2:])
+
+                if ext_cmd.protect is not None:
+                    term_func += '#endif // %s\n' % ext_cmd.protect
+
+                count += 1
+
+        if count > 0:
+            term_func += '    }\n'
+
+        term_func += '    return addr;\n'
+        term_func += '}\n\n'
+
+        return term_func
+
+    #
+    # Create code to initialize a dispatch table from the appropriate list of
+    # core and extension entrypoints and return it as a string
+    def InitInstLoaderExtensionDispatchTable(self):
+        commands = []
+        table = ''
+        cur_extension_name = ''
+
+        table += '// This table contains the loader\'s instance dispatch table, which contains\n'
+        table += '// default functions if no instance layers are activated.  This contains\n'
+        table += '// pointers to "terminator functions".\n'
+        table += 'const VkLayerInstanceDispatchTable instance_disp = {\n'
+
+        for x in range(0, 2):
+            if x == 0:
+                commands = self.core_commands
+            else:
+                commands = self.ext_commands
+
+            for cur_cmd in commands:
+                if cur_cmd.ext_type == 'instance':
+                    if cur_cmd.ext_name != cur_extension_name:
+                        if 'VK_VERSION_' in cur_cmd.ext_name:
+                            table += '\n    // ---- Core %s commands\n' % cur_cmd.ext_name[11:]
+                        else:
+                            table += '\n    // ---- %s extension commands\n' % cur_cmd.ext_name
+                        cur_extension_name = cur_cmd.ext_name
+
+                    # Remove 'vk' from proto name
+                    base_name = cur_cmd.name[2:]
+
+                    if (base_name == 'CreateInstance' or base_name == 'CreateDevice' or
+                        base_name == 'EnumerateInstanceExtensionProperties' or
+                        base_name == 'EnumerateInstanceLayerProperties'):
+                        continue
+
+                    if cur_cmd.protect is not None:
+                        table += '#ifdef %s\n' % cur_cmd.protect
+
+                    if base_name == 'GetInstanceProcAddr':
+                        table += '    .%s = %s,\n' % (base_name, cur_cmd.name)
+                    else:
+                        table += '    .%s = terminator_%s,\n' % (base_name, base_name)
+
+                    if cur_cmd.protect is not None:
+                        table += '#endif // %s\n' % cur_cmd.protect
+        table += '};\n\n'
+
+        return table
+
+    #
+    # Create the extension name whitelist array
+    def OutputInstantExtensionWhitelistArray(self):
+        extensions = self.instanceExtensions
+
+        table = ''
+        table += '// A null-terminated list of all of the instance extensions supported by the loader.\n'
+        table += '// If an instance extension name is not in this list, but it is exported by one or more of the\n'
+        table += '// ICDs detected by the loader, then the extension name not in the list will be filtered out\n'
+        table += '// before passing the list of extensions to the application.\n'
+        table += 'const char *const LOADER_INSTANCE_EXTENSIONS[] = {\n'
+        for ext in extensions:
+            if ext.type == 'device' or 'VK_VERSION_' in ext.name:
+                continue
+
+            if ext.protect is not None:
+                table += '#ifdef %s\n' % ext.protect
+            table += '                                                  '
+
+            if 'VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES2' == ext.name.upper():
+                table += 'VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME,\n'
+            else:
+                table += ext.name.upper()
+                table += '_EXTENSION_NAME,\n'
+
+            if ext.protect is not None:
+                table += '#endif // %s\n' % ext.protect
+        table += '                                                  NULL };\n'
+        return table
+
diff --git a/scripts/lvl_genvk.py b/scripts/lvl_genvk.py
index 0be5d3ea..0789b66c 100644
--- a/scripts/lvl_genvk.py
+++ b/scripts/lvl_genvk.py
@@ -22,8 +22,9 @@ from cgenerator import CGeneratorOptions, COutputGenerator
 from threading_generator import  ThreadGeneratorOptions, ThreadOutputGenerator
 from parameter_validation_generator import ParamCheckerGeneratorOptions, ParamCheckerOutputGenerator
 from unique_objects_generator import UniqueObjectsGeneratorOptions, UniqueObjectsOutputGenerator
-from dispatch_table_generator import DispatchTableOutputGenerator, DispatchTableOutputGeneratorOptions
+from dispatch_table_helper_generator import DispatchTableHelperOutputGenerator, DispatchTableHelperOutputGeneratorOptions
 from helper_file_generator import HelperFileOutputGenerator, HelperFileOutputGeneratorOptions
+from loader_extension_generator import LoaderExtensionOutputGenerator, LoaderExtensionGeneratorOptions
 
 # Simple timer functions
 startTime = None
@@ -162,11 +163,10 @@ def makeGenOpts(extensions = [], removeExtensions = [], protect = True, director
             alignFuncParam    = 48)
         ]
 
-
     # Options for dispatch table helper generator
     genOpts['vk_dispatch_table_helper.h'] = [
-          DispatchTableOutputGenerator,
-          DispatchTableOutputGeneratorOptions(
+          DispatchTableHelperOutputGenerator,
+          DispatchTableHelperOutputGeneratorOptions(
             filename          = 'vk_dispatch_table_helper.h',
             directory         = directory,
             apiname           = 'vulkan',
@@ -184,6 +184,69 @@ def makeGenOpts(extensions = [], removeExtensions = [], protect = True, director
             alignFuncParam    = 48)
         ]
 
+    # Options for Layer dispatch table generator
+    genOpts['vk_layer_dispatch_table.h'] = [
+          LoaderExtensionOutputGenerator,
+          LoaderExtensionGeneratorOptions(
+            filename          = 'vk_layer_dispatch_table.h',
+            directory         = directory,
+            apiname           = 'vulkan',
+            profile           = None,
+            versions          = allVersions,
+            emitversions      = allVersions,
+            defaultExtensions = 'vulkan',
+            addExtensions     = addExtensions,
+            removeExtensions  = removeExtensions,
+            prefixText        = prefixStrings + vkPrefixStrings,
+            protectFeature    = False,
+            apicall           = 'VKAPI_ATTR ',
+            apientry          = 'VKAPI_CALL ',
+            apientryp         = 'VKAPI_PTR *',
+            alignFuncParam    = 48)
+        ]
+
+    # Options for loader extension source generator
+    genOpts['vk_loader_extensions.h'] = [
+          LoaderExtensionOutputGenerator,
+          LoaderExtensionGeneratorOptions(
+            filename          = 'vk_loader_extensions.h',
+            directory         = directory,
+            apiname           = 'vulkan',
+            profile           = None,
+            versions          = allVersions,
+            emitversions      = allVersions,
+            defaultExtensions = 'vulkan',
+            addExtensions     = addExtensions,
+            removeExtensions  = removeExtensions,
+            prefixText        = prefixStrings + vkPrefixStrings,
+            protectFeature    = False,
+            apicall           = 'VKAPI_ATTR ',
+            apientry          = 'VKAPI_CALL ',
+            apientryp         = 'VKAPI_PTR *',
+            alignFuncParam    = 48)
+        ]
+
+    # Options for loader extension source generator
+    genOpts['vk_loader_extensions.c'] = [
+          LoaderExtensionOutputGenerator,
+          LoaderExtensionGeneratorOptions(
+            filename          = 'vk_loader_extensions.c',
+            directory         = directory,
+            apiname           = 'vulkan',
+            profile           = None,
+            versions          = allVersions,
+            emitversions      = allVersions,
+            defaultExtensions = 'vulkan',
+            addExtensions     = addExtensions,
+            removeExtensions  = removeExtensions,
+            prefixText        = prefixStrings + vkPrefixStrings,
+            protectFeature    = False,
+            apicall           = 'VKAPI_ATTR ',
+            apientry          = 'VKAPI_CALL ',
+            apientryp         = 'VKAPI_PTR *',
+            alignFuncParam    = 48)
+        ]
+
     # Helper file generator options for vk_enum_string_helper.h
     genOpts['vk_enum_string_helper.h'] = [
           HelperFileOutputGenerator,
diff --git a/scripts/parameter_validation_generator.py b/scripts/parameter_validation_generator.py
index c4b32051..adcc4ab5 100644
--- a/scripts/parameter_validation_generator.py
+++ b/scripts/parameter_validation_generator.py
@@ -587,7 +587,7 @@ class ParamCheckerOutputGenerator(OutputGenerator):
             decoratedName = '{}({}/{})'.format(*match.group(1, 2, 3))
         else:
             # Matches expressions similar to 'latexmath : [dataSize \over 4]'
-            match = re.match(r'latexmath\s*\:\s*\[\s*\s*(\w+)\s*\\over\s*(\d+)\s*\s*\]', source)
+            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
diff --git a/scripts/vk.xml b/scripts/vk.xml
index b0b73f1b..e319443d 100644
--- a/scripts/vk.xml
+++ b/scripts/vk.xml
@@ -63,6 +63,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project.
         <tag name="TIZEN"       author="Samsung Electronics Co., Ltd." contact="Alon Or-bach @alonorbach"/>
         <tag name="RENDERDOC"   author="RenderDoc (renderdoc.org)"     contact="baldurk@baldurk.org"/>
         <tag name="NN"          author="Nintendo Co., Ltd."            contact="Yasuhiro Yoshioka @yoshioka_yasuhiro"/>
+        <tag name="MVK"         author="The Brenwill Workshop Ltd."    contact="Bill Hollings @billhollings"/>
         <tag name="KHR"         author="Khronos"                       contact="Tom Olson @tom.olson"/>
         <tag name="EXT"         author="Multivendor"                   contact="Jon Leech @oddhack"/>
         <tag name="MESA"        author="Mesa open source project"      contact="Chad Versace @chadversary, Daniel Stone @fooishbar, David Airlie @airlied, Jason Ekstrand @jekstrand"/>
@@ -95,6 +96,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project.
         <type requires="windows.h" name="HANDLE"/>
         <type requires="windows.h" name="SECURITY_ATTRIBUTES"/>
         <type requires="windows.h" name="DWORD"/>
+        <type requires="windows.h" name="LPCWSTR"/>
         <type requires="xcb/xcb.h" name="xcb_connection_t"/>
         <type requires="xcb/xcb.h" name="xcb_visualid_t"/>
         <type requires="xcb/xcb.h" name="xcb_window_t"/>
@@ -110,7 +112,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project.
         <type category="define">// Vulkan 1.0 version number
 #define <name>VK_API_VERSION_1_0</name> <type>VK_MAKE_VERSION</type>(1, 0, 0)</type>    <!-- The patch version here should never be set to anything other than 0 -->
         <type category="define">// Version of this file
-#define <name>VK_HEADER_VERSION</name> 41</type>
+#define <name>VK_HEADER_VERSION</name> 42</type>
 
         <type category="define">
 #define <name>VK_DEFINE_HANDLE</name>(object) typedef struct object##_T* object;</type>
@@ -142,6 +144,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project.
         <type requires="vk_platform" name="uint64_t"/>
         <type requires="vk_platform" name="int32_t"/>
         <type requires="vk_platform" name="size_t"/>
+        <type name="int"/>
         <!-- Bitmask types -->
         <type                                             category="bitmask">typedef <type>VkFlags</type> <name>VkFramebufferCreateFlags</name>;</type>               <!-- creation flags -->
         <type                                             category="bitmask">typedef <type>VkFlags</type> <name>VkQueryPoolCreateFlags</name>;</type>                 <!-- creation flags -->
@@ -159,7 +162,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project.
         <type                                             category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineInputAssemblyStateCreateFlags</name>;</type><!-- creation flags -->
         <type                                             category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineVertexInputStateCreateFlags</name>;</type>  <!-- creation flags -->
         <type                                             category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineShaderStageCreateFlags</name>;</type>       <!-- creation flags -->
-        <type                                             category="bitmask">typedef <type>VkFlags</type> <name>VkDescriptorSetLayoutCreateFlags</name>;</type>       <!-- creation flags -->
+        <type requires="VkDescriptorSetLayoutCreateFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkDescriptorSetLayoutCreateFlags</name>;</type>       <!-- creation flags -->
         <type                                             category="bitmask">typedef <type>VkFlags</type> <name>VkBufferViewCreateFlags</name>;</type>                <!-- creation flags -->
         <type                                             category="bitmask">typedef <type>VkFlags</type> <name>VkInstanceCreateFlags</name>;</type>                  <!-- creation flags -->
         <type                                             category="bitmask">typedef <type>VkFlags</type> <name>VkDeviceCreateFlags</name>;</type>                    <!-- creation flags -->
@@ -192,7 +195,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project.
         <type requires="VkImageAspectFlagBits"            category="bitmask">typedef <type>VkFlags</type> <name>VkImageAspectFlags</name>;</type>                 <!-- Bitmask of image aspects -->
         <type requires="VkSparseMemoryBindFlagBits"       category="bitmask">typedef <type>VkFlags</type> <name>VkSparseMemoryBindFlags</name>;</type>            <!-- Sparse memory bind flags -->
         <type requires="VkSparseImageFormatFlagBits"      category="bitmask">typedef <type>VkFlags</type> <name>VkSparseImageFormatFlags</name>;</type>           <!-- Sparse image memory requirements flags -->
-        <type                                             category="bitmask">typedef <type>VkFlags</type> <name>VkSubpassDescriptionFlags</name>;</type>          <!-- Subpass description flags -->
+        <type requires="VkSubpassDescriptionFlagBits"     category="bitmask">typedef <type>VkFlags</type> <name>VkSubpassDescriptionFlags</name>;</type>          <!-- Subpass description flags -->
         <type requires="VkPipelineStageFlagBits"          category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineStageFlags</name>;</type>               <!-- Pipeline stages -->
         <type requires="VkSampleCountFlagBits"            category="bitmask">typedef <type>VkFlags</type> <name>VkSampleCountFlags</name>;</type>                 <!-- Pipeline stages -->
         <type requires="VkAttachmentDescriptionFlagBits"  category="bitmask">typedef <type>VkFlags</type> <name>VkAttachmentDescriptionFlags</name>;</type>       <!-- Render pass attachment description flags -->
@@ -205,26 +208,38 @@ maintained in the master branch of the Khronos Vulkan GitHub project.
         <type requires="VkIndirectCommandsLayoutUsageFlagBitsNVX"  category="bitmask">typedef <type>VkFlags</type> <name>VkIndirectCommandsLayoutUsageFlagsNVX</name>;</type>  <!-- Device generated commands usage flags -->
         <type requires="VkObjectEntryUsageFlagBitsNVX"             category="bitmask">typedef <type>VkFlags</type> <name>VkObjectEntryUsageFlagsNVX</name>;</type>             <!-- Object usage flags -->
 
+        <type                                             category="bitmask">typedef <type>VkFlags</type> <name>VkDescriptorUpdateTemplateCreateFlagsKHR</name>;</type> <!-- Descriptor update template creation flags -->
             <!-- WSI extensions -->
         <type requires="VkCompositeAlphaFlagBitsKHR"      category="bitmask">typedef <type>VkFlags</type> <name>VkCompositeAlphaFlagsKHR</name>;</type>
         <type requires="VkDisplayPlaneAlphaFlagBitsKHR"   category="bitmask">typedef <type>VkFlags</type> <name>VkDisplayPlaneAlphaFlagsKHR</name>;</type>
         <type requires="VkSurfaceTransformFlagBitsKHR"    category="bitmask">typedef <type>VkFlags</type> <name>VkSurfaceTransformFlagsKHR</name>;</type>
-        <type                                             category="bitmask">typedef <type>VkFlags</type> <name>VkSwapchainCreateFlagsKHR</name>;</type>          <!-- creation flags -->
+        <type requires="VkSwapchainCreateFlagBitsKHR"     category="bitmask">typedef <type>VkFlags</type> <name>VkSwapchainCreateFlagsKHR</name>;</type>          <!-- creation flags -->
         <type                                             category="bitmask">typedef <type>VkFlags</type> <name>VkDisplayModeCreateFlagsKHR</name>;</type>        <!-- creation flags -->
         <type                                             category="bitmask">typedef <type>VkFlags</type> <name>VkDisplaySurfaceCreateFlagsKHR</name>;</type>     <!-- creation flags -->
         <type                                             category="bitmask">typedef <type>VkFlags</type> <name>VkAndroidSurfaceCreateFlagsKHR</name>;</type>     <!-- creation flags -->
         <type                                             category="bitmask">typedef <type>VkFlags</type> <name>VkMirSurfaceCreateFlagsKHR</name>;</type>         <!-- creation flags -->
-        <type                                             category="bitmask">typedef <type>VkFlags</type> <name>VkViSurfaceCreateFlagsNN</name>;</type>      <!-- creation flags -->
+        <type                                             category="bitmask">typedef <type>VkFlags</type> <name>VkViSurfaceCreateFlagsNN</name>;</type>           <!-- creation flags -->
         <type                                             category="bitmask">typedef <type>VkFlags</type> <name>VkWaylandSurfaceCreateFlagsKHR</name>;</type>     <!-- creation flags -->
         <type                                             category="bitmask">typedef <type>VkFlags</type> <name>VkWin32SurfaceCreateFlagsKHR</name>;</type>       <!-- creation flags -->
         <type                                             category="bitmask">typedef <type>VkFlags</type> <name>VkXlibSurfaceCreateFlagsKHR</name>;</type>        <!-- creation flags -->
         <type                                             category="bitmask">typedef <type>VkFlags</type> <name>VkXcbSurfaceCreateFlagsKHR</name>;</type>         <!-- creation flags -->
+        <type                                             category="bitmask">typedef <type>VkFlags</type> <name>VkIOSSurfaceCreateFlagsMVK</name>;</type>         <!-- creation flags -->
+        <type                                             category="bitmask">typedef <type>VkFlags</type> <name>VkMacOSSurfaceCreateFlagsMVK</name>;</type>       <!-- creation flags -->
+        <type requires="VkPeerMemoryFeatureFlagBitsKHX"   category="bitmask">typedef <type>VkFlags</type> <name>VkPeerMemoryFeatureFlagsKHX</name>;</type>        <!-- Peer memory feature flags -->
+        <type requires="VkMemoryAllocateFlagBitsKHX"      category="bitmask">typedef <type>VkFlags</type> <name>VkMemoryAllocateFlagsKHX</name>;</type>           <!-- Memory allocation flags -->
+        <type requires="VkDeviceGroupPresentModeFlagBitsKHX" category="bitmask">typedef <type>VkFlags</type> <name>VkDeviceGroupPresentModeFlagsKHX</name>;</type><!-- Device group present mode flags -->
 
         <type requires="VkDebugReportFlagBitsEXT"      category="bitmask">typedef <type>VkFlags</type> <name>VkDebugReportFlagsEXT</name>;</type>
         <type                                             category="bitmask">typedef <type>VkFlags</type> <name>VkCommandPoolTrimFlagsKHR</name>;</type>
         <type requires="VkExternalMemoryHandleTypeFlagBitsNV" category="bitmask">typedef <type>VkFlags</type> <name>VkExternalMemoryHandleTypeFlagsNV</name>;</type>
         <type requires="VkExternalMemoryFeatureFlagBitsNV" category="bitmask">typedef <type>VkFlags</type> <name>VkExternalMemoryFeatureFlagsNV</name>;</type>
+        <type requires="VkExternalMemoryHandleTypeFlagBitsKHX" category="bitmask">typedef <type>VkFlags</type> <name>VkExternalMemoryHandleTypeFlagsKHX</name>;</type>
+        <type requires="VkExternalMemoryFeatureFlagBitsKHX" category="bitmask">typedef <type>VkFlags</type> <name>VkExternalMemoryFeatureFlagsKHX</name>;</type>
+        <type requires="VkExternalSemaphoreHandleTypeFlagBitsKHX" category="bitmask">typedef <type>VkFlags</type> <name>VkExternalSemaphoreHandleTypeFlagsKHX</name>;</type>
+        <type requires="VkExternalSemaphoreFeatureFlagBitsKHX" category="bitmask">typedef <type>VkFlags</type> <name>VkExternalSemaphoreFeatureFlagsKHX</name>;</type>
         <type requires="VkSurfaceCounterFlagBitsEXT"      category="bitmask">typedef <type>VkFlags</type> <name>VkSurfaceCounterFlagsEXT</name>;</type>
+        <type                                             category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineViewportSwizzleStateCreateFlagsNV</name>;</type>     <!-- creation flags (no bits yet) -->
+        <type                                             category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineDiscardRectangleStateCreateFlagsEXT</name>;</type>     <!-- creation flags (no bits yet) -->
 
         <!-- Types which can be void pointers or class pointers, selected at compile time -->
         <type category="handle"><type>VK_DEFINE_HANDLE</type>(<name>VkInstance</name>)</type>
@@ -254,6 +269,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project.
         <type category="handle" parent="VkDevice"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkPipelineCache</name>)</type>
         <type category="handle" parent="VkDevice"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkObjectTableNVX</name>)</type>
         <type category="handle" parent="VkDevice"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkIndirectCommandsLayoutNVX</name>)</type>
+        <type category="handle" parent="VkDevice"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkDescriptorUpdateTemplateKHR</name>)</type>
 
         <!-- WSI extensions -->
         <type category="handle"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkDisplayKHR</name>)</type>
@@ -353,6 +369,10 @@ maintained in the master branch of the Khronos Vulkan GitHub project.
         <type name="VkIndirectCommandsTokenTypeNVX" category="enum"/>
         <type name="VkObjectEntryUsageFlagBitsNVX" category="enum"/>
         <type name="VkObjectEntryTypeNVX" category="enum"/>
+        <type name="VkDescriptorUpdateTemplateTypeKHR" category="enum"/>
+        <type name="VkViewportCoordinateSwizzleNV" category="enum"/>
+        <type name="VkDiscardRectangleModeEXT" category="enum"/>
+        <type name="VkSubpassDescriptionFlagBits" category="enum"/>
         <!-- WSI extensions -->
         <type name="VkColorSpaceKHR" category="enum"/>
         <type name="VkCompositeAlphaFlagBitsKHR" category="enum"/>
@@ -366,10 +386,18 @@ maintained in the master branch of the Khronos Vulkan GitHub project.
         <type name="VkExternalMemoryHandleTypeFlagBitsNV" category="enum"/>
         <type name="VkExternalMemoryFeatureFlagBitsNV" category="enum"/>
         <type name="VkValidationCheckEXT" category="enum"/>
+        <type name="VkExternalMemoryHandleTypeFlagBitsKHX" category="enum"/>
+        <type name="VkExternalMemoryFeatureFlagBitsKHX" category="enum"/>
+        <type name="VkExternalSemaphoreHandleTypeFlagBitsKHX" category="enum"/>
+        <type name="VkExternalSemaphoreFeatureFlagBitsKHX" category="enum"/>
         <type name="VkSurfaceCounterFlagBitsEXT" category="enum"/>
         <type name="VkDisplayPowerStateEXT" category="enum"/>
         <type name="VkDeviceEventTypeEXT" category="enum"/>
         <type name="VkDisplayEventTypeEXT" category="enum"/>
+        <type name="VkPeerMemoryFeatureFlagBitsKHX" category="enum"/>
+        <type name="VkMemoryAllocateFlagBitsKHX" category="enum"/>
+        <type name="VkDeviceGroupPresentModeFlagBitsKHX" category="enum"/>
+        <type name="VkSwapchainCreateFlagBitsKHR" category="enum"/>
 
         <!-- The PFN_vk*Function types are used by VkAllocationCallbacks below -->
         <type category="funcpointer">typedef void (VKAPI_PTR *<name>PFN_vkInternalAllocationNotification</name>)(
@@ -505,7 +533,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project.
         </type>
         <type category="struct" name="VkDeviceCreateInfo">
             <member values="VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
-            <member validextensionstructs="VkPhysicalDeviceFeatures2KHR">const <type>void</type>*     <name>pNext</name></member>                          <!-- Pointer to next structure -->
+            <member validextensionstructs="VkPhysicalDeviceFeatures2KHR,VkPhysicalDeviceMultiviewFeaturesKHX,VkDeviceGroupDeviceCreateInfoKHX">const <type>void</type>*     <name>pNext</name></member>                          <!-- Pointer to next structure -->
             <member optional="true"><type>VkDeviceCreateFlags</type>    <name>flags</name></member>                   <!-- Reserved -->
             <member><type>uint32_t</type>        <name>queueCreateInfoCount</name></member>
             <member len="queueCreateInfoCount">const <type>VkDeviceQueueCreateInfo</type>* <name>pQueueCreateInfos</name></member>
@@ -539,7 +567,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project.
         </type>
         <type category="struct" name="VkMemoryAllocateInfo">
             <member values="VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
-            <member validextensionstructs="VkDedicatedAllocationMemoryAllocateInfoNV">const <type>void</type>*            <name>pNext</name></member>                          <!-- Pointer to next structure -->
+            <member validextensionstructs="VkDedicatedAllocationMemoryAllocateInfoNV,VkMemoryAllocateFlagsInfoKHX">const <type>void</type>*            <name>pNext</name></member>                          <!-- Pointer to next structure -->
             <member><type>VkDeviceSize</type>           <name>allocationSize</name></member>                 <!-- Size of memory allocation -->
             <member><type>uint32_t</type>               <name>memoryTypeIndex</name></member>                <!-- Index of the of the memory type to allocate from -->
         </type>
@@ -688,7 +716,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project.
         </type>
         <type category="struct" name="VkImageCreateInfo">
             <member values="VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
-            <member validextensionstructs="VkDedicatedAllocationImageCreateInfoNV">const <type>void</type>*            <name>pNext</name></member>                          <!-- Pointer to next structure. -->
+            <member validextensionstructs="VkDedicatedAllocationImageCreateInfoNV,VkImageSwapchainCreateInfoKHX">const <type>void</type>*            <name>pNext</name></member>                          <!-- Pointer to next structure. -->
             <member optional="true"><type>VkImageCreateFlags</type>     <name>flags</name></member>                          <!-- Image creation flags -->
             <member><type>VkImageType</type>            <name>imageType</name></member>
             <member><type>VkFormat</type>               <name>format</name></member>
@@ -757,7 +785,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project.
         </type>
         <type category="struct" name="VkBindSparseInfo">
             <member values="VK_STRUCTURE_TYPE_BIND_SPARSE_INFO"><type>VkStructureType</type> <name>sType</name></member>
-            <member>const <type>void</type>*            <name>pNext</name></member>                          <!-- Pointer to next structure. -->
+            <member validextensionstructs="VkDeviceGroupBindSparseInfoKHX">const <type>void</type>*            <name>pNext</name></member>                          <!-- Pointer to next structure. -->
             <member optional="true"><type>uint32_t</type>               <name>waitSemaphoreCount</name></member>
             <member len="waitSemaphoreCount">const <type>VkSemaphore</type>*     <name>pWaitSemaphores</name></member>
             <member optional="true"><type>uint32_t</type>               <name>bufferBindCount</name></member>
@@ -901,7 +929,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project.
         </type>
         <type category="struct" name="VkPipelineViewportStateCreateInfo">
             <member values="VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
-            <member>const <type>void</type>*            <name>pNext</name></member>                          <!-- Pointer to next structure -->
+            <member validextensionstructs="VkPipelineViewportWScalingStateCreateInfoNV">const <type>void</type>*            <name>pNext</name></member>                          <!-- Pointer to next structure -->
             <member optional="true"><type>VkPipelineViewportStateCreateFlags</type>    <name>flags</name></member>           <!-- Reserved -->
             <member><type>uint32_t</type>               <name>viewportCount</name></member>
             <member noautovalidity="true" optional="true" len="viewportCount">const <type>VkViewport</type>*      <name>pViewports</name></member>
@@ -1071,13 +1099,13 @@ maintained in the master branch of the Khronos Vulkan GitHub project.
         </type>
         <type category="struct" name="VkCommandBufferBeginInfo">
             <member values="VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO"><type>VkStructureType</type> <name>sType</name></member>
-            <member>const <type>void</type>*            <name>pNext</name></member>                          <!-- Pointer to next structure -->
+            <member validextensionstructs="VkDeviceGroupCommandBufferBeginInfoKHX">const <type>void</type>*            <name>pNext</name></member>                          <!-- Pointer to next structure -->
             <member optional="true"><type>VkCommandBufferUsageFlags</type>  <name>flags</name></member>                          <!-- Command buffer usage flags -->
             <member optional="true" noautovalidity="true">const <type>VkCommandBufferInheritanceInfo</type>*       <name>pInheritanceInfo</name></member>                          <!-- Pointer to inheritance info for secondary command buffers -->
         </type>
         <type category="struct" name="VkRenderPassBeginInfo">
             <member values="VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO"><type>VkStructureType</type> <name>sType</name></member>
-            <member>const <type>void</type>*            <name>pNext</name></member>                          <!-- Pointer to next structure -->
+            <member validextensionstructs="VkDeviceGroupRenderPassBeginInfoKHX">const <type>void</type>*            <name>pNext</name></member>                          <!-- Pointer to next structure -->
             <member><type>VkRenderPass</type>           <name>renderPass</name></member>
             <member><type>VkFramebuffer</type>          <name>framebuffer</name></member>
             <member><type>VkRect2D</type>               <name>renderArea</name></member>
@@ -1384,7 +1412,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project.
         </type>
         <type category="struct" name="VkSubmitInfo">
             <member values="VK_STRUCTURE_TYPE_SUBMIT_INFO"><type>VkStructureType</type> <name>sType</name></member>
-            <member>const <type>void</type>*            <name>pNext</name></member>                          <!-- Pointer to next structure -->
+            <member validextensionstructs="VkWin32KeyedMutexAcquireReleaseInfoNV,VkWin32KeyedMutexAcquireReleaseInfoKHX,VkD3D12FenceSubmitInfoKHX,VkDeviceGroupSubmitInfoKHX">const <type>void</type>* <name>pNext</name></member>                          <!-- Pointer to next structure -->
             <member optional="true"><type>uint32_t</type>       <name>waitSemaphoreCount</name></member>
             <member len="waitSemaphoreCount">const <type>VkSemaphore</type>*     <name>pWaitSemaphores</name></member>
             <member len="waitSemaphoreCount">const <type>VkPipelineStageFlags</type>*           <name>pWaitDstStageMask</name></member>
@@ -1516,7 +1544,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project.
         </type>
         <type category="struct" name="VkSwapchainCreateInfoKHR">
             <member values="VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
-            <member>const <type>void</type>*                      <name>pNext</name></member>                    <!-- Pointer to next structure -->
+            <member validextensionstructs="VkDeviceGroupSwapchainCreateInfoKHX">const <type>void</type>*                      <name>pNext</name></member>                    <!-- Pointer to next structure -->
             <member optional="true"><type>VkSwapchainCreateFlagsKHR</type>        <name>flags</name></member>                    <!-- Reserved -->
             <member><type>VkSurfaceKHR</type>                     <name>surface</name></member>                  <!-- The swapchain's target surface -->
             <member><type>uint32_t</type>                         <name>minImageCount</name></member>            <!-- Minimum number of presentation images the application needs -->
@@ -1536,10 +1564,10 @@ maintained in the master branch of the Khronos Vulkan GitHub project.
         </type>
         <type category="struct" name="VkPresentInfoKHR">
             <member values="VK_STRUCTURE_TYPE_PRESENT_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
-            <member validextensionstructs="VkDisplayPresentInfoKHR">const <type>void</type>* <name>pNext</name></member>                    <!-- Pointer to next structure -->
+            <member validextensionstructs="VkDeviceGroupPresentInfoKHX">const <type>void</type>*  <name>pNext</name></member> <!-- Pointer to next structure -->
             <member optional="true"><type>uint32_t</type>         <name>waitSemaphoreCount</name></member>       <!-- Number of semaphores to wait for before presenting -->
             <member optional="true" len="waitSemaphoreCount">const <type>VkSemaphore</type>* <name>pWaitSemaphores</name></member> <!-- Semaphores to wait for before presenting -->
-            <member><type>uint32_t</type>                         <name>swapchainCount</name></member>           <!-- Number of swap chains to present in this call -->
+            <member><type>uint32_t</type>                         <name>swapchainCount</name></member>           <!-- Number of swapchains to present in this call -->
             <member len="swapchainCount">const <type>VkSwapchainKHR</type>* <name>pSwapchains</name></member>    <!-- Swapchains to present an image from -->
             <member len="swapchainCount">const <type>uint32_t</type>* <name>pImageIndices</name></member>        <!-- Indices of which presentable images to present -->
             <member optional="true" len="swapchainCount"><type>VkResult</type>* <name>pResults</name></member>   <!-- Optional (i.e. if non-NULL) VkResult for each swapchain -->
@@ -1639,7 +1667,6 @@ maintained in the master branch of the Khronos Vulkan GitHub project.
             <member len="releaseCount">const <type>VkDeviceMemory</type>*            <name>pReleaseSyncs</name></member>
             <member len="releaseCount">const <type>uint64_t</type>*                  <name>pReleaseKeys</name></member>
         </type>
-
         <type category="struct" name="VkDeviceGeneratedCommandsFeaturesNVX">
             <member values="VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX"><type>VkStructureType</type> <name>sType</name></member>
             <member>const <type>void</type>*                      <name>pNext</name></member>
@@ -1742,12 +1769,12 @@ maintained in the master branch of the Khronos Vulkan GitHub project.
         </type>
         <type category="struct" name="VkPhysicalDeviceFeatures2KHR">
             <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR"><type>VkStructureType</type> <name>sType</name></member>
-            <member><type>void</type>*                            <name>pNext</name></member>                    <!-- Pointer to next structure -->
+            <member validextensionstructs="VkPhysicalDeviceMultiviewFeaturesKHX"><type>void</type>*                            <name>pNext</name></member>                    <!-- Pointer to next structure -->
             <member><type>VkPhysicalDeviceFeatures</type>         <name>features</name></member>
         </type>
         <type category="struct" name="VkPhysicalDeviceProperties2KHR" returnedonly="true">
             <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR"><type>VkStructureType</type> <name>sType</name></member>
-            <member><type>void</type>*                            <name>pNext</name></member>                    <!-- Pointer to next structure -->
+            <member validextensionstructs="VkPhysicalDevicePushDescriptorPropertiesKHR,VkPhysicalDeviceIDPropertiesKHX,VkPhysicalDeviceMultiviewPropertiesKHX,VkPhysicalDeviceDiscardRectanglePropertiesEXT,VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX"><type>void</type>*                            <name>pNext</name></member>                    <!-- Pointer to next structure -->
             <member><type>VkPhysicalDeviceProperties</type>       <name>properties</name></member>
         </type>
         <type category="struct" name="VkFormatProperties2KHR" returnedonly="true">
@@ -1757,12 +1784,12 @@ maintained in the master branch of the Khronos Vulkan GitHub project.
         </type>
         <type category="struct" name="VkImageFormatProperties2KHR" returnedonly="true">
             <member values="VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR"><type>VkStructureType</type> <name>sType</name></member>
-            <member><type>void</type>* <name>pNext</name></member>                    <!-- Pointer to next structure -->
+            <member validextensionstructs="VkExternalImageFormatPropertiesKHX"><type>void</type>* <name>pNext</name></member>                    <!-- Pointer to next structure -->
             <member><type>VkImageFormatProperties</type>          <name>imageFormatProperties</name></member>
         </type>
         <type category="struct" name="VkPhysicalDeviceImageFormatInfo2KHR">
             <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR"><type>VkStructureType</type> <name>sType</name></member>
-            <member>const <type>void</type>* <name>pNext</name></member>                    <!-- Pointer to next structure -->
+            <member validextensionstructs="VkPhysicalDeviceExternalImageFormatInfoKHX">const <type>void</type>* <name>pNext</name></member>                    <!-- Pointer to next structure -->
             <member><type>VkFormat</type>                         <name>format</name></member>
             <member><type>VkImageType</type>                      <name>type</name></member>
             <member><type>VkImageTiling</type>                    <name>tiling</name></member>
@@ -1793,6 +1820,189 @@ maintained in the master branch of the Khronos Vulkan GitHub project.
             <member><type>VkImageUsageFlags</type>                <name>usage</name></member>
             <member><type>VkImageTiling</type>                    <name>tiling</name></member>
         </type>
+        <type category="struct" name="VkPhysicalDevicePushDescriptorPropertiesKHR">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR"><type>VkStructureType</type> <name>sType</name></member>
+            <member><type>void</type>*                            <name>pNext</name></member>                    <!-- Pointer to next structure -->
+            <member><type>uint32_t</type>                         <name>maxPushDescriptors</name></member>
+        </type>
+        <type category="struct" name="VkPhysicalDeviceProperties2KHX" returnedonly="true">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHX"><type>VkStructureType</type> <name>sType</name></member>
+            <member validextensionstructs="VkPhysicalDeviceIDPropertiesKHX"><type>void</type>*                            <name>pNext</name></member>                    <!-- Pointer to next structure -->
+            <member><type>VkPhysicalDeviceProperties</type>       <name>properties</name></member>
+        </type>
+        <type category="struct" name="VkImageFormatProperties2KHX" returnedonly="true">
+            <member values="VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHX"><type>VkStructureType</type> <name>sType</name></member>
+            <member validextensionstructs="VkExternalImageFormatPropertiesKHX"><type>void</type>* <name>pNext</name></member>                    <!-- Pointer to next structure -->
+            <member><type>VkImageFormatProperties</type>          <name>imageFormatProperties</name></member>
+        </type>
+        <type category="struct" name="VkPhysicalDeviceImageFormatInfo2KHX">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHX"><type>VkStructureType</type> <name>sType</name></member>
+            <member validextensionstructs="VkPhysicalDeviceExternalImageFormatInfoKHX">const <type>void</type>* <name>pNext</name></member>                    <!-- Pointer to next structure -->
+            <member><type>VkFormat</type>                         <name>format</name></member>
+            <member><type>VkImageType</type>                      <name>type</name></member>
+            <member><type>VkImageTiling</type>                    <name>tiling</name></member>
+            <member><type>VkImageUsageFlags</type>                <name>usage</name></member>
+            <member optional="true"><type>VkImageCreateFlags</type> <name>flags</name></member>
+        </type>
+        <type category="struct" name="VkExternalMemoryPropertiesKHX" returnedonly="true">
+            <member><type>VkExternalMemoryFeatureFlagsKHX</type>  <name>externalMemoryFeatures</name></member>
+            <member optional="true"><type>VkExternalMemoryHandleTypeFlagsKHX</type> <name>exportFromImportedHandleTypes</name></member>
+            <member><type>VkExternalMemoryHandleTypeFlagsKHX</type> <name>compatibleHandleTypes</name></member>
+        </type>
+        <type category="struct" name="VkPhysicalDeviceExternalImageFormatInfoKHX">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                      <name>pNext</name></member>                    <!-- Pointer to next structure -->
+            <member optional="true"><type>VkExternalMemoryHandleTypeFlagBitsKHX</type> <name>handleType</name></member>
+        </type>
+        <type category="struct" name="VkExternalImageFormatPropertiesKHX" returnedonly="true">
+            <member values="VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHX"><type>VkStructureType</type> <name>sType</name></member>
+            <member><type>void</type>*                            <name>pNext</name></member>                    <!-- Pointer to next structure -->
+            <member><type>VkExternalMemoryPropertiesKHX</type> <name>externalMemoryProperties</name></member>
+        </type>
+        <type category="struct" name="VkPhysicalDeviceExternalBufferInfoKHX">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                      <name>pNext</name></member>                    <!-- Pointer to next structure -->
+            <member optional="true"><type>VkBufferCreateFlags</type> <name>flags</name></member>
+            <member><type>VkBufferUsageFlags</type>               <name>usage</name></member>
+            <member><type>VkExternalMemoryHandleTypeFlagBitsKHX</type> <name>handleType</name></member>
+        </type>
+        <type category="struct" name="VkExternalBufferPropertiesKHX" returnedonly="true">
+            <member values="VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHX"><type>VkStructureType</type> <name>sType</name></member>
+            <member><type>void</type>*                            <name>pNext</name></member>                    <!-- Pointer to next structure -->
+            <member><type>VkExternalMemoryPropertiesKHX</type>    <name>externalMemoryProperties</name></member>
+        </type>
+        <type category="struct" name="VkPhysicalDeviceIDPropertiesKHX" returnedonly="true">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHX"><type>VkStructureType</type> <name>sType</name></member>
+            <member><type>void</type>*                            <name>pNext</name></member>                    <!-- Pointer to next structure -->
+            <member><type>uint8_t</type>                          <name>deviceUUID</name>[<enum>VK_UUID_SIZE</enum>]</member>
+            <member><type>uint8_t</type>                          <name>driverUUID</name>[<enum>VK_UUID_SIZE</enum>]</member>
+            <member><type>uint8_t</type>                          <name>deviceLUID</name>[<enum>VK_LUID_SIZE_KHX</enum>]</member>
+            <member><type>VkBool32</type>                         <name>deviceLUIDValid</name></member>
+        </type>
+        <type category="struct" name="VkExternalMemoryImageCreateInfoKHX">
+            <member values="VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                      <name>pNext</name></member>                    <!-- Pointer to next structure -->
+            <member><type>VkExternalMemoryHandleTypeFlagsKHX</type> <name>handleTypes</name></member>
+        </type>
+        <type category="struct" name="VkExternalMemoryBufferCreateInfoKHX">
+            <member values="VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                      <name>pNext</name></member>                    <!-- Pointer to next structure -->
+            <member optional="true"><type>VkExternalMemoryHandleTypeFlagsKHX</type> <name>handleTypes</name></member>
+        </type>
+        <type category="struct" name="VkExportMemoryAllocateInfoKHX">
+            <member values="VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                      <name>pNext</name></member>                    <!-- Pointer to next structure -->
+            <member optional="true"><type>VkExternalMemoryHandleTypeFlagsKHX</type> <name>handleTypes</name></member>
+        </type>
+        <type category="struct" name="VkImportMemoryWin32HandleInfoKHX">
+            <member values="VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                      <name>pNext</name></member>                    <!-- Pointer to next structure -->
+            <member optional="true"><type>VkExternalMemoryHandleTypeFlagBitsKHX</type> <name>handleType</name></member>
+            <member><type>HANDLE</type>                           <name>handle</name></member>
+        </type>
+        <type category="struct" name="VkExportMemoryWin32HandleInfoKHX">
+            <member values="VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                      <name>pNext</name></member>                    <!-- Pointer to next structure -->
+            <member optional="true">const <type>SECURITY_ATTRIBUTES</type>* <name>pAttributes</name></member>
+            <member><type>DWORD</type>                            <name>dwAccess</name></member>
+            <member><type>LPCWSTR</type>                          <name>name</name></member>
+        </type>
+        <type category="struct" name="VkMemoryWin32HandlePropertiesKHX" returnedonly="true">
+            <member values="VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHX"><type>VkStructureType</type> <name>sType</name></member>
+            <member><type>void</type>*                            <name>pNext</name></member>                    <!-- Pointer to next structure -->
+            <member><type>uint32_t</type>                         <name>memoryTypeBits</name></member>
+        </type>
+        <type category="struct" name="VkImportMemoryFdInfoKHX">
+            <member values="VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                      <name>pNext</name></member>                    <!-- Pointer to next structure -->
+            <member optional="true"><type>VkExternalMemoryHandleTypeFlagBitsKHX</type> <name>handleType</name></member>
+            <member><type>int</type>                              <name>fd</name></member>
+        </type>
+        <type category="struct" name="VkMemoryFdPropertiesKHX" returnedonly="true">
+            <member values="VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHX"><type>VkStructureType</type> <name>sType</name></member>
+            <member><type>void</type>*                            <name>pNext</name></member>                    <!-- Pointer to next structure -->
+            <member><type>uint32_t</type>                         <name>memoryTypeBits</name></member>
+        </type>
+        <type category="struct" name="VkWin32KeyedMutexAcquireReleaseInfoKHX">
+            <member values="VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                      <name>pNext</name></member>                    <!-- Pointer to next structure -->
+            <member optional="true"><type>uint32_t</type>         <name>acquireCount</name></member>
+            <member len="acquireCount">const <type>VkDeviceMemory</type>* <name>pAcquireSyncs</name></member>
+            <member len="acquireCount">const <type>uint64_t</type>* <name>pAcquireKeys</name></member>
+            <member len="acquireCount">const <type>uint32_t</type>* <name>pAcquireTimeouts</name></member>
+            <member optional="true"><type>uint32_t</type>         <name>releaseCount</name></member>
+            <member len="releaseCount">const <type>VkDeviceMemory</type>* <name>pReleaseSyncs</name></member>
+            <member len="releaseCount">const <type>uint64_t</type>* <name>pReleaseKeys</name></member>
+        </type>
+        <type category="struct" name="VkPhysicalDeviceExternalSemaphoreInfoKHX">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                      <name>pNext</name></member>                    <!-- Pointer to next structure -->
+            <member><type>VkExternalSemaphoreHandleTypeFlagBitsKHX</type> <name>handleType</name></member>
+        </type>
+        <type category="struct" name="VkExternalSemaphorePropertiesKHX" returnedonly="true">
+            <member values="VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHX"><type>VkStructureType</type> <name>sType</name></member>
+            <member><type>void</type>*                            <name>pNext</name></member>                    <!-- Pointer to next structure -->
+            <member><type>VkExternalSemaphoreHandleTypeFlagsKHX</type> <name>exportFromImportedHandleTypes</name></member>
+            <member><type>VkExternalSemaphoreHandleTypeFlagsKHX</type> <name>compatibleHandleTypes</name></member>
+            <member optional="true"><type>VkExternalSemaphoreFeatureFlagsKHX</type> <name>externalSemaphoreFeatures</name></member>
+        </type>
+        <type category="struct" name="VkExportSemaphoreCreateInfoKHX">
+            <member values="VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                      <name>pNext</name></member>                    <!-- Pointer to next structure -->
+            <member optional="true"><type>VkExternalSemaphoreHandleTypeFlagsKHX</type> <name>handleTypes</name></member>
+        </type>
+        <type category="struct" name="VkImportSemaphoreWin32HandleInfoKHX">
+            <member values="VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                      <name>pNext</name></member>                    <!-- Pointer to next structure -->
+            <member><type>VkSemaphore</type>                      <name>semaphore</name></member>
+            <member><type>VkExternalSemaphoreHandleTypeFlagsKHX</type> <name>handleType</name></member>
+            <member><type>HANDLE</type>                           <name>handle</name></member>
+        </type>
+        <type category="struct" name="VkExportSemaphoreWin32HandleInfoKHX">
+            <member values="VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                      <name>pNext</name></member>                    <!-- Pointer to next structure -->
+            <member optional="true">const <type>SECURITY_ATTRIBUTES</type>*       <name>pAttributes</name></member>
+            <member><type>DWORD</type>                            <name>dwAccess</name></member>
+            <member><type>LPCWSTR</type>                          <name>name</name></member>
+        </type>
+        <type category="struct" name="VkD3D12FenceSubmitInfoKHX">
+            <member values="VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                      <name>pNext</name></member>                    <!-- Pointer to next structure -->
+            <member optional="true"><type>uint32_t</type>         <name>waitSemaphoreValuesCount</name></member>
+            <member optional="true" len="waitSemaphoreValuesCount">const <type>uint64_t</type>* <name>pWaitSemaphoreValues</name></member>
+            <member optional="true"><type>uint32_t</type>         <name>signalSemaphoreValuesCount</name></member>
+            <member optional="true" len="signalSemaphoreValuesCount">const <type>uint64_t</type>* <name>pSignalSemaphoreValues</name></member>
+        </type>
+        <type category="struct" name="VkImportSemaphoreFdInfoKHX">
+            <member values="VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                      <name>pNext</name></member>                    <!-- Pointer to next structure -->
+            <member><type>VkSemaphore</type>                      <name>semaphore</name></member>
+            <member><type>VkExternalSemaphoreHandleTypeFlagBitsKHX</type> <name>handleType</name></member>
+            <member><type>int</type>                              <name>fd</name></member>
+        </type>
+        <type category="struct" name="VkPhysicalDeviceMultiviewFeaturesKHX">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHX"><type>VkStructureType</type> <name>sType</name></member>
+            <member><type>void</type>*                            <name>pNext</name></member>                    <!-- Pointer to next structure -->
+            <member><type>VkBool32</type>                         <name>multiview</name></member>                <!-- Multiple views in a renderpass -->
+            <member><type>VkBool32</type>                         <name>multiviewGeometryShader</name></member>  <!-- Multiple views in a renderpass w/ geometry shader -->
+            <member><type>VkBool32</type>                         <name>multiviewTessellationShader</name></member> <!-- Multiple views in a renderpass w/ tessellation shader -->
+        </type>
+        <type category="struct" name="VkPhysicalDeviceMultiviewPropertiesKHX" returnedonly="true">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHX"><type>VkStructureType</type> <name>sType</name></member>
+            <member><type>void</type>*                            <name>pNext</name></member>                    <!-- Pointer to next structure -->
+            <member><type>uint32_t</type>                         <name>maxMultiviewViewCount</name></member>    <!-- max number of views in a subpass -->
+            <member><type>uint32_t</type>                         <name>maxMultiviewInstanceIndex</name></member> <!-- max instance index for a draw in a multiview subpass -->
+        </type>
+        <type category="struct" name="VkRenderPassMultiviewCreateInfoKHX">
+            <member values="VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHX"><type>VkStructureType</type>        <name>sType</name></member>
+            <member>const <type>void</type>*            <name>pNext</name></member>                          <!-- Pointer to next structure -->
+            <member optional="true"><type>uint32_t</type>               <name>subpassCount</name></member>
+            <member len="subpassCount">const <type>uint32_t</type>*     <name>pViewMasks</name></member>
+            <member optional="true"><type>uint32_t</type>               <name>dependencyCount</name></member>
+            <member len="dependencyCount">const <type>int32_t</type>*   <name>pViewOffsets</name></member>
+            <member optional="true"><type>uint32_t</type>               <name>correlationMaskCount</name></member>
+            <member len="correlationMaskCount">const <type>uint32_t</type>* <name>pCorrelationMasks</name></member>
+        </type>
         <type category="struct" name="VkSurfaceCapabilities2EXT" returnedonly="true">
             <member values="VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT"><type>VkStructureType</type> <name>sType</name></member>
             <member><type>void</type>*                            <name>pNext</name></member>
@@ -1828,6 +2038,131 @@ maintained in the master branch of the Khronos Vulkan GitHub project.
             <member>const <type>void</type>*                      <name>pNext</name></member>
             <member optional="true"><type>VkSurfaceCounterFlagsEXT</type>         <name>surfaceCounters</name></member>
         </type>
+        <type category="struct" name="VkPhysicalDeviceGroupPropertiesKHX" returnedonly="true">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHX"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                      <name>pNext</name></member>                    <!-- Pointer to next structure -->
+            <member><type>uint32_t</type>                         <name>physicalDeviceCount</name></member>
+            <member><type>VkPhysicalDevice</type>                 <name>physicalDevices</name>[<enum>VK_MAX_DEVICE_GROUP_SIZE_KHX</enum>]</member>
+            <member><type>VkBool32</type>                         <name>subsetAllocation</name></member>
+        </type>
+        <type category="struct" name="VkMemoryAllocateFlagsInfoKHX">
+            <member values="VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                      <name>pNext</name></member>                    <!-- Pointer to next structure -->
+            <member optional="true"><type>VkMemoryAllocateFlagsKHX</type> <name>flags</name></member>
+            <member><type>uint32_t</type>                         <name>deviceMask</name></member>
+        </type>
+        <type category="struct" name="VkBindBufferMemoryInfoKHX">
+            <member values="VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                      <name>pNext</name></member>                    <!-- Pointer to next structure -->
+            <member><type>VkBuffer</type>                         <name>buffer</name></member>
+            <member><type>VkDeviceMemory</type>                   <name>memory</name></member>
+            <member><type>VkDeviceSize</type>                     <name>memoryOffset</name></member>
+            <member optional="true"><type>uint32_t</type>         <name>deviceIndexCount</name></member>
+            <member len="deviceIndexCount">const <type>uint32_t</type>*  <name>pDeviceIndices</name></member>
+        </type>
+        <type category="struct" name="VkBindImageMemoryInfoKHX">
+            <member values="VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member>
+            <member validextensionstructs="VkBindImageMemorySwapchainInfoKHX">const <type>void</type>*                      <name>pNext</name></member>                    <!-- Pointer to next structure -->
+            <member><type>VkImage</type>                          <name>image</name></member>
+            <member><type>VkDeviceMemory</type>                   <name>memory</name></member>
+            <member><type>VkDeviceSize</type>                     <name>memoryOffset</name></member>
+            <member optional="true"><type>uint32_t</type>         <name>deviceIndexCount</name></member>
+            <member len="deviceIndexCount">const <type>uint32_t</type>*  <name>pDeviceIndices</name></member>
+            <member optional="true"><type>uint32_t</type>         <name>SFRRectCount</name></member>
+            <member len="SFRRectCount">const <type>VkRect2D</type>*  <name>pSFRRects</name></member>
+        </type>
+        <type category="struct" name="VkDeviceGroupRenderPassBeginInfoKHX">
+            <member values="VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                      <name>pNext</name></member>                          <!-- Pointer to next structure -->
+            <member><type>uint32_t</type>                         <name>deviceMask</name></member>
+            <member optional="true"><type>uint32_t</type>         <name>deviceRenderAreaCount</name></member>
+            <member len="deviceRenderAreaCount">const <type>VkRect2D</type>*  <name>pDeviceRenderAreas</name></member>
+        </type>
+        <type category="struct" name="VkDeviceGroupCommandBufferBeginInfoKHX">
+            <member values="VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                      <name>pNext</name></member>                          <!-- Pointer to next structure -->
+            <member><type>uint32_t</type>                         <name>deviceMask</name></member>
+        </type>
+        <type category="struct" name="VkDeviceGroupSubmitInfoKHX">
+            <member values="VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                      <name>pNext</name></member>                          <!-- Pointer to next structure -->
+            <member optional="true"><type>uint32_t</type>         <name>waitSemaphoreCount</name></member>
+            <member len="waitSemaphoreCount">const <type>uint32_t</type>*    <name>pWaitSemaphoreDeviceIndices</name></member>
+            <member optional="true"><type>uint32_t</type>         <name>commandBufferCount</name></member>
+            <member len="commandBufferCount">const <type>uint32_t</type>*    <name>pCommandBufferDeviceMasks</name></member>
+            <member optional="true"><type>uint32_t</type>         <name>signalSemaphoreCount</name></member>
+            <member len="signalSemaphoreCount">const <type>uint32_t</type>*  <name>pSignalSemaphoreDeviceIndices</name></member>
+        </type>
+        <type category="struct" name="VkDeviceGroupBindSparseInfoKHX">
+            <member values="VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                      <name>pNext</name></member>                          <!-- Pointer to next structure -->
+            <member><type>uint32_t</type>                         <name>resourceDeviceIndex</name></member>
+            <member><type>uint32_t</type>                         <name>memoryDeviceIndex</name></member>
+        </type>
+        <type category="struct" name="VkDeviceGroupPresentCapabilitiesKHX" returnedonly="true">
+            <member values="VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHX"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                      <name>pNext</name></member>                    <!-- Pointer to next structure -->
+            <member><type>uint32_t</type>                         <name>presentMask</name>[<enum>VK_MAX_DEVICE_GROUP_SIZE_KHX</enum>]</member>
+            <member><type>VkDeviceGroupPresentModeFlagsKHX</type> <name>modes</name></member>
+        </type>
+        <type category="struct" name="VkImageSwapchainCreateInfoKHX">
+            <member values="VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                      <name>pNext</name></member>                    <!-- Pointer to next structure -->
+            <member optional="true"><type>VkSwapchainKHR</type>   <name>swapchain</name></member>
+        </type>
+        <type category="struct" name="VkBindImageMemorySwapchainInfoKHX">
+            <member values="VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                      <name>pNext</name></member>                    <!-- Pointer to next structure -->
+            <member externsync="true"><type>VkSwapchainKHR</type> <name>swapchain</name></member>
+            <member><type>uint32_t</type>                         <name>imageIndex</name></member>
+        </type>
+        <type category="struct" name="VkAcquireNextImageInfoKHX">
+            <member values="VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                      <name>pNext</name></member>                    <!-- Pointer to next structure -->
+            <member externsync="true"><type>VkSwapchainKHR</type> <name>swapchain</name></member>
+            <member><type>uint64_t</type>                         <name>timeout</name></member>
+            <member optional="true" externsync="true"><type>VkSemaphore</type> <name>semaphore</name></member>
+            <member optional="true" externsync="true"><type>VkFence</type> <name>fence</name></member>
+            <member><type>uint32_t</type>                         <name>deviceMask</name></member>
+        </type>
+        <type category="struct" name="VkDeviceGroupPresentInfoKHX">
+            <member values="VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*  <name>pNext</name></member> <!-- Pointer to next structure -->
+            <member optional="true"><type>uint32_t</type>         <name>swapchainCount</name></member>
+            <member len="swapchainCount">const <type>uint32_t</type>* <name>pDeviceMasks</name></member>
+            <member><type>VkDeviceGroupPresentModeFlagBitsKHX</type> <name>mode</name></member>
+        </type>
+        <type category="struct" name="VkDeviceGroupDeviceCreateInfoKHX">
+            <member values="VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                      <name>pNext</name></member>                          <!-- Pointer to next structure -->
+            <member optional="true"><type>uint32_t</type>                         <name>physicalDeviceCount</name></member>
+            <member len="physicalDeviceCount">const <type>VkPhysicalDevice</type>*  <name>pPhysicalDevices</name></member>
+        </type>
+        <type category="struct" name="VkDeviceGroupSwapchainCreateInfoKHX">
+            <member values="VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                      <name>pNext</name></member>                          <!-- Pointer to next structure -->
+            <member><type>VkDeviceGroupPresentModeFlagsKHX</type>                         <name>modes</name></member>
+        </type>
+        <type category="struct" name="VkDescriptorUpdateTemplateEntryKHR">
+            <member><type>uint32_t</type>                         <name>dstBinding</name></member>                     <!-- Binding within the destination descriptor set to write -->
+            <member><type>uint32_t</type>                         <name>dstArrayElement</name></member>                <!-- Array element within the destination binding to write -->
+            <member><type>uint32_t</type>                         <name>descriptorCount</name></member>                <!-- Number of descriptors to write -->
+            <member><type>VkDescriptorType</type>                 <name>descriptorType</name></member>                 <!-- Descriptor type to write -->
+            <member><type>size_t</type>                           <name>offset</name></member>                         <!-- Offset into pData where the descriptors to update are stored -->
+            <member><type>size_t</type>                           <name>stride</name></member>                         <!-- Stride between two descriptors in pData when writing more than one descriptor -->
+        </type>
+        <type category="struct" name="VkDescriptorUpdateTemplateCreateInfoKHR">
+            <member values="VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
+            <member><type>void</type>*                                   <name>pNext</name></member>                    <!-- Pointer to next structure -->
+            <member optional="true"><type>VkDescriptorUpdateTemplateCreateFlagsKHR</type>    <name>flags</name></member>                      <!-- Reserved -->
+            <member><type>uint32_t</type>                 <name>descriptorUpdateEntryCount</name></member>      <!-- Number of descriptor update entries to use for the update template -->
+            <member len="descriptorUpdateEntryCount">const <type>VkDescriptorUpdateTemplateEntryKHR</type>* <name>pDescriptorUpdateEntries</name></member> <!-- Descriptor update entries for the template -->
+            <member><type>VkDescriptorUpdateTemplateTypeKHR</type> <name>templateType</name></member>
+            <member optional="true"><type>VkDescriptorSetLayout</type> <name>descriptorSetLayout</name></member>
+            <member optional="true"><type>VkPipelineBindPoint</type> <name>pipelineBindPoint</name></member>
+            <member optional="true"><type>VkPipelineLayout</type><name>pipelineLayout</name></member>                             <!-- If used for push descriptors, this is the only allowed layout -->
+            <member optional="true"><type>uint32_t</type> <name>set</name></member>
+        </type>
         <type category="struct" name="VkXYColorEXT">
             <!-- chromaticity coordinate -->
             <member><type>float</type>   <name>x</name></member>
@@ -1842,6 +2177,60 @@ maintained in the master branch of the Khronos Vulkan GitHub project.
             <member><type>float</type>   <name>maxLuminance</name></member>          <!-- Display maximum luminance -->
             <member><type>float</type>   <name>minLuminance</name></member>          <!-- Display minimum luminance -->
         </type>
+        <type category="struct" name="VkIOSSurfaceCreateInfoMVK">
+            <member values="VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                                    <name>pNext</name></member>     <!-- Pointer to next structure -->
+            <member optional="true"><type>VkIOSSurfaceCreateFlagsMVK</type>     <name>flags</name></member>     <!-- Reserved -->
+            <member>const <type>void</type>*                                    <name>pView</name></member>
+        </type>
+        <type category="struct" name="VkMacOSSurfaceCreateInfoMVK">
+            <member values="VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                                    <name>pNext</name></member>     <!-- Pointer to next structure -->
+            <member optional="true"><type>VkMacOSSurfaceCreateFlagsMVK</type>   <name>flags</name></member>     <!-- Reserved -->
+            <member>const <type>void</type>*                                    <name>pView</name></member>
+        </type>
+        <type category="struct" name="VkViewportWScalingNV">
+            <member><type>float</type>          <name>xcoeff</name></member>
+            <member><type>float</type>          <name>ycoeff</name></member>
+        </type>
+        <type category="struct" name="VkPipelineViewportWScalingStateCreateInfoNV">
+            <member values="VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*            <name>pNext</name></member>                          <!-- Pointer to next structure -->
+            <member><type>VkBool32</type>               <name>viewportWScalingEnable</name></member>
+            <member><type>uint32_t</type>               <name>viewportCount</name></member>
+            <member noautovalidity="true" len="viewportCount">const <type>VkViewportWScalingNV</type>*      <name>pViewportWScalings</name></member>
+        </type>
+        <type category="struct" name="VkViewportSwizzleNV">
+            <member><type>VkViewportCoordinateSwizzleNV</type>          <name>x</name></member>
+            <member><type>VkViewportCoordinateSwizzleNV</type>          <name>y</name></member>
+            <member><type>VkViewportCoordinateSwizzleNV</type>          <name>z</name></member>
+            <member><type>VkViewportCoordinateSwizzleNV</type>          <name>w</name></member>
+        </type>
+        <type category="struct" name="VkPipelineViewportSwizzleStateCreateInfoNV">
+            <member values="VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*            <name>pNext</name></member>                          <!-- Pointer to next structure -->
+            <member optional="true"><type>VkPipelineViewportSwizzleStateCreateFlagsNV</type>    <name>flags</name></member>           <!-- Reserved -->
+            <member><type>uint32_t</type>               <name>viewportCount</name></member>
+            <member noautovalidity="true" optional="true" len="viewportCount">const <type>VkViewportSwizzleNV</type>*      <name>pViewportSwizzles</name></member>
+        </type>
+        <type category="struct" name="VkPhysicalDeviceDiscardRectanglePropertiesEXT">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*            <name>pNext</name></member>                          <!-- Pointer to next structure -->
+            <member><type>uint32_t</type>               <name>maxDiscardRectangles</name></member>           <!-- max number of active discard rectangles -->
+        </type>
+        <type category="struct" name="VkPipelineDiscardRectangleStateCreateInfoEXT">
+            <member values="VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                                                                      <name>pNext</name></member>                 <!-- Pointer to next structure -->
+            <member optional="true"><type>VkPipelineDiscardRectangleStateCreateFlagsEXT</type>                    <name>flags</name></member>                 <!-- Reserved -->
+            <member><type>VkDiscardRectangleModeEXT</type>                                                        <name>discardRectangleMode</name></member>
+            <member optional="true"><type>uint32_t</type>                                                         <name>discardRectangleCount</name></member>
+            <member noautovalidity="true" optional="true" len="discardRectangleCount">const <type>VkRect2D</type>* <name>pDiscardRectangles</name></member>
+        </type>
+        <type category="struct" name="VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX" returnedonly="true">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX"><type>VkStructureType</type> <name>sType</name></member>
+            <member><type>void</type>*                            <name>pNext</name></member>                    <!-- Pointer to next structure -->
+            <member><type>VkBool32</type>                         <name>perViewPositionAllComponents</name></member>
+        </type>
     </types>
 
     <!-- SECTION: Vulkan enumerant (token) definitions. -->
@@ -1850,6 +2239,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project.
             <!-- This is part of the header boilerplate -->
         <enum value="256"   name="VK_MAX_PHYSICAL_DEVICE_NAME_SIZE"/>
         <enum value="16"    name="VK_UUID_SIZE"/>
+        <enum value="8"     name="VK_LUID_SIZE_KHX"/>
         <enum value="256"   name="VK_MAX_EXTENSION_NAME_SIZE"/>
         <enum value="256"   name="VK_MAX_DESCRIPTION_SIZE"/>
         <enum value="32"    name="VK_MAX_MEMORY_TYPES"/>
@@ -1862,7 +2252,9 @@ maintained in the master branch of the Khronos Vulkan GitHub project.
         <enum value="1"     name="VK_TRUE"/>
         <enum value="0"     name="VK_FALSE"/>
         <enum value="(~0U)" name="VK_QUEUE_FAMILY_IGNORED"/>
+        <enum value="(~0U-1)" name="VK_QUEUE_FAMILY_EXTERNAL_KHX"/>
         <enum value="(~0U)" name="VK_SUBPASS_EXTERNAL"/>
+        <enum value="32"    name="VK_MAX_DEVICE_GROUP_SIZE_KHX"/>
     </enums>
 
     <!-- Unlike OpenGL, most tokens in Vulkan are actual typed enumerants in
@@ -2370,6 +2762,10 @@ maintained in the master branch of the Khronos Vulkan GitHub project.
         <enum value="7"    name="VK_DYNAMIC_STATE_STENCIL_WRITE_MASK"/>
         <enum value="8"    name="VK_DYNAMIC_STATE_STENCIL_REFERENCE"/>
     </enums>
+    <enums name="VkDescriptorUpdateTemplateTypeKHR" type="enum">
+        <enum value="0"    name="VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR"   comment="Create descriptor update template for descriptor set updates"/>
+        <enum value="1"    name="VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR" comment="Create descriptor update template for pushed descriptor updates"/>
+    </enums>
 
     <!-- Flags -->
     <enums name="VkQueueFlagBits" type="bitmask">
@@ -2697,6 +3093,33 @@ maintained in the master branch of the Khronos Vulkan GitHub project.
         <enum value="3" name="VK_OBJECT_ENTRY_VERTEX_BUFFER_NVX"/>
         <enum value="4" name="VK_OBJECT_ENTRY_PUSH_CONSTANT_NVX"/>
     </enums>
+    <enums name="VkDescriptorSetLayoutCreateFlagBits" type="bitmask">
+    </enums>
+    <enums name="VkExternalMemoryHandleTypeFlagBitsKHX" type="bitmask">
+        <enum bitpos="0" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHX"/>
+        <enum bitpos="1" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHX"/>
+        <enum bitpos="2" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHX"/>
+        <enum bitpos="3" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHX"/>
+        <enum bitpos="4" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHX"/>
+        <enum bitpos="5" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHX"/>
+        <enum bitpos="6" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHX"/>
+    </enums>
+    <enums name="VkExternalMemoryFeatureFlagBitsKHX" type="bitmask">
+        <enum bitpos="0" name="VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHX"/>
+        <enum bitpos="1" name="VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHX"/>
+        <enum bitpos="2" name="VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHX"/>
+    </enums>
+    <enums name="VkExternalSemaphoreHandleTypeFlagBitsKHX" type="bitmask">
+        <enum bitpos="0" name="VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHX"/>
+        <enum bitpos="1" name="VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHX"/>
+        <enum bitpos="2" name="VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHX"/>
+        <enum bitpos="3" name="VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHX"/>
+        <enum bitpos="4" name="VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FENCE_FD_BIT_KHX"/>
+    </enums>
+    <enums name="VkExternalSemaphoreFeatureFlagBitsKHX" type="bitmask">
+        <enum bitpos="0" name="VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHX"/>
+        <enum bitpos="1" name="VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHX"/>
+    </enums>
     <enums name="VkSurfaceCounterFlagBitsEXT" type="bitmask">
         <enum bitpos="0" name="VK_SURFACE_COUNTER_VBLANK_EXT"/>
     </enums>
@@ -2711,6 +3134,39 @@ maintained in the master branch of the Khronos Vulkan GitHub project.
     <enums name="VkDisplayEventTypeEXT" type="enum">
         <enum value="0" name="VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT"/>
     </enums>
+    <enums name="VkPeerMemoryFeatureFlagBitsKHX" type="bitmask">
+        <enum bitpos="0"    name="VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHX"           comment="Can read with vkCmdCopy commands"/>
+        <enum bitpos="1"    name="VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHX"           comment="Can write with vkCmdCopy commands"/>
+        <enum bitpos="2"    name="VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHX"        comment="Can read with any access type/command"/>
+        <enum bitpos="3"    name="VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHX"        comment="Can write with and access type/command"/>
+    </enums>
+    <enums name="VkMemoryAllocateFlagBitsKHX" type="bitmask">
+        <enum bitpos="0"    name="VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHX"            comment="Force allocation on specific devices"/>
+    </enums>
+    <enums name="VkDeviceGroupPresentModeFlagBitsKHX" type="bitmask">
+        <enum bitpos="0"    name="VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHX"        comment="Present from local memory"/>
+        <enum bitpos="1"    name="VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHX"       comment="Present from remote memory"/>
+        <enum bitpos="2"    name="VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHX"          comment="Present sum of local and/or remote memory"/>
+        <enum bitpos="3"    name="VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHX" comment="Each physical device presents from local memory"/>
+    </enums>
+    <enums name="VkSwapchainCreateFlagBitsKHR" type="bitmask">
+    </enums>
+    <enums name="VkViewportCoordinateSwizzleNV" type="enum">
+        <enum value="0" name="VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV"/>
+        <enum value="1" name="VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV"/>
+        <enum value="2" name="VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV"/>
+        <enum value="3" name="VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV"/>
+        <enum value="4" name="VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV"/>
+        <enum value="5" name="VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV"/>
+        <enum value="6" name="VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV"/>
+        <enum value="7" name="VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV"/>
+    </enums>
+    <enums name="VkDiscardRectangleModeEXT" type="enum">
+        <enum value="0"     name="VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT"/>
+        <enum value="1"     name="VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT"/>
+    </enums>
+    <enums name="VkSubpassDescriptionFlagBits" type="bitmask">
+    </enums>
 
     <!-- SECTION: Vulkan command definitions -->
     <commands>
@@ -2839,7 +3295,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project.
                 <param>all sname:VkQueue objects created from pname:device</param>
             </implicitexternsyncparams>
         </command>
-        <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_TOO_MANY_OBJECTS">
+        <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_TOO_MANY_OBJECTS,VK_ERROR_INVALID_EXTERNAL_HANDLE_KHX">
             <proto><type>VkResult</type> <name>vkAllocateMemory</name></proto>
             <param><type>VkDevice</type> <name>device</name></param>
             <param>const <type>VkMemoryAllocateInfo</type>* <name>pAllocateInfo</name></param>
@@ -3216,7 +3672,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project.
                 <param>any sname:VkDescriptorSet objects allocated from pname:descriptorPool</param>
             </implicitexternsyncparams>
         </command>
-        <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_FRAGMENTED_POOL">
+        <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_FRAGMENTED_POOL,VK_ERROR_OUT_OF_POOL_MEMORY_KHR">
             <proto><type>VkResult</type> <name>vkAllocateDescriptorSets</name></proto>
             <param><type>VkDevice</type> <name>device</name></param>
             <param externsync="pAllocateInfo::descriptorPool">const <type>VkDescriptorSetAllocateInfo</type>* <name>pAllocateInfo</name></param>
@@ -3444,9 +3900,9 @@ maintained in the master branch of the Khronos Vulkan GitHub project.
         <command queues="compute" renderpass="outside" cmdbufferlevel="primary,secondary" pipeline="compute">
             <proto><type>void</type> <name>vkCmdDispatch</name></proto>
             <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
-            <param><type>uint32_t</type> <name>x</name></param>
-            <param><type>uint32_t</type> <name>y</name></param>
-            <param><type>uint32_t</type> <name>z</name></param>
+            <param><type>uint32_t</type> <name>groupCountX</name></param>
+            <param><type>uint32_t</type> <name>groupCountY</name></param>
+            <param><type>uint32_t</type> <name>groupCountZ</name></param>
         </command>
         <command queues="compute" renderpass="outside" cmdbufferlevel="primary,secondary" pipeline="compute">
             <proto><type>void</type> <name>vkCmdDispatchIndirect</name></proto>
@@ -4047,12 +4503,96 @@ maintained in the master branch of the Khronos Vulkan GitHub project.
             <param optional="false,true"><type>uint32_t</type>* <name>pPropertyCount</name></param>
             <param optional="true" len="pPropertyCount"><type>VkSparseImageFormatProperties2KHR</type>* <name>pProperties</name></param>
         </command>
+        <command queues="graphics,compute" renderpass="both" cmdbufferlevel="primary,secondary">
+            <proto><type>void</type> <name>vkCmdPushDescriptorSetKHR</name></proto>
+            <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
+            <param><type>VkPipelineBindPoint</type> <name>pipelineBindPoint</name></param>
+            <param><type>VkPipelineLayout</type> <name>layout</name></param>
+            <param><type>uint32_t</type> <name>set</name></param>
+            <param><type>uint32_t</type> <name>descriptorWriteCount</name></param>
+            <param len="descriptorWriteCount">const <type>VkWriteDescriptorSet</type>* <name>pDescriptorWrites</name></param>
+        </command>
         <command>
              <proto><type>void</type> <name>vkTrimCommandPoolKHR</name></proto>
              <param><type>VkDevice</type> <name>device</name></param>
              <param externsync="true"><type>VkCommandPool</type> <name>commandPool</name></param>
              <param optional="true"><type>VkCommandPoolTrimFlagsKHR</type> <name>flags</name></param>
         </command>
+        <command>
+            <proto><type>void</type> <name>vkGetPhysicalDeviceProperties2KHX</name></proto>
+            <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
+            <param><type>VkPhysicalDeviceProperties2KHX</type>* <name>pProperties</name></param>
+        </command>
+        <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_FORMAT_NOT_SUPPORTED">
+            <proto><type>VkResult</type> <name>vkGetPhysicalDeviceImageFormatProperties2KHX</name></proto>
+            <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
+            <param>const <type>VkPhysicalDeviceImageFormatInfo2KHX</type>* <name>pImageFormatInfo</name></param>
+            <param><type>VkImageFormatProperties2KHX</type>* <name>pImageFormatProperties</name></param>
+        </command>
+        <command>
+            <proto><type>void</type> <name>vkGetPhysicalDeviceExternalBufferPropertiesKHX</name></proto>
+            <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
+            <param>const <type>VkPhysicalDeviceExternalBufferInfoKHX</type>* <name>pExternalBufferInfo</name></param>
+            <param><type>VkExternalBufferPropertiesKHX</type>* <name>pExternalBufferProperties</name></param>
+        </command>
+        <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_TOO_MANY_OBJECTS,VK_ERROR_OUT_OF_HOST_MEMORY">
+            <proto><type>VkResult</type> <name>vkGetMemoryWin32HandleKHX</name></proto>
+            <param><type>VkDevice</type> <name>device</name></param>
+            <param><type>VkDeviceMemory</type> <name>memory</name></param>
+            <param><type>VkExternalMemoryHandleTypeFlagBitsKHX</type> <name>handleType</name></param>
+            <param><type>HANDLE</type>* <name>pHandle</name></param>
+        </command>
+        <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_INVALID_EXTERNAL_HANDLE_KHX">
+            <proto><type>VkResult</type> <name>vkGetMemoryWin32HandlePropertiesKHX</name></proto>
+            <param><type>VkDevice</type> <name>device</name></param>
+            <param><type>VkExternalMemoryHandleTypeFlagBitsKHX</type> <name>handleType</name></param>
+            <param><type>HANDLE</type> <name>handle</name></param>
+            <param><type>VkMemoryWin32HandlePropertiesKHX</type>* <name>pMemoryWin32HandleProperties</name></param>
+        </command>
+        <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_TOO_MANY_OBJECTS,VK_ERROR_OUT_OF_HOST_MEMORY">
+            <proto><type>VkResult</type> <name>vkGetMemoryFdKHX</name></proto>
+            <param><type>VkDevice</type> <name>device</name></param>
+            <param><type>VkDeviceMemory</type> <name>memory</name></param>
+            <param><type>VkExternalMemoryHandleTypeFlagBitsKHX</type> <name>handleType</name></param>
+            <param><type>int</type>* <name>pFd</name></param>
+        </command>
+        <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_INVALID_EXTERNAL_HANDLE_KHX">
+            <proto><type>VkResult</type> <name>vkGetMemoryFdPropertiesKHX</name></proto>
+            <param><type>VkDevice</type> <name>device</name></param>
+            <param><type>VkExternalMemoryHandleTypeFlagBitsKHX</type> <name>handleType</name></param>
+            <param><type>int</type> <name>fd</name></param>
+            <param><type>VkMemoryFdPropertiesKHX</type>* <name>pMemoryFdProperties</name></param>
+        </command>
+        <command>
+            <proto><type>void</type> <name>vkGetPhysicalDeviceExternalSemaphorePropertiesKHX</name></proto>
+            <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
+            <param>const <type>VkPhysicalDeviceExternalSemaphoreInfoKHX</type>* <name>pExternalSemaphoreInfo</name></param>
+            <param><type>VkExternalSemaphorePropertiesKHX</type>* <name>pExternalSemaphoreProperties</name></param>
+        </command>
+        <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_TOO_MANY_OBJECTS,VK_ERROR_OUT_OF_HOST_MEMORY">
+            <proto><type>VkResult</type> <name>vkGetSemaphoreWin32HandleKHX</name></proto>
+            <param><type>VkDevice</type> <name>device</name></param>
+            <param><type>VkSemaphore</type> <name>semaphore</name></param>
+            <param><type>VkExternalSemaphoreHandleTypeFlagBitsKHX</type> <name>handleType</name></param>
+            <param><type>HANDLE</type>* <name>pHandle</name></param>
+        </command>
+        <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_INVALID_EXTERNAL_HANDLE_KHX">
+            <proto><type>VkResult</type> <name>vkImportSemaphoreWin32HandleKHX</name></proto>
+            <param><type>VkDevice</type> <name>device</name></param>
+            <param>const <type>VkImportSemaphoreWin32HandleInfoKHX</type>* <name>pImportSemaphoreWin32HandleInfo</name></param>
+        </command>
+        <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_TOO_MANY_OBJECTS,VK_ERROR_OUT_OF_HOST_MEMORY">
+            <proto><type>VkResult</type> <name>vkGetSemaphoreFdKHX</name></proto>
+            <param><type>VkDevice</type> <name>device</name></param>
+            <param><type>VkSemaphore</type> <name>semaphore</name></param>
+            <param><type>VkExternalSemaphoreHandleTypeFlagBitsKHX</type> <name>handleType</name></param>
+            <param><type>int</type>* <name>pFd</name></param>
+        </command>
+        <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_INVALID_EXTERNAL_HANDLE_KHX">
+            <proto><type>VkResult</type> <name>vkImportSemaphoreFdKHX</name></proto>
+            <param><type>VkDevice</type> <name>device</name></param>
+            <param>const <type>VkImportSemaphoreFdInfoKHX</type>* <name>pImportSemaphoreFdInfo</name></param>
+        </command>
         <command successcodes="VK_SUCCESS">
             <proto><type>VkResult</type> <name>vkReleaseDisplayEXT</name></proto>
             <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
@@ -4105,6 +4645,99 @@ maintained in the master branch of the Khronos Vulkan GitHub project.
             <param><type>VkSurfaceKHR</type> <name>surface</name></param>
             <param><type>VkSurfaceCapabilities2EXT</type>* <name>pSurfaceCapabilities</name></param>
         </command>
+        <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_INITIALIZATION_FAILED">
+            <proto><type>VkResult</type> <name>vkEnumeratePhysicalDeviceGroupsKHX</name></proto>
+            <param><type>VkInstance</type> <name>instance</name></param>
+            <param optional="false,true"><type>uint32_t</type>* <name>pPhysicalDeviceGroupCount</name></param>
+            <param optional="true" len="pPhysicalDeviceGroupCount"><type>VkPhysicalDeviceGroupPropertiesKHX</type>* <name>pPhysicalDeviceGroupProperties</name></param>
+        </command>
+        <command>
+            <proto><type>void</type> <name>vkGetDeviceGroupPeerMemoryFeaturesKHX</name></proto>
+            <param><type>VkDevice</type> <name>device</name></param>
+            <param><type>uint32_t</type> <name>heapIndex</name></param>
+            <param><type>uint32_t</type> <name>localDeviceIndex</name></param>
+            <param><type>uint32_t</type> <name>remoteDeviceIndex</name></param>
+            <param><type>VkPeerMemoryFeatureFlagsKHX</type>* <name>pPeerMemoryFeatures</name></param>
+        </command>
+        <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
+            <proto><type>VkResult</type> <name>vkBindBufferMemory2KHX</name></proto>
+            <param><type>VkDevice</type> <name>device</name></param>
+            <param><type>uint32_t</type> <name>bindInfoCount</name></param>
+            <param len="bindInfoCount">const <type>VkBindBufferMemoryInfoKHX</type>* <name>pBindInfos</name></param>
+        </command>
+        <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
+            <proto><type>VkResult</type> <name>vkBindImageMemory2KHX</name></proto>
+            <param><type>VkDevice</type> <name>device</name></param>
+            <param><type>uint32_t</type> <name>bindInfoCount</name></param>
+            <param len="bindInfoCount">const <type>VkBindImageMemoryInfoKHX</type>* <name>pBindInfos</name></param>
+        </command>
+        <command queues="graphics,compute,transfer" renderpass="both" cmdbufferlevel="primary,secondary">
+            <proto><type>void</type> <name>vkCmdSetDeviceMaskKHX</name></proto>
+            <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
+            <param><type>uint32_t</type> <name>deviceMask</name></param>
+        </command>
+        <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
+            <proto><type>VkResult</type> <name>vkGetDeviceGroupPresentCapabilitiesKHX</name></proto>
+            <param><type>VkDevice</type> <name>device</name></param>
+            <param><type>VkDeviceGroupPresentCapabilitiesKHX</type>* <name>pDeviceGroupPresentCapabilities</name></param>
+        </command>
+        <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_SURFACE_LOST_KHR">
+            <proto><type>VkResult</type> <name>vkGetDeviceGroupSurfacePresentModesKHX</name></proto>
+            <param><type>VkDevice</type> <name>device</name></param>
+            <param externsync="true"><type>VkSurfaceKHR</type> <name>surface</name></param>
+            <param><type>VkDeviceGroupPresentModeFlagsKHX</type>* <name>pModes</name></param>
+        </command>
+        <command successcodes="VK_SUCCESS,VK_TIMEOUT,VK_NOT_READY,VK_SUBOPTIMAL_KHR" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_DEVICE_LOST,VK_ERROR_OUT_OF_DATE_KHR,VK_ERROR_SURFACE_LOST_KHR">
+            <proto><type>VkResult</type> <name>vkAcquireNextImage2KHX</name></proto>
+            <param><type>VkDevice</type> <name>device</name></param>
+            <param>const <type>VkAcquireNextImageInfoKHX</type>* <name>pAcquireInfo</name></param>
+            <param><type>uint32_t</type>* <name>pImageIndex</name></param>
+        </command>
+        <command queues="compute" renderpass="outside" cmdbufferlevel="primary,secondary">
+            <proto><type>void</type> <name>vkCmdDispatchBaseKHX</name></proto>
+            <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
+            <param><type>uint32_t</type> <name>baseGroupX</name></param>
+            <param><type>uint32_t</type> <name>baseGroupY</name></param>
+            <param><type>uint32_t</type> <name>baseGroupZ</name></param>
+            <param><type>uint32_t</type> <name>groupCountX</name></param>
+            <param><type>uint32_t</type> <name>groupCountY</name></param>
+            <param><type>uint32_t</type> <name>groupCountZ</name></param>
+        </command>
+        <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
+            <proto><type>VkResult</type> <name>vkGetPhysicalDevicePresentRectanglesKHX</name></proto>
+            <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
+            <param externsync="true"><type>VkSurfaceKHR</type> <name>surface</name></param>
+            <param optional="false,true"><type>uint32_t</type>* <name>pRectCount</name></param>
+            <param optional="true" len="pRectCount"><type>VkRect2D</type>* <name>pRects</name></param>
+        </command>
+        <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
+            <proto><type>VkResult</type> <name>vkCreateDescriptorUpdateTemplateKHR</name></proto>
+            <param><type>VkDevice</type> <name>device</name></param>
+            <param>const <type>VkDescriptorUpdateTemplateCreateInfoKHR</type>* <name>pCreateInfo</name></param>
+            <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
+            <param><type>VkDescriptorUpdateTemplateKHR</type>* <name>pDescriptorUpdateTemplate</name></param>
+         </command>
+        <command>
+            <proto><type>void</type> <name>vkDestroyDescriptorUpdateTemplateKHR</name></proto>
+            <param><type>VkDevice</type> <name>device</name></param>
+            <param optional="true" externsync="true"><type>VkDescriptorUpdateTemplateKHR</type> <name>descriptorUpdateTemplate</name></param>
+            <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
+        </command>
+        <command>
+            <proto><type>void</type> <name>vkUpdateDescriptorSetWithTemplateKHR</name></proto>
+            <param><type>VkDevice</type> <name>device</name></param>
+            <param externsync="true"><type>VkDescriptorSet</type> <name>descriptorSet</name></param>
+            <param><type>VkDescriptorUpdateTemplateKHR</type> <name>descriptorUpdateTemplate</name></param>
+            <param>const <type>void</type>* <name>pData</name></param>
+        </command>
+        <command queues="graphics,compute" renderpass="both" cmdbufferlevel="primary,secondary">
+            <proto><type>void</type> <name>vkCmdPushDescriptorSetWithTemplateKHR</name></proto>
+            <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
+            <param><type>VkDescriptorUpdateTemplateKHR</type> <name>descriptorUpdateTemplate</name></param>
+            <param><type>VkPipelineLayout</type> <name>layout</name></param>
+            <param><type>uint32_t</type> <name>set</name></param>
+            <param>const <type>void</type>* <name>pData</name></param>
+        </command>
         <command>
             <proto><type>void</type> <name>vkSetSMPTE2086MetadataEXT</name></proto>
             <param><type>VkDevice</type> <name>device</name></param>
@@ -4112,6 +4745,34 @@ maintained in the master branch of the Khronos Vulkan GitHub project.
             <param len="swapchainCount">const <type>VkSwapchainKHR</type>* <name>pSwapchains</name></param>    <!-- Swapchains to present an image from -->
             <param len="swapchainCount">const <type>VkSMPTE2086MetadataEXT</type>* <name>pMetadata</name></param>
         </command>
+        <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_NATIVE_WINDOW_IN_USE_KHR">
+            <proto><type>VkResult</type> <name>vkCreateIOSSurfaceMVK</name></proto>
+            <param><type>VkInstance</type> <name>instance</name></param>
+            <param>const <type>VkIOSSurfaceCreateInfoMVK</type>* <name>pCreateInfo</name></param>
+            <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
+            <param><type>VkSurfaceKHR</type>* <name>pSurface</name></param>
+        </command>
+        <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_NATIVE_WINDOW_IN_USE_KHR">
+            <proto><type>VkResult</type> <name>vkCreateMacOSSurfaceMVK</name></proto>
+            <param><type>VkInstance</type> <name>instance</name></param>
+            <param>const <type>VkMacOSSurfaceCreateInfoMVK</type>* <name>pCreateInfo</name></param>
+            <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
+            <param><type>VkSurfaceKHR</type>* <name>pSurface</name></param>
+        </command>
+        <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
+          <proto><type>void</type> <name>vkCmdSetViewportWScalingNV</name></proto>
+          <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
+          <param><type>uint32_t</type> <name>firstViewport</name></param>
+          <param><type>uint32_t</type> <name>viewportCount</name></param>
+          <param len="viewportCount" noautovalidity="true">const <type>VkViewportWScalingNV</type>* <name>pViewportWScalings</name></param>
+        </command>
+        <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
+            <proto><type>void</type> <name>vkCmdSetDiscardRectangleEXT</name></proto>
+            <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
+            <param><type>uint32_t</type> <name>firstDiscardRectangle</name></param>
+            <param><type>uint32_t</type> <name>discardRectangleCount</name></param>
+            <param len="discardRectangleCount">const <type>VkRect2D</type>* <name>pDiscardRectangles</name></param>
+        </command>
     </commands>
 
     <!-- SECTION: Vulkan API interface definitions -->
@@ -4770,10 +5431,17 @@ maintained in the master branch of the Khronos Vulkan GitHub project.
                 <enum value="&quot;VK_NV_extension_53&quot;"            name="VK_NV_EXTENSION_53_EXTENSION_NAME"/>
             </require>
         </extension>
-        <extension name="VK_NV_extension_54" number="54" author="NVIDIA" contact="Jeff Bolz @jbolz" supported="disabled">
+        <extension name="VK_KHX_multiview" number="54" type="device" author="NVIDIA" requires="VK_KHR_get_physical_device_properties2" contact="Jeff Bolz @jbolz" supported="vulkan">
             <require>
-                <enum value="0"                                         name="VK_NV_EXTENSION_54_SPEC_VERSION"/>
-                <enum value="&quot;VK_NV_extension_54&quot;"            name="VK_NV_EXTENSION_54_EXTENSION_NAME"/>
+                <enum value="1"                                         name="VK_KHX_MULTIVIEW_SPEC_VERSION"/>
+                <enum value="&quot;VK_KHX_multiview&quot;"              name="VK_KHX_MULTIVIEW_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHX"/>
+                <enum offset="1" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHX"/>
+                <enum offset="2" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHX"/>
+                <enum bitpos="1" extends="VkDependencyFlagBits"         name="VK_DEPENDENCY_VIEW_LOCAL_BIT_KHX"/>
+                <type name="VkRenderPassMultiviewCreateInfoKHX"/>
+                <type name="VkPhysicalDeviceMultiviewFeaturesKHX"/>
+                <type name="VkPhysicalDeviceMultiviewPropertiesKHX"/>
             </require>
         </extension>
         <extension name="VK_IMG_format_pvrtc" number="55" type="device" author="IMG" contact="Tobias Hector @tobias" supported="vulkan">
@@ -4862,10 +5530,56 @@ maintained in the master branch of the Khronos Vulkan GitHub project.
                 <command name="vkGetPhysicalDeviceSparseImageFormatProperties2KHR"/>
             </require>
         </extension>
-        <extension name="VK_KHR_extension_61" number="61" author="KHR" contact="Jeff Bolz @jbolz" supported="disabled">
+        <extension name="VK_KHX_device_group" number="61" type="device" author="KHX" requires="VK_KHR_swapchain" contact="Jeff Bolz @jbolz" supported="vulkan">
             <require>
-                <enum value="0"                                         name="VK_KHR_EXTENSION_61_SPEC_VERSION"/>
-                <enum value="&quot;VK_KHR_extension_61&quot;"           name="VK_KHR_EXTENSION_61_EXTENSION_NAME"/>
+                <enum value="1"                                         name="VK_KHX_DEVICE_GROUP_SPEC_VERSION"/>
+                <enum value="&quot;VK_KHX_device_group&quot;"           name="VK_KHX_DEVICE_GROUP_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHX"/>
+                <enum offset="1" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHX"/>
+                <enum offset="2" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHX"/>
+                <enum offset="3" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHX"/>
+                <enum offset="4" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHX"/>
+                <enum offset="5" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHX"/>
+                <enum offset="6" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHX"/>
+                <enum offset="7" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHX"/>
+                <enum offset="8" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHX"/>
+                <enum offset="9" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHX"/>
+                <enum offset="10" extends="VkStructureType"             name="VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHX"/>
+                <enum offset="11" extends="VkStructureType"             name="VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHX"/>
+                <enum offset="12" extends="VkStructureType"             name="VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHX"/>
+                <type name="VkPeerMemoryFeatureFlagsKHX"/>
+                <type name="VkPeerMemoryFeatureFlagBitsKHX"/>
+                <type name="VkMemoryAllocateFlagsKHX"/>
+                <type name="VkMemoryAllocateFlagBitsKHX"/>
+                <type name="VkDeviceGroupPresentModeFlagBitsKHX"/>
+                <type name="VkDeviceGroupPresentModeFlagsKHX"/>
+                <type name="VkMemoryAllocateFlagsInfoKHX"/>
+                <type name="VkBindBufferMemoryInfoKHX"/>
+                <type name="VkBindImageMemoryInfoKHX"/>
+                <type name="VkDeviceGroupRenderPassBeginInfoKHX"/>
+                <type name="VkDeviceGroupCommandBufferBeginInfoKHX"/>
+                <type name="VkDeviceGroupSubmitInfoKHX"/>
+                <type name="VkDeviceGroupBindSparseInfoKHX"/>
+                <type name="VkDeviceGroupPresentCapabilitiesKHX"/>
+                <type name="VkImageSwapchainCreateInfoKHX"/>
+                <type name="VkBindImageMemorySwapchainInfoKHX"/>
+                <type name="VkAcquireNextImageInfoKHX"/>
+                <type name="VkDeviceGroupPresentInfoKHX"/>
+                <type name="VkDeviceGroupSwapchainCreateInfoKHX"/>
+                <command name="vkGetDeviceGroupPeerMemoryFeaturesKHX"/>
+                <command name="vkBindBufferMemory2KHX"/>
+                <command name="vkBindImageMemory2KHX"/>
+                <command name="vkCmdSetDeviceMaskKHX"/>
+                <command name="vkGetDeviceGroupPresentCapabilitiesKHX"/>
+                <command name="vkGetDeviceGroupSurfacePresentModesKHX"/>
+                <command name="vkAcquireNextImage2KHX"/>
+                <command name="vkCmdDispatchBaseKHX"/>
+                <command name="vkGetPhysicalDevicePresentRectanglesKHX"/>
+                <enum bitpos="6" extends="VkImageCreateFlagBits"  name="VK_IMAGE_CREATE_BIND_SFR_BIT_KHX"    comment="Allows using VkBindImageMemoryInfoKHX::pSFRRects when binding memory to the image"/>
+                <enum bitpos="3" extends="VkPipelineCreateFlagBits"  name="VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHX"/>
+                <enum bitpos="4" extends="VkPipelineCreateFlagBits"  name="VK_PIPELINE_CREATE_DISPATCH_BASE_KHX"/>
+                <enum bitpos="2" extends="VkDependencyFlagBits"   name="VK_DEPENDENCY_DEVICE_GROUP_BIT_KHX"      comment="Dependency is across devices"/>
+                <enum bitpos="0" extends="VkSwapchainCreateFlagBitsKHR" name="VK_SWAPCHAIN_CREATE_BIND_SFR_BIT_KHX" comment="Allow images with VK_IMAGE_CREATE_BIND_SFR_BIT_KHX"/>
             </require>
         </extension>
         <extension name="VK_EXT_validation_flags" number="62" type="instance" author="Google, Inc." contact="Tobin Ehlis @tobine" supported="vulkan">
@@ -4933,70 +5647,157 @@ maintained in the master branch of the Khronos Vulkan GitHub project.
                 <command name="vkTrimCommandPoolKHR"/>
             </require>
         </extension>
-        <extension name="VK_KHR_extension_71" number="71" author="KHR" contact="Jeff Bolz @jbolz" supported="disabled">
+        <extension name="VK_KHX_device_group_creation" number="71" type="instance" author="KHX" contact="Jeff Bolz @jbolz" supported="vulkan">
             <require>
-                <enum value="0"                                         name="VK_KHR_EXTENSION_71_SPEC_VERSION"/>
-                <enum value="&quot;VK_KHR_extension_71&quot;"           name="VK_KHR_EXTENSION_71_EXTENSION_NAME"/>
+                <enum value="1"                                         name="VK_KHX_DEVICE_GROUP_CREATION_SPEC_VERSION"/>
+                <enum value="&quot;VK_KHX_device_group_creation&quot;"  name="VK_KHX_DEVICE_GROUP_CREATION_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHX"/>
+                <enum offset="1" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHX"/>
+                <enum name="VK_MAX_DEVICE_GROUP_SIZE_KHX"/>
+                <type name="VkPhysicalDeviceGroupPropertiesKHX"/>
+                <type name="VkDeviceGroupDeviceCreateInfoKHX"/>
+                <command name="vkEnumeratePhysicalDeviceGroupsKHX"/>
+                <enum bitpos="1" extends="VkMemoryHeapFlagBits"   name="VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHX"    comment="If set, heap allocations allocate multiple instances by default"/>
             </require>
         </extension>
-        <extension name="VK_KHR_extension_72" number="72" author="KHR" contact="James Jones @cubanismo" supported="disable">
+        <extension name="VK_KHX_external_memory_capabilities" number="72" type="instance" author="KHX" requires="VK_KHR_get_physical_device_properties2" contact="James Jones @cubanismo" supported="vulkan">
             <require>
-                <enum value="0"                                         name="VK_KHR_EXTENSION_72_SPEC_VERSION"/>
-                <enum value="&quot;VK_KHR_extension_72&quot;"           name="VK_KHR_EXTENSION_72_EXTENSION_NAME"/>
+                <enum value="1"                                         name="VK_KHX_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION"/>
+                <enum value="&quot;VK_KHX_external_memory_capabilities&quot;" name="VK_KHX_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHX"/>
+                <enum offset="1" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHX"/>
+                <enum offset="2" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHX"/>
+                <enum offset="3" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHX"/>
+                <enum offset="4" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHX"/>
+                <enum offset="5" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHX"/> <!-- KHX-only.  Remove for KHR -->
+                <enum offset="6" extends="VkStructureType"                name="VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHX"/> <!-- KHX-only.  Remove for KHR -->
+                <enum offset="7" extends="VkStructureType"                name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHX"/> <!-- KHX-only.  Remove for KHR -->
+                <enum name="VK_LUID_SIZE_KHX"/>
+                <type name="VkExternalMemoryHandleTypeFlagsKHX"/>
+                <type name="VkExternalMemoryHandleTypeFlagBitsKHX"/>
+                <type name="VkExternalMemoryFeatureFlagsKHX"/>
+                <type name="VkExternalMemoryFeatureFlagBitsKHX"/>
+                <type name="VkExternalMemoryPropertiesKHX"/>
+                <type name="VkPhysicalDeviceExternalImageFormatInfoKHX"/>
+                <type name="VkExternalImageFormatPropertiesKHX"/>
+                <type name="VkPhysicalDeviceExternalBufferInfoKHX"/>
+                <type name="VkExternalBufferPropertiesKHX"/>
+                <type name="VkPhysicalDeviceIDPropertiesKHX"/>
+                <type name="VkPhysicalDeviceProperties2KHX"/> <!-- KHX-only.  Remove for KHR -->
+                <type name="VkImageFormatProperties2KHX"/> <!-- KHX-only.  Remove for KHR -->
+                <type name="VkPhysicalDeviceImageFormatInfo2KHX"/> <!-- KHX-only.  Remove for KHR -->
+                <command name="vkGetPhysicalDeviceExternalBufferPropertiesKHX"/>
+                <command name="vkGetPhysicalDeviceProperties2KHX"/> <!-- KHX-only.  Remove for KHR -->
+                <command name="vkGetPhysicalDeviceImageFormatProperties2KHX"/> <!-- KHX-only.  Remove for KHR -->
             </require>
         </extension>
-        <extension name="VK_KHR_extension_73" number="73" author="KHR" contact="James Jones @cubanismo" supported="disable">
+        <extension name="VK_KHX_external_memory" number="73" type="device" requires="VK_KHX_external_memory_capabilities" author="KHX" contact="James Jones @cubanismo" supported="vulkan">
             <require>
-                <enum value="0"                                         name="VK_KHR_EXTENSION_73_SPEC_VERSION"/>
-                <enum value="&quot;VK_KHR_extension_73&quot;"           name="VK_KHR_EXTENSION_73_EXTENSION_NAME"/>
+                <enum value="1"                                         name="VK_KHX_EXTERNAL_MEMORY_SPEC_VERSION"/>
+                <enum value="&quot;VK_KHX_external_memory&quot;"        name="VK_KHX_EXTERNAL_MEMORY_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHX"/>
+                <enum offset="1" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHX"/>
+                <enum offset="2" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHX"/>
+                <enum offset="3" dir="-" extends="VkResult"             name="VK_ERROR_INVALID_EXTERNAL_HANDLE_KHX"/>
+                <enum name="VK_QUEUE_FAMILY_EXTERNAL_KHX"/>
+                <type name="VkExternalMemoryImageCreateInfoKHX"/>
+                <type name="VkExternalMemoryBufferCreateInfoKHX"/>
+                <type name="VkExportMemoryAllocateInfoKHX"/>
             </require>
         </extension>
-        <extension name="VK_KHR_extension_74" number="74" author="KHR" contact="James Jones @cubanismo" supported="disable">
+        <extension name="VK_KHX_external_memory_win32" number="74" type="device" requires="VK_KHX_external_memory_capabilities,VK_KHX_external_memory" author="KHX" contact="James Jones @cubanismo" protect="VK_USE_PLATFORM_WIN32_KHR" supported="vulkan">
             <require>
-                <enum value="0"                                         name="VK_KHR_EXTENSION_74_SPEC_VERSION"/>
-                <enum value="&quot;VK_KHR_extension_74&quot;"           name="VK_KHR_EXTENSION_74_EXTENSION_NAME"/>
+                <enum value="1"                                         name="VK_KHX_EXTERNAL_MEMORY_WIN32_SPEC_VERSION"/>
+                <enum value="&quot;VK_KHX_external_memory_win32&quot;"  name="VK_KHX_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHX"/>
+                <enum offset="1" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHX"/>
+                <enum offset="2" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHX"/>
+                <type name="VkImportMemoryWin32HandleInfoKHX"/>
+                <type name="VkExportMemoryWin32HandleInfoKHX"/>
+                <type name="VkMemoryWin32HandlePropertiesKHX"/>
+                <command name="vkGetMemoryWin32HandleKHX"/>
+                <command name="vkGetMemoryWin32HandlePropertiesKHX"/>
             </require>
         </extension>
-        <extension name="VK_KHR_extension_75" number="75" author="KHR" contact="James Jones @cubanismo" supported="disable">
+        <extension name="VK_KHX_external_memory_fd" number="75" type="device" requires="VK_KHX_external_memory_capabilities,VK_KHX_external_memory" author="KHX" contact="James Jones @cubanismo" supported="vulkan">
             <require>
-                <enum value="0"                                         name="VK_KHR_EXTENSION_75_SPEC_VERSION"/>
-                <enum value="&quot;VK_KHR_extension_75&quot;"           name="VK_KHR_EXTENSION_75_EXTENSION_NAME"/>
+                <enum value="1"                                         name="VK_KHX_EXTERNAL_MEMORY_FD_SPEC_VERSION"/>
+                <enum value="&quot;VK_KHX_external_memory_fd&quot;"     name="VK_KHX_EXTERNAL_MEMORY_FD_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHX"/>
+                <enum offset="1" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHX"/>
+                <type name="VkImportMemoryFdInfoKHX"/>
+                <type name="VkMemoryFdPropertiesKHX"/>
+                <command name="vkGetMemoryFdKHX"/>
+                <command name="vkGetMemoryFdPropertiesKHX"/>
             </require>
         </extension>
-        <extension name="VK_KHR_extension_76" number="76" author="KHR" contact="James Jones @cubanismo" supported="disable">
+        <extension name="VK_KHX_win32_keyed_mutex" number="76" type="device" requires="VK_KHX_external_memory_capabilities,VK_KHX_external_memory,VK_KHX_external_memory_win32" author="KHX" contact="Carsten Rohde" protect="VK_USE_PLATFORM_WIN32_KHR" supported="vulkan">
             <require>
-                <enum value="0"                                         name="VK_KHR_EXTENSION_76_SPEC_VERSION"/>
-                <enum value="&quot;VK_KHR_extension_76&quot;"           name="VK_KHR_EXTENSION_76_EXTENSION_NAME"/>
+                <enum value="1"                                         name="VK_KHX_WIN32_KEYED_MUTEX_SPEC_VERSION"/>
+                <enum value="&quot;VK_KHX_win32_keyed_mutex&quot;"      name="VK_KHX_WIN32_KEYED_MUTEX_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHX"/>
+                <type name="VkWin32KeyedMutexAcquireReleaseInfoKHX"/>
             </require>
         </extension>
-        <extension name="VK_KHR_extension_77" number="77" author="KHR" contact="James Jones @cubanismo" supported="disable">
+        <extension name="VK_KHX_external_semaphore_capabilities" number="77" type="instance" author="KHX" requires="VK_KHR_get_physical_device_properties2" contact="James Jones @cubanismo" supported="vulkan">
             <require>
-                <enum value="0"                                         name="VK_KHR_EXTENSION_77_SPEC_VERSION"/>
-                <enum value="&quot;VK_KHR_extension_77&quot;"           name="VK_KHR_EXTENSION_77_EXTENSION_NAME"/>
+                <enum value="1"                                         name="VK_KHX_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION"/>
+                <enum value="&quot;VK_KHX_external_semaphore_capabilities&quot;" name="VK_KHX_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHX"/>
+                <enum offset="1" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHX"/>
+                <enum name="VK_LUID_SIZE_KHX"/>
+                <type name="VkExternalSemaphoreHandleTypeFlagsKHX"/>
+                <type name="VkExternalSemaphoreHandleTypeFlagBitsKHX"/>
+                <type name="VkExternalSemaphoreFeatureFlagsKHX"/>
+                <type name="VkExternalSemaphoreFeatureFlagBitsKHX"/>
+                <type name="VkPhysicalDeviceExternalSemaphoreInfoKHX"/>
+                <type name="VkExternalSemaphorePropertiesKHX"/>
+                <type name="VkPhysicalDeviceIDPropertiesKHX"/>
+                <type name="VkPhysicalDeviceProperties2KHX"/> <!-- KHX-only.  Remove for KHR -->
+                <command name="vkGetPhysicalDeviceExternalSemaphorePropertiesKHX"/>
+                <command name="vkGetPhysicalDeviceProperties2KHX"/> <!-- KHX-only.  Remove for KHR -->
             </require>
         </extension>
-        <extension name="VK_KHR_extension_78" number="78" author="KHR" contact="James Jones @cubanismo" supported="disable">
+        <extension name="VK_KHX_external_semaphore" number="78" type="device" requires="VK_KHX_external_semaphore_capabilities" author="KHX" contact="James Jones @cubanismo" supported="vulkan">
             <require>
-                <enum value="0"                                         name="VK_KHR_EXTENSION_78_SPEC_VERSION"/>
-                <enum value="&quot;VK_KHR_extension_78&quot;"           name="VK_KHR_EXTENSION_78_EXTENSION_NAME"/>
+                <enum value="1"                                         name="VK_KHX_EXTERNAL_SEMAPHORE_SPEC_VERSION"/>
+                <enum value="&quot;VK_KHX_external_semaphore&quot;"     name="VK_KHX_EXTERNAL_SEMAPHORE_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHX"/>
+                <type name="VkExportSemaphoreCreateInfoKHX"/>
             </require>
         </extension>
-        <extension name="VK_KHR_extension_79" number="79" author="KHR" contact="James Jones @cubanismo" supported="disable">
+        <extension name="VK_KHX_external_semaphore_win32" number="79" type="device" requires="VK_KHX_external_semaphore_capabilities,VK_KHX_external_semaphore" author="KHX" contact="James Jones @cubanismo" protect="VK_USE_PLATFORM_WIN32_KHX" supported="vulkan">
             <require>
-                <enum value="0"                                         name="VK_KHR_EXTENSION_79_SPEC_VERSION"/>
-                <enum value="&quot;VK_KHR_extension_79&quot;"           name="VK_KHR_EXTENSION_79_EXTENSION_NAME"/>
+                <enum value="1"                                         name="VK_KHX_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION"/>
+                <enum value="&quot;VK_KHX_external_semaphore_win32&quot;" name="VK_KHX_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX"/>
+                <enum offset="1" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX"/>
+                <enum offset="2" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHX"/>
+                <type name="VkImportSemaphoreWin32HandleInfoKHX"/>
+                <type name="VkExportSemaphoreWin32HandleInfoKHX"/>
+                <type name="VkD3D12FenceSubmitInfoKHX"/>
+                <command name="vkImportSemaphoreWin32HandleKHX"/>
+                <command name="vkGetSemaphoreWin32HandleKHX"/>
             </require>
         </extension>
-        <extension name="VK_KHR_extension_80" number="80" author="KHR" contact="James Jones @cubanismo" supported="disable">
+        <extension name="VK_KHX_external_semaphore_fd" number="80" type="device" requires="VK_KHX_external_semaphore_capabilities,VK_KHX_external_semaphore" author="KHX" contact="James Jones @cubanismo" supported="vulkan">
             <require>
-                <enum value="0"                                         name="VK_KHR_EXTENSION_80_SPEC_VERSION"/>
-                <enum value="&quot;VK_KHR_extension_80&quot;"           name="VK_KHR_EXTENSION_80_EXTENSION_NAME"/>
+                <enum value="1"                                         name="VK_KHX_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION"/>
+                <enum value="&quot;VK_KHX_external_semaphore_fd&quot;"  name="VK_KHX_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHX"/>
+                <type name="VkImportSemaphoreFdInfoKHX"/>
+                <command name="vkImportSemaphoreFdKHX"/>
+                <command name="vkGetSemaphoreFdKHX"/>
             </require>
         </extension>
-        <extension name="VK_KHR_extension_81" number="81" author="KHR" contact="Jeff Bolz @jbolz" supported="disabled">
+        <extension name="VK_KHR_push_descriptor" number="81" type="device" author="KHR" requires="VK_KHR_get_physical_device_properties2" contact="Jeff Bolz @jbolz" supported="vulkan">
             <require>
-                <enum value="0"                                         name="VK_KHR_EXTENSION_81_SPEC_VERSION"/>
-                <enum value="&quot;VK_KHR_extension_81&quot;"           name="VK_KHR_EXTENSION_81_EXTENSION_NAME"/>
+                <enum value="1"                                         name="VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION"/>
+                <enum value="&quot;VK_KHR_push_descriptor&quot;"        name="VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR"/>
+                <enum bitpos="0" extends="VkDescriptorSetLayoutCreateFlagBits"   name="VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR"  comment="Descriptors are pushed via flink:vkCmdPushDescriptorSetKHR"/>
+                <command name="vkCmdPushDescriptorSetKHR"/>
+                <type name="VkPhysicalDevicePushDescriptorPropertiesKHR"/>
             </require>
         </extension>
         <extension name="VK_KHR_extension_82" number="82" author="KHR" contact="Jeff Bolz @jbolz" supported="disabled">
@@ -5023,10 +5824,19 @@ maintained in the master branch of the Khronos Vulkan GitHub project.
                  <enum value="&quot;VK_KHR_extension_85&quot;"           name="VK_KHR_EXTENSION_85_EXTENSION_NAME"/>
              </require>
          </extension>
-         <extension name="VK_KHR_extension_86" number="86" author="KHR" contact="Markus Tavenrath @mtavenrath" supported="disabled">
-             <require>
-                 <enum value="0"                                         name="VK_KHR_EXTENSION_86_SPEC_VERSION"/>
-                 <enum value="&quot;VK_KHR_extension_86&quot;"           name="VK_KHR_EXTENSION_86_EXTENSION_NAME"/>
+         <extension name="VK_KHR_descriptor_update_template" number="86" type="device" author="KHR" contact="Markus Tavenrath @mtavenrath" supported="vulkan">
+              <require>
+                 <enum value="1"                                             name="VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION"/>
+                 <enum value="&quot;VK_KHR_descriptor_update_template&quot;" name="VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME"/>
+                 <enum offset="0" extends="VkStructureType"                  name="VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR"/>
+                 <command name="vkCreateDescriptorUpdateTemplateKHR"/>
+                 <command name="vkDestroyDescriptorUpdateTemplateKHR"/>
+                 <command name="vkUpdateDescriptorSetWithTemplateKHR"/>
+                 <command name="vkCmdPushDescriptorSetWithTemplateKHR"/>
+                 <type name="VkDescriptorUpdateTemplateCreateFlagsKHR"/>
+                 <type name="VkDescriptorUpdateTemplateTypeKHR"/>
+                 <type name="VkDescriptorUpdateTemplateEntryKHR"/>
+                 <type name="VkDescriptorUpdateTemplateCreateInfoKHR"/>
               </require>
          </extension>
         <extension name="VK_NVX_device_generated_commands" number="87" type="device" author="NVIDIA" contact="Christoph Kubisch @pixeljetstream" supported="vulkan">
@@ -5075,12 +5885,17 @@ maintained in the master branch of the Khronos Vulkan GitHub project.
               <command name="vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX"/>
           </require>
         </extension>
-         <extension name="VK_KHR_extension_88" number="88" author="NV" contact="Eric Werness @ewerness" supported="disabled">
-             <require>
-                 <enum value="0"                                         name="VK_KHR_EXTENSION_88_SPEC_VERSION"/>
-                 <enum value="&quot;VK_KHR_extension_88&quot;"           name="VK_KHR_EXTENSION_88_EXTENSION_NAME"/>
-              </require>
-         </extension>
+        <extension name="VK_NV_clip_space_w_scaling" number="88" type="device" author="NV" contact="Eric Werness @ewerness" supported="vulkan">
+            <require>
+                <enum value="1"                                         name="VK_NV_CLIP_SPACE_W_SCALING_SPEC_VERSION"/>
+                <enum value="&quot;VK_NV_clip_space_w_scaling&quot;"    name="VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV"/>
+                <enum offset="0" extends="VkDynamicState"               name="VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV"/>
+                <type name="VkViewportWScalingNV"/>
+                <type name="VkPipelineViewportWScalingStateCreateInfoNV"/>
+                <command name="vkCmdSetViewportWScalingNV"/>
+            </require>
+        </extension>
          <extension name="VK_EXT_direct_mode_display" number="89" type="instance" requires="VK_KHR_display" author="NVIDIA" contact="James Jones @cubanismo" supported="vulkan">
              <require>
                  <enum value="1"                                         name="VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION"/>
@@ -5140,40 +5955,57 @@ maintained in the master branch of the Khronos Vulkan GitHub project.
                  <enum value="&quot;VK_KHR_extension_94&quot;"           name="VK_KHR_EXTENSION_94_EXTENSION_NAME"/>
              </require>
          </extension>
-         <extension name="VK_NV_extension_95" number="95" author="NVIDIA" contact="Daniel Koch @dgkoch" supported="disabled">
+         <extension name="VK_NV_sample_mask_override_coverage" number="95" type="device" author="NVIDIA" contact="Piers Daniell @pdaniell" supported="vulkan">
              <require>
-                 <enum value="0"                                         name="VK_NV_EXTENSION_95_SPEC_VERSION"/>
-                 <enum value="&quot;VK_NV_extension_95&quot;"            name="VK_NV_EXTENSION_95_EXTENSION_NAME"/>
+                 <enum value="1"                                               name="VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION"/>
+                 <enum value="&quot;VK_NV_sample_mask_override_coverage&quot;" name="VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME"/>
              </require>
          </extension>
-         <extension name="VK_NV_extension_96" number="96" author="NVIDIA" contact="Daniel Koch @dgkoch" supported="disabled">
+         <extension name="VK_NV_geometry_shader_passthrough" number="96" type="device" author="NVIDIA" contact="Daniel Koch @dgkoch" supported="vulkan">
              <require>
-                 <enum value="0"                                         name="VK_NV_EXTENSION_96_SPEC_VERSION"/>
-                 <enum value="&quot;VK_NV_extension_96&quot;"            name="VK_NV_EXTENSION_96_EXTENSION_NAME"/>
+                 <enum value="1"                                             name="VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION"/>
+                 <enum value="&quot;VK_NV_geometry_shader_passthrough&quot;" name="VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME"/>
              </require>
          </extension>
-         <extension name="VK_NV_extension_97" number="97" author="NVIDIA" contact="Daniel Koch @dgkoch" supported="disabled">
+         <extension name="VK_NV_viewport_array2" number="97" type="device" author="NVIDIA" contact="Daniel Koch @dgkoch" supported="vulkan">
              <require>
-                 <enum value="0"                                         name="VK_NV_EXTENSION_97_SPEC_VERSION"/>
-                 <enum value="&quot;VK_NV_extension_97&quot;"            name="VK_NV_EXTENSION_97_EXTENSION_NAME"/>
+                 <enum value="1"                                         name="VK_NV_VIEWPORT_ARRAY2_SPEC_VERSION"/>
+                 <enum value="&quot;VK_NV_viewport_array2&quot;"         name="VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME"/>
              </require>
          </extension>
-         <extension name="VK_NV_extension_98" number="98" author="NVIDIA" contact="Daniel Koch @dgkoch" supported="disabled">
+         <extension name="VK_NVX_multiview_per_view_attributes" number="98" type="device" author="NVIDIA" contact="Jeff Bolz @jbolz" supported="vulkan">
              <require>
-                 <enum value="0"                                         name="VK_NV_EXTENSION_98_SPEC_VERSION"/>
-                 <enum value="&quot;VK_NV_extension_98&quot;"            name="VK_NV_EXTENSION_98_EXTENSION_NAME"/>
+                 <enum value="1"                                         name="VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION"/>
+                 <enum value="&quot;VK_NVX_multiview_per_view_attributes&quot;"  name="VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME"/>
+                 <enum offset="0" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX"/>
+                 <enum bitpos="0" extends="VkSubpassDescriptionFlagBits" name="VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX"/>
+                 <enum bitpos="1" extends="VkSubpassDescriptionFlagBits" name="VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX"/>
+                 <type name="VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX"/>
              </require>
          </extension>
-         <extension name="VK_NV_extension_99" number="99" author="NVIDIA" contact="Daniel Koch @dgkoch" supported="disabled">
+         <extension name="VK_NV_viewport_swizzle" number="99" type="device" author="NVIDIA" contact="Piers Daniell @pdaniell" supported="vulkan">
              <require>
-                 <enum value="0"                                         name="VK_NV_EXTENSION_99_SPEC_VERSION"/>
-                 <enum value="&quot;VK_NV_extension_99&quot;"            name="VK_NV_EXTENSION_99_EXTENSION_NAME"/>
+                 <enum value="1"                                         name="VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION"/>
+                 <enum value="&quot;VK_NV_viewport_swizzle&quot;"        name="VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME"/>
+                 <enum offset="0" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV"/>
+                 <type name="VkViewportSwizzleNV"/>
+                 <type name="VkViewportCoordinateSwizzleNV"/>
+                 <type name="VkPipelineViewportSwizzleStateCreateInfoNV"/>
+                 <type name="VkPipelineViewportSwizzleStateCreateFlagsNV"/>
              </require>
          </extension>
-         <extension name="VK_NV_extension_100" number="100" author="NVIDIA" contact="Daniel Koch @dgkoch" supported="disabled">
+         <extension name="VK_EXT_discard_rectangles" number="100" type="device" requires="VK_KHR_get_physical_device_properties2" author="NVIDIA" contact="Piers Daniell @pdaniell" supported="vulkan">
              <require>
-                 <enum value="0"                                         name="VK_NV_EXTENSION_100_SPEC_VERSION"/>
-                 <enum value="&quot;VK_NV_extension_100&quot;"           name="VK_NV_EXTENSION_100_EXTENSION_NAME"/>
+                 <enum value="1"                                         name="VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION"/>
+                 <enum value="&quot;VK_EXT_discard_rectangles&quot;"     name="VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME"/>
+                 <enum offset="0" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT"/>
+                 <enum offset="1" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT"/>
+                 <enum offset="0" extends="VkDynamicState"               name="VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT"/>
+                 <type name="VkPhysicalDeviceDiscardRectanglePropertiesEXT"/>
+                 <type name="VkPipelineDiscardRectangleStateCreateInfoEXT"/>
+                 <type name="VkPipelineDiscardRectangleStateCreateFlagsEXT"/>
+                 <type name="VkDiscardRectangleModeEXT"/>
+                 <command name="vkCmdSetDiscardRectangleEXT"/>
              </require>
          </extension>
          <extension name="VK_NV_extension_101" number="101" author="NVIDIA" contact="Daniel Koch @dgkoch" supported="disabled">
@@ -5323,7 +6155,32 @@ maintained in the master branch of the Khronos Vulkan GitHub project.
                  <enum value="&quot;VK_KHR_extension_122&quot;"          name="VK_KHR_EXTENSION_122_EXTENSION_NAME"/>
              </require>
          </extension>
-         <!-- padding 123-125, for unpublished extensions under review -->
+         <extension name="VK_MVK_ios_surface" number="123" type="instance" requires="VK_KHR_surface" protect="VK_USE_PLATFORM_IOS_MVK" supported="vulkan" author="MVK" contact="Bill Hollings @billhollings">
+             <require>
+                 <enum value="1"                                         name="VK_MVK_IOS_SURFACE_SPEC_VERSION"/>
+                 <enum value="&quot;VK_MVK_ios_surface&quot;"            name="VK_MVK_IOS_SURFACE_EXTENSION_NAME"/>
+                 <enum offset="0" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK"/>
+                 <type name="VkIOSSurfaceCreateFlagsMVK"/>
+                 <type name="VkIOSSurfaceCreateInfoMVK"/>
+                 <command name="vkCreateIOSSurfaceMVK"/>
+             </require>
+         </extension>
+         <extension name="VK_MVK_macos_surface" number="124" type="instance" requires="VK_KHR_surface" protect="VK_USE_PLATFORM_MACOS_MVK" supported="vulkan" author="MVK" contact="Bill Hollings @billhollings">
+             <require>
+                 <enum value="1"                                         name="VK_MVK_MACOS_SURFACE_SPEC_VERSION"/>
+                 <enum value="&quot;VK_MVK_macos_surface&quot;"          name="VK_MVK_MACOS_SURFACE_EXTENSION_NAME"/>
+                 <enum offset="0" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK"/>
+                 <type name="VkMacOSSurfaceCreateFlagsMVK"/>
+                 <type name="VkMacOSSurfaceCreateInfoMVK"/>
+                 <command name="vkCreateMacOSSurfaceMVK"/>
+             </require>
+         </extension>
+         <extension name="VK_MVK_moltenvk" number="125" type="instance" author="MVK" contact="Bill Hollings @billhollings" supported="disabled">
+             <require>
+                 <enum value="0"                                         name="VK_MVK_MOLTENVK_SPEC_VERSION"/>
+                 <enum value="&quot;VK_MVK_moltenvk&quot;"               name="VK_MVK_MOLTENVK_EXTENSION_NAME"/>
+             </require>
+         </extension>
          <extension name="VK_MESA_extension_126" number="126" author="MESA" contact="Chad Versace @chadversary" supported="disabled">
              <require>
                  <enum value="0"                                         name="VK_MESA_EXTENSION_126_SPEC_VERSION"/>
author	Mark Young <marky@lunarg.com>	2017-02-28 09:58:04 -0700
committer	Mark Young <marky@lunarg.com>	2017-03-01 08:20:22 -0700
commit	e2ebfd58c6cfbafbee172093b22e06867e1c3fe6 (patch)
tree	7617f642ef2cee90b334b8e58455296c0f47df59 /scripts
parent	9172c7bf11a3dbb663e170f57692e68891e891c9 (diff)
download	usermoji-e2ebfd58c6cfbafbee172093b22e06867e1c3fe6.tar.xz