[PATCH 0/6] MR9586: winevulkan: Misc cleanups and simplifications for make_vulkan.

[Rémi Bernon]

-- 
https://gitlab.winehq.org/wine/wine/-/merge_requests/9586

[PATCH 1/6] winevulkan: Move api checks out of the constructors.

[Rémi Bernon]

From: Rémi Bernon <rbernon(a)codeweavers.com>

---
 dlls/winevulkan/make_vulkan | 98 ++++++++-----------------------------
 include/wine/vulkan.h       |  2 -
 2 files changed, 20 insertions(+), 80 deletions(-)

diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan
index ba8e8695fd1..073e040e995 100755
--- a/dlls/winevulkan/make_vulkan
+++ b/dlls/winevulkan/make_vulkan
@@ -345,7 +345,7 @@ class Unwrap(Enum):
     DRIVER = 2
 
 
-def api_is_vulkan(obj):
+def is_api_supported(obj):
     return "vulkan" in obj.get("api", "vulkan").split(",")
 
 
@@ -433,9 +433,6 @@ class VkDefine(object):
 
     @staticmethod
     def from_xml(registry, define):
-        if not api_is_vulkan(define):
-            return None
-
         value = innertext(define)
         value = re.sub(r'\s*//.*$', '', value, flags=re.M)
         value = value.strip()
@@ -469,9 +466,6 @@ class VkEnum(object):
 
     @staticmethod
     def from_xml(registry, enum):
-        if not api_is_vulkan(enum):
-            return None
-
         name = enum.attrib.get("name")
         bitwidth = int(enum.attrib.get("bitwidth", "32"))
         result = VkEnum(name, bitwidth)
@@ -628,18 +622,6 @@ class VkFunction(object):
 
     @staticmethod
     def from_alias(registry, command, alias):
-        """ Create VkFunction from an alias command.
-
-        Args:
-            command: xml data for command
-            alias (VkFunction): function to use as a base for types / parameters.
-
-        Returns:
-            VkFunction
-        """
-        if not api_is_vulkan(command):
-            return None
-
         func_name = command.attrib.get("name")
         func_type = alias.type
         params = alias.params
@@ -648,18 +630,14 @@ class VkFunction(object):
 
     @staticmethod
     def from_xml(registry, command, types):
-        if not api_is_vulkan(command):
-            return None
-
         proto = command.find("proto")
         func_name = proto.find("name").text
         func_type = proto.find("type").text
 
         params = []
-        for param in command.findall("param"):
+        for param in filter(is_api_supported, command.findall("param")):
             vk_param = VkParam.from_xml(registry, param, types, params)
-            if vk_param:
-                params.append(vk_param)
+            params.append(vk_param)
 
         return VkFunction(_type=func_type, name=func_name, params=params)
 
@@ -1004,9 +982,6 @@ class VkFunctionPointer(object):
 
     @staticmethod
     def from_xml(registry, funcpointer):
-        if not api_is_vulkan(funcpointer):
-            return None
-
         value = innertext(funcpointer).replace('\n', '')
         value = re.sub(r'\s*//.*$', '', value, flags=re.M)
         value = re.sub(r'\s+', ' ', value, flags=re.M)
@@ -1037,9 +1012,6 @@ class VkHandle(object):
 
     @staticmethod
     def from_xml(registry, handle):
-        if not api_is_vulkan(handle):
-            return None
-
         name = handle.find("name").text
         _type = handle.find("type").text
         parent = handle.attrib.get("parent") # Most objects have a parent e.g. VkQueue has VkDevice.
@@ -1354,10 +1326,6 @@ class VkMember(VkVariable):
     @staticmethod
     def from_xml(registry, member, returnedonly, parent):
         """ Helper function for parsing a member tag within a struct or union. """
-
-        if not api_is_vulkan(member):
-            return None
-
         name_elem = member.find("name")
         type_elem = member.find("type")
 
@@ -1596,11 +1564,6 @@ class VkParam(VkVariable):
 
     @staticmethod
     def from_xml(registry, param, types, parent):
-        """ Helper function to create VkParam from xml. """
-
-        if not api_is_vulkan(param):
-            return None
-
         # Parameter parsing is slightly tricky. All the data is contained within
         # a param tag, but some data is within subtags while others are text
         # before or after the type tag.
@@ -1921,9 +1884,6 @@ class VkStruct(Sequence):
 
     @staticmethod
     def from_xml(registry, struct):
-        if not api_is_vulkan(struct):
-            return None
-
         # Unions and structs are the same parsing wise, but we need to
         # know which one we are dealing with later on for code generation.
         union = True if struct.attrib["category"] == "union" else False
@@ -1947,10 +1907,9 @@ class VkStruct(Sequence):
         structextends = structextends.split(",") if structextends else []
 
         s = VkStruct(registry, name, [], returnedonly, structextends, union=union)
-        for member in struct.findall("member"):
+        for member in filter(is_api_supported, struct.findall("member")):
             vk_member = VkMember.from_xml(registry, member, returnedonly, s)
-            if vk_member:
-                s.members.append(vk_member)
+            s.members.append(vk_member)
 
         return s
 
@@ -3167,22 +3126,20 @@ class VkRegistry(object):
         # metadata need to be looked up from the Core command.
         # We parse the alias commands in a second pass.
         alias_commands = []
-        for command in commands:
+        for command in filter(is_api_supported, commands):
             alias_name = command.attrib.get("alias")
             if alias_name:
                 alias_commands.append(command)
                 continue
 
             func = VkFunction.from_xml(self, command, self.types)
-            if func:
-                funcs[func.name] = func
+            funcs[func.name] = func
 
         for command in alias_commands:
             alias_name = command.attrib.get("alias")
             alias = funcs[alias_name]
             func = VkFunction.from_alias(self, command, alias)
-            if func:
-                funcs[func.name] = func
+            funcs[func.name] = func
 
         # To make life easy for the code generation, separate all function
         # calls out in the 4 types of Vulkan functions:
@@ -3215,14 +3172,13 @@ class VkRegistry(object):
         """ Parse enums section or better described as constants section. """
         enums = {}
         self.consts = []
-        for enum in root.findall("./enums"):
+        for enum in filter(is_api_supported, root.findall("./enums")):
             name = enum.attrib.get("name")
             _type = enum.attrib.get("type")
 
             if _type in ("enum", "bitmask"):
                 enum_obj = VkEnum.from_xml(self, enum)
-                if enum_obj:
-                    enums[name] = enum_obj
+                enums[name] = enum_obj
             else:
                 # If no type is set, we are dealing with API constants.
                 for value in enum.findall("enum"):
@@ -3445,9 +3401,7 @@ class VkRegistry(object):
     def _parse_features(self, root):
         """ Parse the feature section, which describes Core commands and types needed. """
 
-        for feature in root.findall("./feature"):
-            if not api_is_vulkan(feature):
-                continue
+        for feature in filter(is_api_supported, root.findall("./feature")):
             feature_name = feature.attrib["name"]
             for require in feature.findall("require"):
                 LOGGER.info("Including features for {0}".format(require.attrib.get("comment")))
@@ -3483,7 +3437,7 @@ class VkRegistry(object):
         structs = []
 
         alias_types = []
-        for t in types:
+        for t in filter(is_api_supported, types):
             type_info = {}
             type_info["category"] = t.attrib.get("category", None)
             type_info["requires"] = t.attrib.get("requires", None)
@@ -3530,11 +3484,8 @@ class VkRegistry(object):
 
             elif type_info["category"] == "define":
                 define = VkDefine.from_xml(self, t)
-                if define:
-                    defines.append(define)
-                    type_info["data"] = define
-                else:
-                    continue
+                defines.append(define)
+                type_info["data"] = define
 
             elif type_info["category"] == "enum":
                 name = t.attrib.get("name")
@@ -3550,19 +3501,13 @@ class VkRegistry(object):
 
             elif type_info["category"] == "funcpointer":
                 funcpointer = VkFunctionPointer.from_xml(self, t)
-                if funcpointer:
-                    funcpointers.append(funcpointer)
-                    type_info["data"] = funcpointer
-                else:
-                    continue
+                funcpointers.append(funcpointer)
+                type_info["data"] = funcpointer
 
             elif type_info["category"] == "handle":
                 handle = VkHandle.from_xml(self, t)
-                if handle:
-                    handles.append(handle)
-                    type_info["data"] = handle
-                else:
-                    continue
+                handles.append(handle)
+                type_info["data"] = handle
 
             elif type_info["category"] in ["struct", "union"]:
                 # We store unions among structs as some structs depend
@@ -3570,11 +3515,8 @@ class VkRegistry(object):
                 # generation anyway. The official Vulkan scripts use
                 # a similar kind of hack.
                 struct = VkStruct.from_xml(self, t)
-                if struct:
-                    structs.append(struct)
-                    type_info["data"] = struct
-                else:
-                    continue
+                structs.append(struct)
+                type_info["data"] = struct
 
             # Name is in general within a name tag else it is an optional
             # attribute on the type tag.
diff --git a/include/wine/vulkan.h b/include/wine/vulkan.h
index a6145db94d7..bc1a5c56dc8 100644
--- a/include/wine/vulkan.h
+++ b/include/wine/vulkan.h
@@ -1220,7 +1220,6 @@ typedef VkFlags VkPerformanceCounterDescriptionFlagsKHR;
 typedef VkFlags64 VkPhysicalDeviceSchedulingControlsFlagsARM;
 typedef VkFlags VkPipelineCacheCreateFlags;
 typedef VkFlags VkPipelineColorBlendStateCreateFlags;
-typedef VkFlags VkPipelineColorBlendStateCreateFlags;
 typedef VkFlags VkPipelineCompilerControlFlagsAMD;
 typedef VkFlags VkPipelineCoverageModulationStateCreateFlagsNV;
 typedef VkFlags VkPipelineCoverageReductionStateCreateFlagsNV;
@@ -1231,7 +1230,6 @@ typedef VkPipelineCreateFlags2 VkPipelineCreateFlags2KHR;
 typedef VkFlags VkPipelineCreationFeedbackFlags;
 typedef VkPipelineCreationFeedbackFlags VkPipelineCreationFeedbackFlagsEXT;
 typedef VkFlags VkPipelineDepthStencilStateCreateFlags;
-typedef VkFlags VkPipelineDepthStencilStateCreateFlags;
 typedef VkFlags VkPipelineDiscardRectangleStateCreateFlagsEXT;
 typedef VkFlags VkPipelineDynamicStateCreateFlags;
 typedef VkFlags VkPipelineInputAssemblyStateCreateFlags;
-- 
GitLab


https://gitlab.winehq.org/wine/wine/-/merge_requests/9586

[PATCH 2/6] winevulkan: Simplify enum alias handling.

[Rémi Bernon]

From: Rémi Bernon <rbernon(a)codeweavers.com>

---
 dlls/winevulkan/make_vulkan | 195 +++++++++++++-----------------------
 include/wine/vulkan.h       | 178 ++++++++++++++++----------------
 2 files changed, 157 insertions(+), 216 deletions(-)

diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan
index 073e040e995..20970482063 100755
--- a/dlls/winevulkan/make_vulkan
+++ b/dlls/winevulkan/make_vulkan
@@ -352,6 +352,8 @@ def is_api_supported(obj):
 def innertext(tag):
     return (tag.text or '') + ''.join(innertext(e) for e in tag) + (tag.tail or '')
 
+def snake_case(value):
+    return re.sub(r'([0-9a-z_])([A-Z0-9])',r'\1_\2', value)
 
 def convert_suffix(direction, win_type, unwrap, is_wrapped):
     if direction == Direction.OUTPUT:
@@ -445,158 +447,106 @@ class VkDefine(object):
         return self.value + '\n'
 
 
-class VkEnum(object):
-    def __init__(self, name, bitwidth, alias=None):
-        if not bitwidth in [32, 64]:
-            LOGGER.error("unknown bitwidth {0} for {1}".format(bitwidth, name))
+class Enum(object):
+    def __init__(self, values, name, bitwidth="32", **kwargs):
         self.name = name
-        self.bitwidth = bitwidth
-        self.values = [] if alias == None else alias.values
-        self.required = False
-        self.alias = alias
-        self.aliased_by = []
-
-    @staticmethod
-    def from_alias(registry, enum, alias):
-        name = enum.attrib.get("name")
-        aliasee = VkEnum(name, alias.bitwidth, alias=alias)
+        self.values = values
+        self.bitwidth = int(bitwidth)
+        assert self.bitwidth in (32, 64)
 
-        alias.add_aliased_by(aliasee)
-        return aliasee
+        self.extensions = set()
+        self.typedefs = []
+        self.required = False
 
     @staticmethod
-    def from_xml(registry, enum):
-        name = enum.attrib.get("name")
-        bitwidth = int(enum.attrib.get("bitwidth", "32"))
-        result = VkEnum(name, bitwidth)
-
-        for v in enum.findall("enum"):
-            value_name = v.attrib.get("name")
-            # Value is either a value or a bitpos, only one can exist.
-            value = v.attrib.get("value")
-            alias_name = v.attrib.get("alias")
-            if alias_name:
-                result.create_alias(value_name, alias_name)
-            elif value:
-                result.create_value(value_name, value)
-            else:
-                # bitmask
-                result.create_bitpos(value_name, int(v.attrib.get("bitpos")))
+    def from_xml(node):
+        values = filter(is_api_supported, node.findall("enum"))
+        values = [EnumValue(**node.attrib) for node in values]
 
-        if bitwidth == 32:
+        enum = Enum(values, **node.attrib)
+        if enum.bitwidth == 32 and not any(x.value == 0x7fffffff for x in enum.values):
             # vulkan.h contains a *_MAX_ENUM value set to 32-bit at the time of writing,
             # which is to prepare for extensions as they can add values and hence affect
             # the size definition.
-            max_name = re.sub(r'([0-9a-z_])([A-Z0-9])',r'\1_\2', name).upper() + "_MAX_ENUM"
-            result.create_value(max_name, "0x7fffffff")
+            name = snake_case(enum.name).upper() + "_MAX_ENUM"
+            enum.add(EnumValue(name=name, value="0x7fffffff"))
 
-        return result
-
-    def create_alias(self, name, alias_name):
-        """ Create an aliased value for this enum """
-        self.add(VkEnumValue(name, self.bitwidth, alias=alias_name))
-
-    def create_value(self, name, value):
-        """ Create a new value for this enum """
-        # Some values are in hex form. We want to preserve the hex representation
-        # at least when we convert back to a string. Internally we want to use int.
-        hex = "0x" in value
-        self.add(VkEnumValue(name, self.bitwidth, value=int(value, 0), hex=hex))
-
-    def create_bitpos(self, name, pos):
-        """ Create a new bitmask value for this enum """
-        self.add(VkEnumValue(name, self.bitwidth, value=(1 << pos), hex=True))
+        return enum
 
     def add(self, value):
-        """ Add a value to enum. """
-
         # Extensions can add new enum values. When an extension is promoted to Core
         # the registry defines the value twice once for old extension and once for
         # new Core features. Add the duplicate if it's explicitly marked as an
         # alias, otherwise ignore it.
-        for v in self.values:
-            if not value.is_alias() and v.value == value.value:
-                LOGGER.debug("Adding duplicate enum value {0} to {1}".format(v, self.name))
-                return
+        if any(not value.is_alias() and value.value == prev.value for prev in self.values):
+            return
         # Avoid adding duplicate aliases multiple times
-        if not any(x.name == value.name for x in self.values):
-            self.values.append(value)
+        if any(x.name == value.name for x in self.values):
+            return
+        self.values.append(value)
 
     def fixup_64bit_aliases(self):
-        """ Replace 64bit aliases with literal values """
         # Older GCC versions need a literal to initialize a static const uint64_t
         # which is what we use for 64bit bitmasks.
         if self.bitwidth != 64:
             return
-        for value in self.values:
-            if not value.is_alias():
-                continue
+
+        for value in filter(EnumValue.is_alias, self.values):
             alias = next(x for x in self.values if x.name == value.alias)
             value.hex = alias.hex
             value.value = alias.value
+            value.alias = None
 
     def definition(self):
-        if self.is_alias():
-            return ""
-
-        default_value = 0x7ffffffe if self.bitwidth == 32 else 0xfffffffffffffffe
-
         # Print values sorted, values can have been added in a random order.
-        values = sorted(self.values, key=lambda value: value.value if value.value is not None else default_value)
+        values = sorted(self.values, key=lambda value: value.value)
 
         if self.bitwidth == 32:
-            text = "typedef enum {0}\n{{\n".format(self.name)
+            text  = f"typedef enum {self.name}\n{{\n"
             for value in values:
-                text += "    {0},\n".format(value.definition())
-            text += "}} {0};\n".format(self.name)
+                text += f"    {value.definition()},\n"
+            text += f"}} {self.name};\n"
+
         elif self.bitwidth == 64:
-            text = "typedef VkFlags64 {0};\n\n".format(self.name)
+            text  = f"typedef VkFlags64 {self.name};\n\n"
             for value in values:
-                text += "static const {0} {1};\n".format(self.name, value.definition())
+                text += f"static const {self.name} {value.definition(size=8)};\n"
 
-        for aliasee in self.aliased_by:
-            text += "typedef {0} {1};\n".format(self.name, aliasee.name)
+        for name in self.typedefs:
+            text += f"typedef {self.name} {name};\n"
 
         text += "\n"
         return text
 
-    def is_alias(self):
-        return bool(self.alias)
-
-    def add_aliased_by(self, aliasee):
-        self.aliased_by.append(aliasee)
-
 
-class VkEnumValue(object):
-    def __init__(self, name, bitwidth, value=None, hex=False, alias=None):
+class EnumValue(object):
+    def __init__(self, name, value=None, bitpos=None, alias=None, hex=False, **kwargs):
         self.name = name
-        self.bitwidth = bitwidth
-        self.value = value
-        self.hex = hex
         self.alias = alias
 
-    def __repr__(self):
-        postfix = "ull" if self.bitwidth == 64 else ""
-        if self.is_alias() and self.value == None:
-            return "{0}={1}".format(self.name, self.alias)
-        return "{0}={1}{2}".format(self.name, self.value, postfix)
-
-    def definition(self):
-        """ Convert to text definition e.g. VK_FOO = 1 """
-        postfix = "ull" if self.bitwidth == 64 else ""
-        if self.is_alias() and self.value == None:
-            return "{0} = {1}".format(self.name, self.alias)
-
-        # Hex is commonly used for FlagBits and sometimes within
-        # a non-FlagBits enum for a bitmask value as well.
-        if self.hex:
-            return "{0} = 0x{1:08x}{2}".format(self.name, self.value, postfix)
+        if alias:
+            self.hex = False
+            self.value = 0xffffffffffffffff
+        elif bitpos:
+            self.hex = True
+            self.value = (1 << int(bitpos))
         else:
-            return "{0} = {1}{2}".format(self.name, self.value, postfix)
+            self.hex = "0x" in value
+            self.value = int(value, 0)
 
     def is_alias(self):
         return self.alias is not None
 
+    def definition(self, size=4):
+        if self.alias:
+            return f"{self.name} = {self.alias}"
+
+        # Hex is commonly used for FlagBits and sometimes within
+        # a non-FlagBits enum for a bitmask value as well.
+        suffix = "ull" if size == 8 else ""
+        value  = f"0x{self.value:08x}" if self.hex else self.value
+        return f"{self.name} = {value}{suffix}"
+
 
 class VkFunction(object):
     def __init__(self, _type=None, name=None, params=[], alias=None):
@@ -3087,7 +3037,7 @@ class VkRegistry(object):
         for p in func.params:
             type_info = self.types[p.type]
 
-            # Check if we are dealing with a complex type e.g. VkEnum, VkStruct and others.
+            # Check if we are dealing with a complex type e.g. Enum, VkStruct and others.
             if "data" not in type_info:
                 continue
 
@@ -3177,7 +3127,7 @@ class VkRegistry(object):
             _type = enum.attrib.get("type")
 
             if _type in ("enum", "bitmask"):
-                enum_obj = VkEnum.from_xml(self, enum)
+                enum_obj = Enum.from_xml(enum)
                 enums[name] = enum_obj
             else:
                 # If no type is set, we are dealing with API constants.
@@ -3196,9 +3146,9 @@ class VkRegistry(object):
         if "extends" in enum_elem.keys():
             enum = self.types[enum_elem.attrib["extends"]]["data"]
 
-            # Need to define VkEnumValues which were aliased to by another value. This is necessary
+            # Need to define EnumValues which were aliased to by another value. This is necessary
             # from VK spec version 1.2.135 where the provisional VK_KHR_ray_tracing extension was
-            # added which altered VK_NV_ray_tracing's VkEnumValues to alias to the provisional
+            # added which altered VK_NV_ray_tracing's EnumValues to alias to the provisional
             # extension.
             aliased = False
             for _, t in self.types.items():
@@ -3213,12 +3163,7 @@ class VkRegistry(object):
             if only_aliased and not aliased:
                 return
 
-            if "bitpos" in enum_elem.keys():
-                # We need to add an extra value to an existing enum type.
-                # E.g. VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG to VkFormatFeatureFlagBits.
-                enum.create_bitpos(enum_elem.attrib["name"], int(enum_elem.attrib["bitpos"]))
-
-            elif "offset" in enum_elem.keys():
+            if "offset" in enum_elem.keys():
                 # Extensions promoted to Core, have the extension number as part
                 # of the enum value. Else retrieve from the extension tag.
                 if enum_elem.attrib.get("extnumber"):
@@ -3233,12 +3178,9 @@ class VkRegistry(object):
                 if direction is not None:
                     value = -value
 
-                enum.create_value(enum_elem.attrib["name"], str(value))
-
-            elif "value" in enum_elem.keys():
-                enum.create_value(enum_elem.attrib["name"], enum_elem.attrib["value"])
-            elif "alias" in enum_elem.keys():
-                enum.create_alias(enum_elem.attrib["name"], enum_elem.attrib["alias"])
+                enum.add(EnumValue(**enum_elem.attrib, value=str(value)))
+            else:
+                enum.add(EnumValue(**enum_elem.attrib))
 
         elif "value" in enum_elem.keys():
             # Constant with an explicit value
@@ -3255,7 +3197,7 @@ class VkRegistry(object):
 
     @staticmethod
     def _require_type(type_info):
-        if type(type_info) != VkDefine and type_info.is_alias():
+        if type(type_info) not in (VkDefine, Enum) and type_info.is_alias():
             type_info = type_info.alias
         type_info.required = True
         if type(type_info) == VkStruct:
@@ -3306,8 +3248,8 @@ class VkRegistry(object):
                 skipped_exts.append(ext_name)
                 return
 
-            # Extensions can define VkEnumValues which alias to provisional extensions. Pre-process
-            # extensions to define any required VkEnumValues before the platform check below.
+            # Extensions can define EnumValues which alias to provisional extensions. Pre-process
+            # extensions to define any required EnumValues before the platform check below.
             for require in ext.findall("require"):
                 # Extensions can add enum values to Core / extension enums, so add these.
                 for enum_elem in require.findall("enum"):
@@ -3547,9 +3489,8 @@ class VkRegistry(object):
                 type_info["data"] = bitmask
 
             if type_info["category"] == "enum":
-                enum = VkEnum.from_alias(self, t, self.types[alias]["data"])
-                type_info["data"] = enum
-                self.enums[enum.name] = enum
+                type_info["data"] = self.enums[alias]
+                self.enums[alias].typedefs += [type_info["name"]]
 
             if type_info["category"] == "handle":
                 handle = VkHandle.from_alias(self, t, self.types[alias]["data"])
diff --git a/include/wine/vulkan.h b/include/wine/vulkan.h
index bc1a5c56dc8..c693d373896 100644
--- a/include/wine/vulkan.h
+++ b/include/wine/vulkan.h
@@ -1364,8 +1364,8 @@ typedef enum StdVideoAV1ColorPrimaries
     STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_431 = 11,
     STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_432 = 12,
     STD_VIDEO_AV1_COLOR_PRIMARIES_EBU_3213 = 22,
-    STD_VIDEO_AV1_COLOR_PRIMARIES_BT_UNSPECIFIED = STD_VIDEO_AV1_COLOR_PRIMARIES_UNSPECIFIED,
     STD_VIDEO_AV1_COLOR_PRIMARIES_INVALID = 0x7fffffff,
+    STD_VIDEO_AV1_COLOR_PRIMARIES_BT_UNSPECIFIED = STD_VIDEO_AV1_COLOR_PRIMARIES_UNSPECIFIED,
 } StdVideoAV1ColorPrimaries;
 
 typedef enum StdVideoAV1FrameRestorationType
@@ -1840,9 +1840,9 @@ typedef enum VkAccelerationStructureTypeKHR
     VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR = 0,
     VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR = 1,
     VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR = 2,
+    VK_ACCELERATION_STRUCTURE_TYPE_KHR_MAX_ENUM = 0x7fffffff,
     VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR,
     VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR,
-    VK_ACCELERATION_STRUCTURE_TYPE_KHR_MAX_ENUM = 0x7fffffff,
 } VkAccelerationStructureTypeKHR;
 typedef VkAccelerationStructureTypeKHR VkAccelerationStructureTypeNV;
 
@@ -1877,13 +1877,13 @@ typedef enum VkAccessFlagBits
     VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT = 0x02000000,
     VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT = 0x04000000,
     VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT = 0x08000000,
+    VK_ACCESS_FLAG_BITS_MAX_ENUM = 0x7fffffff,
     VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV = VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR,
     VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV = VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR,
     VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV = VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR,
     VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV = VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_EXT,
     VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV = VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_EXT,
     VK_ACCESS_NONE_KHR = VK_ACCESS_NONE,
-    VK_ACCESS_FLAG_BITS_MAX_ENUM = 0x7fffffff,
 } VkAccessFlagBits;
 
 typedef VkFlags64 VkAccessFlagBits2;
@@ -2011,9 +2011,9 @@ typedef enum VkAttachmentLoadOp
     VK_ATTACHMENT_LOAD_OP_CLEAR = 1,
     VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2,
     VK_ATTACHMENT_LOAD_OP_NONE = 1000400000,
+    VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7fffffff,
     VK_ATTACHMENT_LOAD_OP_NONE_EXT = VK_ATTACHMENT_LOAD_OP_NONE,
     VK_ATTACHMENT_LOAD_OP_NONE_KHR = VK_ATTACHMENT_LOAD_OP_NONE,
-    VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7fffffff,
 } VkAttachmentLoadOp;
 
 typedef enum VkAttachmentStoreOp
@@ -2021,10 +2021,10 @@ typedef enum VkAttachmentStoreOp
     VK_ATTACHMENT_STORE_OP_STORE = 0,
     VK_ATTACHMENT_STORE_OP_DONT_CARE = 1,
     VK_ATTACHMENT_STORE_OP_NONE = 1000301000,
+    VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7fffffff,
     VK_ATTACHMENT_STORE_OP_NONE_KHR = VK_ATTACHMENT_STORE_OP_NONE,
     VK_ATTACHMENT_STORE_OP_NONE_QCOM = VK_ATTACHMENT_STORE_OP_NONE,
     VK_ATTACHMENT_STORE_OP_NONE_EXT = VK_ATTACHMENT_STORE_OP_NONE,
-    VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7fffffff,
 } VkAttachmentStoreOp;
 
 typedef enum VkBlendFactor
@@ -2144,9 +2144,9 @@ typedef enum VkBufferCreateFlagBits
     VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 0x00000010,
     VK_BUFFER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00000020,
     VK_BUFFER_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR = 0x00000040,
+    VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
     VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT,
     VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT,
-    VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
 } VkBufferCreateFlagBits;
 
 typedef enum VkBufferUsageFlagBits
@@ -2177,10 +2177,10 @@ typedef enum VkBufferUsageFlagBits
     VK_BUFFER_USAGE_MICROMAP_STORAGE_BIT_EXT = 0x01000000,
     VK_BUFFER_USAGE_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT = 0x04000000,
     VK_BUFFER_USAGE_TILE_MEMORY_BIT_QCOM = 0x08000000,
+    VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
     VK_BUFFER_USAGE_RAY_TRACING_BIT_NV = VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR,
     VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
     VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
-    VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
 } VkBufferUsageFlagBits;
 
 typedef VkFlags64 VkBufferUsageFlagBits2;
@@ -2240,6 +2240,7 @@ typedef enum VkBuildAccelerationStructureFlagBitsKHR
     VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_BIT_EXT = 0x00000100,
     VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR = 0x00000800,
     VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_CLUSTER_OPACITY_MICROMAPS_BIT_NV = 0x00001000,
+    VK_BUILD_ACCELERATION_STRUCTURE_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff,
     VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR,
     VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR,
     VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR,
@@ -2249,7 +2250,6 @@ typedef enum VkBuildAccelerationStructureFlagBitsKHR
     VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_EXT = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_EXT,
     VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_BIT_EXT,
     VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_KHR = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR,
-    VK_BUILD_ACCELERATION_STRUCTURE_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff,
 } VkBuildAccelerationStructureFlagBitsKHR;
 typedef VkBuildAccelerationStructureFlagBitsKHR VkBuildAccelerationStructureFlagBitsNV;
 
@@ -2278,9 +2278,9 @@ typedef enum VkChromaLocation
 {
     VK_CHROMA_LOCATION_COSITED_EVEN = 0,
     VK_CHROMA_LOCATION_MIDPOINT = 1,
+    VK_CHROMA_LOCATION_MAX_ENUM = 0x7fffffff,
     VK_CHROMA_LOCATION_COSITED_EVEN_KHR = VK_CHROMA_LOCATION_COSITED_EVEN,
     VK_CHROMA_LOCATION_MIDPOINT_KHR = VK_CHROMA_LOCATION_MIDPOINT,
-    VK_CHROMA_LOCATION_MAX_ENUM = 0x7fffffff,
 } VkChromaLocation;
 typedef VkChromaLocation VkChromaLocationKHR;
 
@@ -2380,9 +2380,9 @@ typedef enum VkColorSpaceKHR
     VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT = 1000104012,
     VK_COLOR_SPACE_PASS_THROUGH_EXT = 1000104013,
     VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT = 1000104014,
+    VK_COLOR_SPACE_KHR_MAX_ENUM = 0x7fffffff,
     VK_COLORSPACE_SRGB_NONLINEAR_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
     VK_COLOR_SPACE_DCI_P3_LINEAR_EXT = VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT,
-    VK_COLOR_SPACE_KHR_MAX_ENUM = 0x7fffffff,
 } VkColorSpaceKHR;
 
 typedef enum VkCommandBufferLevel
@@ -2463,6 +2463,7 @@ typedef enum VkComponentTypeKHR
     VK_COMPONENT_TYPE_UINT8_PACKED_NV = 1000491001,
     VK_COMPONENT_TYPE_FLOAT8_E4M3_EXT = 1000491002,
     VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT = 1000491003,
+    VK_COMPONENT_TYPE_KHR_MAX_ENUM = 0x7fffffff,
     VK_COMPONENT_TYPE_FLOAT16_NV = VK_COMPONENT_TYPE_FLOAT16_KHR,
     VK_COMPONENT_TYPE_FLOAT32_NV = VK_COMPONENT_TYPE_FLOAT32_KHR,
     VK_COMPONENT_TYPE_FLOAT64_NV = VK_COMPONENT_TYPE_FLOAT64_KHR,
@@ -2476,7 +2477,6 @@ typedef enum VkComponentTypeKHR
     VK_COMPONENT_TYPE_UINT64_NV = VK_COMPONENT_TYPE_UINT64_KHR,
     VK_COMPONENT_TYPE_FLOAT_E4M3_NV = VK_COMPONENT_TYPE_FLOAT8_E4M3_EXT,
     VK_COMPONENT_TYPE_FLOAT_E5M2_NV = VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT,
-    VK_COMPONENT_TYPE_KHR_MAX_ENUM = 0x7fffffff,
 } VkComponentTypeKHR;
 typedef VkComponentTypeKHR VkComponentTypeNV;
 
@@ -2518,9 +2518,9 @@ typedef enum VkCopyAccelerationStructureModeKHR
     VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR = 1,
     VK_COPY_ACCELERATION_STRUCTURE_MODE_SERIALIZE_KHR = 2,
     VK_COPY_ACCELERATION_STRUCTURE_MODE_DESERIALIZE_KHR = 3,
+    VK_COPY_ACCELERATION_STRUCTURE_MODE_KHR_MAX_ENUM = 0x7fffffff,
     VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV = VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR,
     VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV = VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR,
-    VK_COPY_ACCELERATION_STRUCTURE_MODE_KHR_MAX_ENUM = 0x7fffffff,
 } VkCopyAccelerationStructureModeKHR;
 typedef VkCopyAccelerationStructureModeKHR VkCopyAccelerationStructureModeNV;
 
@@ -2649,11 +2649,11 @@ typedef enum VkDebugReportObjectTypeEXT
     VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT = 1000150000,
     VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT = 1000156000,
     VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT = 1000165000,
+    VK_DEBUG_REPORT_OBJECT_TYPE_EXT_MAX_ENUM = 0x7fffffff,
     VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT,
     VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT,
     VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT,
     VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT,
-    VK_DEBUG_REPORT_OBJECT_TYPE_EXT_MAX_ENUM = 0x7fffffff,
 } VkDebugReportObjectTypeEXT;
 
 typedef enum VkDebugUtilsMessageSeverityFlagBitsEXT
@@ -2689,9 +2689,9 @@ typedef enum VkDependencyFlagBits
     VK_DEPENDENCY_FEEDBACK_LOOP_BIT_EXT = 0x00000008,
     VK_DEPENDENCY_QUEUE_FAMILY_OWNERSHIP_TRANSFER_USE_ALL_STAGES_BIT_KHR = 0x00000020,
     VK_DEPENDENCY_ASYMMETRIC_EVENT_BIT_KHR = 0x00000040,
+    VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7fffffff,
     VK_DEPENDENCY_VIEW_LOCAL_BIT_KHR = VK_DEPENDENCY_VIEW_LOCAL_BIT,
     VK_DEPENDENCY_DEVICE_GROUP_BIT_KHR = VK_DEPENDENCY_DEVICE_GROUP_BIT,
-    VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7fffffff,
 } VkDependencyFlagBits;
 
 typedef enum VkDepthBiasRepresentationEXT
@@ -2715,11 +2715,11 @@ typedef enum VkDescriptorBindingFlagBits
     VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT = 0x00000002,
     VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT = 0x00000004,
     VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT = 0x00000008,
+    VK_DESCRIPTOR_BINDING_FLAG_BITS_MAX_ENUM = 0x7fffffff,
     VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT = VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT,
     VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT = VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT,
     VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT = VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT,
     VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT = VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT,
-    VK_DESCRIPTOR_BINDING_FLAG_BITS_MAX_ENUM = 0x7fffffff,
 } VkDescriptorBindingFlagBits;
 typedef VkDescriptorBindingFlagBits VkDescriptorBindingFlagBitsEXT;
 
@@ -2730,9 +2730,9 @@ typedef enum VkDescriptorPoolCreateFlagBits
     VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_EXT = 0x00000004,
     VK_DESCRIPTOR_POOL_CREATE_ALLOW_OVERALLOCATION_SETS_BIT_NV = 0x00000008,
     VK_DESCRIPTOR_POOL_CREATE_ALLOW_OVERALLOCATION_POOLS_BIT_NV = 0x00000010,
+    VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
     VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT,
     VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE = VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_EXT,
-    VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
 } VkDescriptorPoolCreateFlagBits;
 
 typedef enum VkDescriptorSetLayoutCreateFlagBits
@@ -2744,10 +2744,10 @@ typedef enum VkDescriptorSetLayoutCreateFlagBits
     VK_DESCRIPTOR_SET_LAYOUT_CREATE_EMBEDDED_IMMUTABLE_SAMPLERS_BIT_EXT = 0x00000020,
     VK_DESCRIPTOR_SET_LAYOUT_CREATE_PER_STAGE_BIT_NV = 0x00000040,
     VK_DESCRIPTOR_SET_LAYOUT_CREATE_INDIRECT_BINDABLE_BIT_NV = 0x00000080,
+    VK_DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
     VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR = VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT,
     VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT,
     VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE = VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT,
-    VK_DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
 } VkDescriptorSetLayoutCreateFlagBits;
 
 typedef enum VkDescriptorType
@@ -2771,18 +2771,18 @@ typedef enum VkDescriptorType
     VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM = 1000440001,
     VK_DESCRIPTOR_TYPE_TENSOR_ARM = 1000460000,
     VK_DESCRIPTOR_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_NV = 1000570000,
+    VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7fffffff,
     VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT = VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK,
     VK_DESCRIPTOR_TYPE_MUTABLE_VALVE = VK_DESCRIPTOR_TYPE_MUTABLE_EXT,
-    VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7fffffff,
 } VkDescriptorType;
 
 typedef enum VkDescriptorUpdateTemplateType
 {
     VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET = 0,
     VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS = 1,
+    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_MAX_ENUM = 0x7fffffff,
     VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS,
     VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET,
-    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_MAX_ENUM = 0x7fffffff,
 } VkDescriptorUpdateTemplateType;
 typedef VkDescriptorUpdateTemplateType VkDescriptorUpdateTemplateTypeKHR;
 
@@ -2878,6 +2878,7 @@ typedef enum VkDriverId
     VK_DRIVER_ID_MESA_HONEYKRISP = 26,
     VK_DRIVER_ID_VULKAN_SC_EMULATION_ON_VULKAN = 27,
     VK_DRIVER_ID_MESA_KOSMICKRISP = 28,
+    VK_DRIVER_ID_MAX_ENUM = 0x7fffffff,
     VK_DRIVER_ID_AMD_PROPRIETARY_KHR = VK_DRIVER_ID_AMD_PROPRIETARY,
     VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR = VK_DRIVER_ID_AMD_OPEN_SOURCE,
     VK_DRIVER_ID_MESA_RADV_KHR = VK_DRIVER_ID_MESA_RADV,
@@ -2890,7 +2891,6 @@ typedef enum VkDriverId
     VK_DRIVER_ID_GOOGLE_SWIFTSHADER_KHR = VK_DRIVER_ID_GOOGLE_SWIFTSHADER,
     VK_DRIVER_ID_GGP_PROPRIETARY_KHR = VK_DRIVER_ID_GGP_PROPRIETARY,
     VK_DRIVER_ID_BROADCOM_PROPRIETARY_KHR = VK_DRIVER_ID_BROADCOM_PROPRIETARY,
-    VK_DRIVER_ID_MAX_ENUM = 0x7fffffff,
 } VkDriverId;
 typedef VkDriverId VkDriverIdKHR;
 
@@ -2969,6 +2969,7 @@ typedef enum VkDynamicState
     VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV = 1000455032,
     VK_DYNAMIC_STATE_ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT = 1000524000,
     VK_DYNAMIC_STATE_DEPTH_CLAMP_RANGE_EXT = 1000582000,
+    VK_DYNAMIC_STATE_MAX_ENUM = 0x7fffffff,
     VK_DYNAMIC_STATE_LINE_STIPPLE_EXT = VK_DYNAMIC_STATE_LINE_STIPPLE,
     VK_DYNAMIC_STATE_CULL_MODE_EXT = VK_DYNAMIC_STATE_CULL_MODE,
     VK_DYNAMIC_STATE_FRONT_FACE_EXT = VK_DYNAMIC_STATE_FRONT_FACE,
@@ -2986,23 +2987,22 @@ typedef enum VkDynamicState
     VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT = VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE,
     VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT = VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE,
     VK_DYNAMIC_STATE_LINE_STIPPLE_KHR = VK_DYNAMIC_STATE_LINE_STIPPLE,
-    VK_DYNAMIC_STATE_MAX_ENUM = 0x7fffffff,
 } VkDynamicState;
 
 typedef enum VkEventCreateFlagBits
 {
     VK_EVENT_CREATE_DEVICE_ONLY_BIT = 0x00000001,
-    VK_EVENT_CREATE_DEVICE_ONLY_BIT_KHR = VK_EVENT_CREATE_DEVICE_ONLY_BIT,
     VK_EVENT_CREATE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
+    VK_EVENT_CREATE_DEVICE_ONLY_BIT_KHR = VK_EVENT_CREATE_DEVICE_ONLY_BIT,
 } VkEventCreateFlagBits;
 
 typedef enum VkExternalFenceFeatureFlagBits
 {
     VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT = 0x00000001,
     VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT = 0x00000002,
+    VK_EXTERNAL_FENCE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
     VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT,
     VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT,
-    VK_EXTERNAL_FENCE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
 } VkExternalFenceFeatureFlagBits;
 typedef VkExternalFenceFeatureFlagBits VkExternalFenceFeatureFlagBitsKHR;
 
@@ -3012,11 +3012,11 @@ typedef enum VkExternalFenceHandleTypeFlagBits
     VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002,
     VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004,
     VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000008,
+    VK_EXTERNAL_FENCE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
     VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT,
     VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT,
     VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
     VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT,
-    VK_EXTERNAL_FENCE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
 } VkExternalFenceHandleTypeFlagBits;
 typedef VkExternalFenceHandleTypeFlagBits VkExternalFenceHandleTypeFlagBitsKHR;
 
@@ -3025,10 +3025,10 @@ typedef enum VkExternalMemoryFeatureFlagBits
     VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT = 0x00000001,
     VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT = 0x00000002,
     VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT = 0x00000004,
+    VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
     VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT,
     VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT,
     VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT,
-    VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
 } VkExternalMemoryFeatureFlagBits;
 typedef VkExternalMemoryFeatureFlagBits VkExternalMemoryFeatureFlagBitsKHR;
 
@@ -3047,6 +3047,7 @@ typedef enum VkExternalMemoryHandleTypeFlagBits
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLBUFFER_BIT_EXT = 0x00010000,
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLTEXTURE_BIT_EXT = 0x00020000,
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLHEAP_BIT_EXT = 0x00040000,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT,
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT,
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
@@ -3054,7 +3055,6 @@ typedef enum VkExternalMemoryHandleTypeFlagBits
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT,
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT,
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT,
-    VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
 } VkExternalMemoryHandleTypeFlagBits;
 typedef VkExternalMemoryHandleTypeFlagBits VkExternalMemoryHandleTypeFlagBitsKHR;
 
@@ -3062,9 +3062,9 @@ typedef enum VkExternalSemaphoreFeatureFlagBits
 {
     VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT = 0x00000001,
     VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT = 0x00000002,
+    VK_EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
     VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT,
     VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT,
-    VK_EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
 } VkExternalSemaphoreFeatureFlagBits;
 typedef VkExternalSemaphoreFeatureFlagBits VkExternalSemaphoreFeatureFlagBitsKHR;
 
@@ -3075,13 +3075,13 @@ typedef enum VkExternalSemaphoreHandleTypeFlagBits
     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004,
     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT = 0x00000008,
     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000010,
+    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE_BIT = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT,
     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT,
     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT,
     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT,
     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT,
-    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
 } VkExternalSemaphoreHandleTypeFlagBits;
 typedef VkExternalSemaphoreHandleTypeFlagBits VkExternalSemaphoreHandleTypeFlagBitsKHR;
 
@@ -3094,8 +3094,8 @@ typedef enum VkFenceCreateFlagBits
 typedef enum VkFenceImportFlagBits
 {
     VK_FENCE_IMPORT_TEMPORARY_BIT = 0x00000001,
-    VK_FENCE_IMPORT_TEMPORARY_BIT_KHR = VK_FENCE_IMPORT_TEMPORARY_BIT,
     VK_FENCE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7fffffff,
+    VK_FENCE_IMPORT_TEMPORARY_BIT_KHR = VK_FENCE_IMPORT_TEMPORARY_BIT,
 } VkFenceImportFlagBits;
 typedef VkFenceImportFlagBits VkFenceImportFlagBitsKHR;
 
@@ -3104,8 +3104,8 @@ typedef enum VkFilter
     VK_FILTER_NEAREST = 0,
     VK_FILTER_LINEAR = 1,
     VK_FILTER_CUBIC_EXT = 1000015000,
-    VK_FILTER_CUBIC_IMG = VK_FILTER_CUBIC_EXT,
     VK_FILTER_MAX_ENUM = 0x7fffffff,
+    VK_FILTER_CUBIC_IMG = VK_FILTER_CUBIC_EXT,
 } VkFilter;
 
 typedef enum VkFormat
@@ -3375,6 +3375,7 @@ typedef enum VkFormat
     VK_FORMAT_R14X2G14X2B14X2A14X2_UNORM_4PACK16_ARM = 1000609011,
     VK_FORMAT_G14X2_B14X2R14X2_2PLANE_420_UNORM_3PACK16_ARM = 1000609012,
     VK_FORMAT_G14X2_B14X2R14X2_2PLANE_422_UNORM_3PACK16_ARM = 1000609013,
+    VK_FORMAT_MAX_ENUM = 0x7fffffff,
     VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK,
     VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK,
     VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK,
@@ -3432,7 +3433,6 @@ typedef enum VkFormat
     VK_FORMAT_R16G16_S10_5_NV = VK_FORMAT_R16G16_SFIXED5_NV,
     VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR = VK_FORMAT_A1B5G5R5_UNORM_PACK16,
     VK_FORMAT_A8_UNORM_KHR = VK_FORMAT_A8_UNORM,
-    VK_FORMAT_MAX_ENUM = 0x7fffffff,
 } VkFormat;
 
 typedef enum VkFormatFeatureFlagBits
@@ -3468,6 +3468,7 @@ typedef enum VkFormatFeatureFlagBits
     VK_FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR = 0x10000000,
     VK_FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR = 0x20000000,
     VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x40000000,
+    VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
     VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT,
     VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT,
     VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_DST_BIT,
@@ -3479,7 +3480,6 @@ typedef enum VkFormatFeatureFlagBits
     VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT,
     VK_FORMAT_FEATURE_DISJOINT_BIT_KHR = VK_FORMAT_FEATURE_DISJOINT_BIT,
     VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT,
-    VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
 } VkFormatFeatureFlagBits;
 
 typedef VkFlags64 VkFormatFeatureFlagBits2;
@@ -3611,8 +3611,8 @@ typedef enum VkFrameBoundaryFlagBitsEXT
 typedef enum VkFramebufferCreateFlagBits
 {
     VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT = 0x00000001,
-    VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR = VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT,
     VK_FRAMEBUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
+    VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR = VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT,
 } VkFramebufferCreateFlagBits;
 
 typedef enum VkFrontFace
@@ -3626,9 +3626,9 @@ typedef enum VkGeometryFlagBitsKHR
 {
     VK_GEOMETRY_OPAQUE_BIT_KHR = 0x00000001,
     VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR = 0x00000002,
+    VK_GEOMETRY_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff,
     VK_GEOMETRY_OPAQUE_BIT_NV = VK_GEOMETRY_OPAQUE_BIT_KHR,
     VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_NV = VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR,
-    VK_GEOMETRY_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff,
 } VkGeometryFlagBitsKHR;
 typedef VkGeometryFlagBitsKHR VkGeometryFlagBitsNV;
 
@@ -3640,6 +3640,7 @@ typedef enum VkGeometryInstanceFlagBitsKHR
     VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR = 0x00000008,
     VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_EXT = 0x00000010,
     VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_EXT = 0x00000020,
+    VK_GEOMETRY_INSTANCE_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff,
     VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR = VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR,
     VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NV = VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR,
     VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_NV = VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR,
@@ -3647,7 +3648,6 @@ typedef enum VkGeometryInstanceFlagBitsKHR
     VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NV = VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR,
     VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_EXT = VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_EXT,
     VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_EXT = VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_EXT,
-    VK_GEOMETRY_INSTANCE_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff,
 } VkGeometryInstanceFlagBitsKHR;
 typedef VkGeometryInstanceFlagBitsKHR VkGeometryInstanceFlagBitsNV;
 
@@ -3658,9 +3658,9 @@ typedef enum VkGeometryTypeKHR
     VK_GEOMETRY_TYPE_INSTANCES_KHR = 2,
     VK_GEOMETRY_TYPE_SPHERES_NV = 1000429004,
     VK_GEOMETRY_TYPE_LINEAR_SWEPT_SPHERES_NV = 1000429005,
+    VK_GEOMETRY_TYPE_KHR_MAX_ENUM = 0x7fffffff,
     VK_GEOMETRY_TYPE_TRIANGLES_NV = VK_GEOMETRY_TYPE_TRIANGLES_KHR,
     VK_GEOMETRY_TYPE_AABBS_NV = VK_GEOMETRY_TYPE_AABBS_KHR,
-    VK_GEOMETRY_TYPE_KHR_MAX_ENUM = 0x7fffffff,
 } VkGeometryTypeKHR;
 typedef VkGeometryTypeKHR VkGeometryTypeNV;
 
@@ -3676,10 +3676,10 @@ typedef enum VkGraphicsPipelineLibraryFlagBitsEXT
 typedef enum VkHostImageCopyFlagBits
 {
     VK_HOST_IMAGE_COPY_MEMCPY_BIT = 0x00000001,
+    VK_HOST_IMAGE_COPY_FLAG_BITS_MAX_ENUM = 0x7fffffff,
     VK_HOST_IMAGE_COPY_MEMCPY = VK_HOST_IMAGE_COPY_MEMCPY_BIT,
     VK_HOST_IMAGE_COPY_MEMCPY_BIT_EXT = VK_HOST_IMAGE_COPY_MEMCPY_BIT,
     VK_HOST_IMAGE_COPY_MEMCPY_EXT = VK_HOST_IMAGE_COPY_MEMCPY_BIT,
-    VK_HOST_IMAGE_COPY_FLAG_BITS_MAX_ENUM = 0x7fffffff,
 } VkHostImageCopyFlagBits;
 typedef VkHostImageCopyFlagBits VkHostImageCopyFlagBitsEXT;
 
@@ -3697,11 +3697,11 @@ typedef enum VkImageAspectFlagBits
     VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT = 0x00000100,
     VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT = 0x00000200,
     VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT = 0x00000400,
+    VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM = 0x7fffffff,
     VK_IMAGE_ASPECT_PLANE_0_BIT_KHR = VK_IMAGE_ASPECT_PLANE_0_BIT,
     VK_IMAGE_ASPECT_PLANE_1_BIT_KHR = VK_IMAGE_ASPECT_PLANE_1_BIT,
     VK_IMAGE_ASPECT_PLANE_2_BIT_KHR = VK_IMAGE_ASPECT_PLANE_2_BIT,
     VK_IMAGE_ASPECT_NONE_KHR = VK_IMAGE_ASPECT_NONE,
-    VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM = 0x7fffffff,
 } VkImageAspectFlagBits;
 
 typedef enum VkImageCompressionFixedRateFlagBitsEXT
@@ -3765,6 +3765,7 @@ typedef enum VkImageCreateFlagBits
     VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT = 0x00020000,
     VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT = 0x00040000,
     VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR = 0x00100000,
+    VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
     VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT,
     VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT,
     VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT,
@@ -3772,7 +3773,6 @@ typedef enum VkImageCreateFlagBits
     VK_IMAGE_CREATE_DISJOINT_BIT_KHR = VK_IMAGE_CREATE_DISJOINT_BIT,
     VK_IMAGE_CREATE_ALIAS_BIT_KHR = VK_IMAGE_CREATE_ALIAS_BIT,
     VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM = VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT,
-    VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
 } VkImageCreateFlagBits;
 
 typedef enum VkImageLayout
@@ -3808,6 +3808,7 @@ typedef enum VkImageLayout
     VK_IMAGE_LAYOUT_TENSOR_ALIASING_ARM = 1000460000,
     VK_IMAGE_LAYOUT_VIDEO_ENCODE_QUANTIZATION_MAP_KHR = 1000553000,
     VK_IMAGE_LAYOUT_ZERO_INITIALIZED_EXT = 1000620000,
+    VK_IMAGE_LAYOUT_MAX_ENUM = 0x7fffffff,
     VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL,
     VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL,
     VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV = VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR,
@@ -3818,7 +3819,6 @@ typedef enum VkImageLayout
     VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL,
     VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL,
     VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL,
-    VK_IMAGE_LAYOUT_MAX_ENUM = 0x7fffffff,
 } VkImageLayout;
 
 typedef enum VkImageTiling
@@ -3864,9 +3864,9 @@ typedef enum VkImageUsageFlagBits
     VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR = 0x02000000,
     VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR = 0x04000000,
     VK_IMAGE_USAGE_TILE_MEMORY_BIT_QCOM = 0x08000000,
+    VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
     VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV = VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR,
     VK_IMAGE_USAGE_HOST_TRANSFER_BIT_EXT = VK_IMAGE_USAGE_HOST_TRANSFER_BIT,
-    VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
 } VkImageUsageFlagBits;
 
 typedef enum VkImageViewCreateFlagBits
@@ -3895,10 +3895,10 @@ typedef enum VkIndexType
     VK_INDEX_TYPE_UINT32 = 1,
     VK_INDEX_TYPE_NONE_KHR = 1000165000,
     VK_INDEX_TYPE_UINT8 = 1000265000,
+    VK_INDEX_TYPE_MAX_ENUM = 0x7fffffff,
     VK_INDEX_TYPE_NONE_NV = VK_INDEX_TYPE_NONE_KHR,
     VK_INDEX_TYPE_UINT8_EXT = VK_INDEX_TYPE_UINT8,
     VK_INDEX_TYPE_UINT8_KHR = VK_INDEX_TYPE_UINT8,
-    VK_INDEX_TYPE_MAX_ENUM = 0x7fffffff,
 } VkIndexType;
 
 typedef enum VkIndirectCommandsInputModeFlagBitsEXT
@@ -4027,6 +4027,7 @@ typedef enum VkLineRasterizationMode
     VK_LINE_RASTERIZATION_MODE_RECTANGULAR = 1,
     VK_LINE_RASTERIZATION_MODE_BRESENHAM = 2,
     VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH = 3,
+    VK_LINE_RASTERIZATION_MODE_MAX_ENUM = 0x7fffffff,
     VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT = VK_LINE_RASTERIZATION_MODE_DEFAULT,
     VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT = VK_LINE_RASTERIZATION_MODE_RECTANGULAR,
     VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT = VK_LINE_RASTERIZATION_MODE_BRESENHAM,
@@ -4035,7 +4036,6 @@ typedef enum VkLineRasterizationMode
     VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR = VK_LINE_RASTERIZATION_MODE_RECTANGULAR,
     VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR = VK_LINE_RASTERIZATION_MODE_BRESENHAM,
     VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH,
-    VK_LINE_RASTERIZATION_MODE_MAX_ENUM = 0x7fffffff,
 } VkLineRasterizationMode;
 typedef VkLineRasterizationMode VkLineRasterizationModeKHR;
 typedef VkLineRasterizationMode VkLineRasterizationModeEXT;
@@ -4067,10 +4067,10 @@ typedef enum VkMemoryAllocateFlagBits
     VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT = 0x00000002,
     VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 0x00000004,
     VK_MEMORY_ALLOCATE_ZERO_INITIALIZE_BIT_EXT = 0x00000008,
+    VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
     VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT,
     VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT,
     VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT,
-    VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
 } VkMemoryAllocateFlagBits;
 typedef VkMemoryAllocateFlagBits VkMemoryAllocateFlagBitsKHR;
 
@@ -4085,8 +4085,8 @@ typedef enum VkMemoryHeapFlagBits
     VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001,
     VK_MEMORY_HEAP_MULTI_INSTANCE_BIT = 0x00000002,
     VK_MEMORY_HEAP_TILE_MEMORY_BIT_QCOM = 0x00000008,
-    VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT,
     VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 0x7fffffff,
+    VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT,
 } VkMemoryHeapFlagBits;
 
 typedef enum VkMemoryMapFlagBits
@@ -4189,10 +4189,10 @@ typedef enum VkObjectType
     VK_OBJECT_TYPE_DATA_GRAPH_PIPELINE_SESSION_ARM = 1000507000,
     VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT = 1000572000,
     VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT = 1000572001,
+    VK_OBJECT_TYPE_MAX_ENUM = 0x7fffffff,
     VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE,
     VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION,
     VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT = VK_OBJECT_TYPE_PRIVATE_DATA_SLOT,
-    VK_OBJECT_TYPE_MAX_ENUM = 0x7fffffff,
 } VkObjectType;
 
 typedef enum VkOpacityMicromapFormatEXT
@@ -4303,11 +4303,11 @@ typedef enum VkPeerMemoryFeatureFlagBits
     VK_PEER_MEMORY_FEATURE_COPY_DST_BIT = 0x00000002,
     VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT = 0x00000004,
     VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT = 0x00000008,
+    VK_PEER_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
     VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHR = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT,
     VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHR = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT,
     VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHR = VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT,
     VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHR = VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT,
-    VK_PEER_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
 } VkPeerMemoryFeatureFlagBits;
 typedef VkPeerMemoryFeatureFlagBits VkPeerMemoryFeatureFlagBitsKHR;
 
@@ -4321,9 +4321,9 @@ typedef enum VkPerformanceCounterDescriptionFlagBitsKHR
 {
     VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR = 0x00000001,
     VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR = 0x00000002,
+    VK_PERFORMANCE_COUNTER_DESCRIPTION_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff,
     VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR = VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR,
     VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR = VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR,
-    VK_PERFORMANCE_COUNTER_DESCRIPTION_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff,
 } VkPerformanceCounterDescriptionFlagBitsKHR;
 
 typedef enum VkPerformanceCounterScopeKHR
@@ -4331,10 +4331,10 @@ typedef enum VkPerformanceCounterScopeKHR
     VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR = 0,
     VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR = 1,
     VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR = 2,
+    VK_PERFORMANCE_COUNTER_SCOPE_KHR_MAX_ENUM = 0x7fffffff,
     VK_QUERY_SCOPE_COMMAND_BUFFER_KHR = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR,
     VK_QUERY_SCOPE_RENDER_PASS_KHR = VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR,
     VK_QUERY_SCOPE_COMMAND_KHR = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR,
-    VK_PERFORMANCE_COUNTER_SCOPE_KHR_MAX_ENUM = 0x7fffffff,
 } VkPerformanceCounterScopeKHR;
 
 typedef enum VkPerformanceCounterStorageKHR
@@ -4425,16 +4425,16 @@ typedef enum VkPipelineBindPoint
     VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR = 1000165000,
     VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI = 1000369003,
     VK_PIPELINE_BIND_POINT_DATA_GRAPH_ARM = 1000507000,
-    VK_PIPELINE_BIND_POINT_RAY_TRACING_NV = VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR,
     VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7fffffff,
+    VK_PIPELINE_BIND_POINT_RAY_TRACING_NV = VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR,
 } VkPipelineBindPoint;
 
 typedef enum VkPipelineCacheCreateFlagBits
 {
     VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT = 0x00000001,
     VK_PIPELINE_CACHE_CREATE_INTERNALLY_SYNCHRONIZED_MERGE_BIT_KHR = 0x00000008,
-    VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT = VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT,
     VK_PIPELINE_CACHE_CREATE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
+    VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT = VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT,
 } VkPipelineCacheCreateFlagBits;
 
 typedef enum VkPipelineCacheHeaderVersion
@@ -4447,8 +4447,8 @@ typedef enum VkPipelineCacheHeaderVersion
 typedef enum VkPipelineColorBlendStateCreateFlagBits
 {
     VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT = 0x00000001,
-    VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_ARM = VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT,
     VK_PIPELINE_COLOR_BLEND_STATE_CREATE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
+    VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_ARM = VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT,
 } VkPipelineColorBlendStateCreateFlagBits;
 
 typedef enum VkPipelineCompilerControlFlagBitsAMD
@@ -4488,6 +4488,7 @@ typedef enum VkPipelineCreateFlagBits
     VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT = 0x08000000,
     VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT = 0x20000000,
     VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT = 0x40000000,
+    VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
     VK_PIPELINE_CREATE_DISPATCH_BASE = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT,
     VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT,
     VK_PIPELINE_CREATE_DISPATCH_BASE_BIT_KHR = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT,
@@ -4498,7 +4499,6 @@ typedef enum VkPipelineCreateFlagBits
     VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT_EXT = VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT,
     VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT_EXT = VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT,
     VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT_EXT = VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT,
-    VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
 } VkPipelineCreateFlagBits;
 
 typedef VkFlags64 VkPipelineCreateFlagBits2;
@@ -4558,10 +4558,10 @@ typedef enum VkPipelineCreationFeedbackFlagBits
     VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT = 0x00000001,
     VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT = 0x00000002,
     VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT = 0x00000004,
+    VK_PIPELINE_CREATION_FEEDBACK_FLAG_BITS_MAX_ENUM = 0x7fffffff,
     VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT_EXT = VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT,
     VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT_EXT = VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT,
     VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT_EXT = VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT,
-    VK_PIPELINE_CREATION_FEEDBACK_FLAG_BITS_MAX_ENUM = 0x7fffffff,
 } VkPipelineCreationFeedbackFlagBits;
 typedef VkPipelineCreationFeedbackFlagBits VkPipelineCreationFeedbackFlagBitsEXT;
 
@@ -4569,9 +4569,9 @@ typedef enum VkPipelineDepthStencilStateCreateFlagBits
 {
     VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT = 0x00000001,
     VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT = 0x00000002,
+    VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
     VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM = VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT,
     VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM = VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT,
-    VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
 } VkPipelineDepthStencilStateCreateFlagBits;
 
 typedef enum VkPipelineExecutableStatisticFormatKHR
@@ -4595,11 +4595,11 @@ typedef enum VkPipelineRobustnessBufferBehavior
     VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED = 1,
     VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS = 2,
     VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2 = 3,
+    VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_MAX_ENUM = 0x7fffffff,
     VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT_EXT = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT,
     VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED_EXT = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED,
     VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_EXT = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS,
     VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2,
-    VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_MAX_ENUM = 0x7fffffff,
 } VkPipelineRobustnessBufferBehavior;
 typedef VkPipelineRobustnessBufferBehavior VkPipelineRobustnessBufferBehaviorEXT;
 
@@ -4609,11 +4609,11 @@ typedef enum VkPipelineRobustnessImageBehavior
     VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED = 1,
     VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS = 2,
     VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2 = 3,
+    VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_MAX_ENUM = 0x7fffffff,
     VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT_EXT = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT,
     VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED_EXT = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED,
     VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_EXT = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS,
     VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2_EXT = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2,
-    VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_MAX_ENUM = 0x7fffffff,
 } VkPipelineRobustnessImageBehavior;
 typedef VkPipelineRobustnessImageBehavior VkPipelineRobustnessImageBehaviorEXT;
 
@@ -4621,9 +4621,9 @@ typedef enum VkPipelineShaderStageCreateFlagBits
 {
     VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT = 0x00000001,
     VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT = 0x00000002,
+    VK_PIPELINE_SHADER_STAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
     VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT = VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT,
     VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT = VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT,
-    VK_PIPELINE_SHADER_STAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
 } VkPipelineShaderStageCreateFlagBits;
 
 typedef enum VkPipelineStageFlagBits
@@ -4655,6 +4655,7 @@ typedef enum VkPipelineStageFlagBits
     VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT = 0x00800000,
     VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT = 0x01000000,
     VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR = 0x02000000,
+    VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
     VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV = VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR,
     VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV = VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR,
     VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV = VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR,
@@ -4662,7 +4663,6 @@ typedef enum VkPipelineStageFlagBits
     VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV = VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT,
     VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV = VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_EXT,
     VK_PIPELINE_STAGE_NONE_KHR = VK_PIPELINE_STAGE_NONE,
-    VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
 } VkPipelineStageFlagBits;
 
 typedef VkFlags64 VkPipelineStageFlagBits2;
@@ -4753,9 +4753,9 @@ typedef enum VkPointClippingBehavior
 {
     VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES = 0,
     VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY = 1,
+    VK_POINT_CLIPPING_BEHAVIOR_MAX_ENUM = 0x7fffffff,
     VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES,
     VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY,
-    VK_POINT_CLIPPING_BEHAVIOR_MAX_ENUM = 0x7fffffff,
 } VkPointClippingBehavior;
 typedef VkPointClippingBehavior VkPointClippingBehaviorKHR;
 
@@ -4773,10 +4773,10 @@ typedef enum VkPresentGravityFlagBitsKHR
     VK_PRESENT_GRAVITY_MIN_BIT_KHR = 0x00000001,
     VK_PRESENT_GRAVITY_MAX_BIT_KHR = 0x00000002,
     VK_PRESENT_GRAVITY_CENTERED_BIT_KHR = 0x00000004,
+    VK_PRESENT_GRAVITY_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff,
     VK_PRESENT_GRAVITY_MIN_BIT_EXT = VK_PRESENT_GRAVITY_MIN_BIT_KHR,
     VK_PRESENT_GRAVITY_MAX_BIT_EXT = VK_PRESENT_GRAVITY_MAX_BIT_KHR,
     VK_PRESENT_GRAVITY_CENTERED_BIT_EXT = VK_PRESENT_GRAVITY_CENTERED_BIT_KHR,
-    VK_PRESENT_GRAVITY_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff,
 } VkPresentGravityFlagBitsKHR;
 typedef VkPresentGravityFlagBitsKHR VkPresentGravityFlagBitsEXT;
 
@@ -4787,8 +4787,8 @@ typedef enum VkPresentModeKHR
     VK_PRESENT_MODE_FIFO_KHR = 2,
     VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3,
     VK_PRESENT_MODE_FIFO_LATEST_READY_KHR = 1000361000,
-    VK_PRESENT_MODE_FIFO_LATEST_READY_EXT = VK_PRESENT_MODE_FIFO_LATEST_READY_KHR,
     VK_PRESENT_MODE_KHR_MAX_ENUM = 0x7fffffff,
+    VK_PRESENT_MODE_FIFO_LATEST_READY_EXT = VK_PRESENT_MODE_FIFO_LATEST_READY_KHR,
 } VkPresentModeKHR;
 
 typedef enum VkPresentScalingFlagBitsKHR
@@ -4796,10 +4796,10 @@ typedef enum VkPresentScalingFlagBitsKHR
     VK_PRESENT_SCALING_ONE_TO_ONE_BIT_KHR = 0x00000001,
     VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_KHR = 0x00000002,
     VK_PRESENT_SCALING_STRETCH_BIT_KHR = 0x00000004,
+    VK_PRESENT_SCALING_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff,
     VK_PRESENT_SCALING_ONE_TO_ONE_BIT_EXT = VK_PRESENT_SCALING_ONE_TO_ONE_BIT_KHR,
     VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_EXT = VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_KHR,
     VK_PRESENT_SCALING_STRETCH_BIT_EXT = VK_PRESENT_SCALING_STRETCH_BIT_KHR,
-    VK_PRESENT_SCALING_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff,
 } VkPresentScalingFlagBitsKHR;
 typedef VkPresentScalingFlagBitsKHR VkPresentScalingFlagBitsEXT;
 
@@ -4924,6 +4924,7 @@ typedef enum VkQueueGlobalPriority
     VK_QUEUE_GLOBAL_PRIORITY_MEDIUM = 256,
     VK_QUEUE_GLOBAL_PRIORITY_HIGH = 512,
     VK_QUEUE_GLOBAL_PRIORITY_REALTIME = 1024,
+    VK_QUEUE_GLOBAL_PRIORITY_MAX_ENUM = 0x7fffffff,
     VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT = VK_QUEUE_GLOBAL_PRIORITY_LOW,
     VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT = VK_QUEUE_GLOBAL_PRIORITY_MEDIUM,
     VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT = VK_QUEUE_GLOBAL_PRIORITY_HIGH,
@@ -4932,7 +4933,6 @@ typedef enum VkQueueGlobalPriority
     VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_KHR = VK_QUEUE_GLOBAL_PRIORITY_MEDIUM,
     VK_QUEUE_GLOBAL_PRIORITY_HIGH_KHR = VK_QUEUE_GLOBAL_PRIORITY_HIGH,
     VK_QUEUE_GLOBAL_PRIORITY_REALTIME_KHR = VK_QUEUE_GLOBAL_PRIORITY_REALTIME,
-    VK_QUEUE_GLOBAL_PRIORITY_MAX_ENUM = 0x7fffffff,
 } VkQueueGlobalPriority;
 typedef VkQueueGlobalPriority VkQueueGlobalPriorityKHR;
 typedef VkQueueGlobalPriority VkQueueGlobalPriorityEXT;
@@ -4948,9 +4948,9 @@ typedef enum VkRayTracingInvocationReorderModeEXT
 {
     VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_EXT = 0,
     VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_EXT = 1,
+    VK_RAY_TRACING_INVOCATION_REORDER_MODE_EXT_MAX_ENUM = 0x7fffffff,
     VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_NV = VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_EXT,
     VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_NV = VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_EXT,
-    VK_RAY_TRACING_INVOCATION_REORDER_MODE_EXT_MAX_ENUM = 0x7fffffff,
 } VkRayTracingInvocationReorderModeEXT;
 typedef VkRayTracingInvocationReorderModeEXT VkRayTracingInvocationReorderModeNV;
 
@@ -4973,10 +4973,10 @@ typedef enum VkRayTracingShaderGroupTypeKHR
     VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR = 0,
     VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR = 1,
     VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR = 2,
+    VK_RAY_TRACING_SHADER_GROUP_TYPE_KHR_MAX_ENUM = 0x7fffffff,
     VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV = VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR,
     VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV = VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR,
     VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV = VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR,
-    VK_RAY_TRACING_SHADER_GROUP_TYPE_KHR_MAX_ENUM = 0x7fffffff,
 } VkRayTracingShaderGroupTypeKHR;
 typedef VkRayTracingShaderGroupTypeKHR VkRayTracingShaderGroupTypeNV;
 
@@ -5006,11 +5006,11 @@ typedef enum VkRenderingFlagBits
     VK_RENDERING_FRAGMENT_REGION_BIT_EXT = 0x00000040,
     VK_RENDERING_CUSTOM_RESOLVE_BIT_EXT = 0x00000080,
     VK_RENDERING_LOCAL_READ_CONCURRENT_ACCESS_CONTROL_BIT_KHR = 0x00000100,
+    VK_RENDERING_FLAG_BITS_MAX_ENUM = 0x7fffffff,
     VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR = VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT,
     VK_RENDERING_SUSPENDING_BIT_KHR = VK_RENDERING_SUSPENDING_BIT,
     VK_RENDERING_RESUMING_BIT_KHR = VK_RENDERING_RESUMING_BIT,
     VK_RENDERING_CONTENTS_INLINE_BIT_EXT = VK_RENDERING_CONTENTS_INLINE_BIT_KHR,
-    VK_RENDERING_FLAG_BITS_MAX_ENUM = 0x7fffffff,
 } VkRenderingFlagBits;
 typedef VkRenderingFlagBits VkRenderingFlagBitsKHR;
 
@@ -5029,12 +5029,12 @@ typedef enum VkResolveModeFlagBits
     VK_RESOLVE_MODE_MIN_BIT = 0x00000004,
     VK_RESOLVE_MODE_MAX_BIT = 0x00000008,
     VK_RESOLVE_MODE_CUSTOM_BIT_EXT = 0x00000020,
+    VK_RESOLVE_MODE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
     VK_RESOLVE_MODE_NONE_KHR = VK_RESOLVE_MODE_NONE,
     VK_RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT,
     VK_RESOLVE_MODE_AVERAGE_BIT_KHR = VK_RESOLVE_MODE_AVERAGE_BIT,
     VK_RESOLVE_MODE_MIN_BIT_KHR = VK_RESOLVE_MODE_MIN_BIT,
     VK_RESOLVE_MODE_MAX_BIT_KHR = VK_RESOLVE_MODE_MAX_BIT,
-    VK_RESOLVE_MODE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
 } VkResolveModeFlagBits;
 typedef VkResolveModeFlagBits VkResolveModeFlagBitsKHR;
 
@@ -5087,6 +5087,7 @@ typedef enum VkResult
     VK_PIPELINE_COMPILE_REQUIRED = 1000297000,
     VK_INCOMPATIBLE_SHADER_BINARY_EXT = 1000482000,
     VK_PIPELINE_BINARY_MISSING_KHR = 1000483000,
+    VK_RESULT_MAX_ENUM = 0x7fffffff,
     VK_ERROR_VALIDATION_FAILED_EXT = VK_ERROR_VALIDATION_FAILED,
     VK_ERROR_OUT_OF_POOL_MEMORY_KHR = VK_ERROR_OUT_OF_POOL_MEMORY,
     VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR = VK_ERROR_INVALID_EXTERNAL_HANDLE,
@@ -5098,7 +5099,6 @@ typedef enum VkResult
     VK_PIPELINE_COMPILE_REQUIRED_EXT = VK_PIPELINE_COMPILE_REQUIRED,
     VK_ERROR_PIPELINE_COMPILE_REQUIRED_EXT = VK_PIPELINE_COMPILE_REQUIRED,
     VK_ERROR_INCOMPATIBLE_SHADER_BINARY_EXT = VK_INCOMPATIBLE_SHADER_BINARY_EXT,
-    VK_RESULT_MAX_ENUM = 0x7fffffff,
 } VkResult;
 
 typedef enum VkSampleCountFlagBits
@@ -5120,8 +5120,8 @@ typedef enum VkSamplerAddressMode
     VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2,
     VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3,
     VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4,
-    VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE_KHR = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE,
     VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7fffffff,
+    VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE_KHR = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE,
 } VkSamplerAddressMode;
 
 typedef enum VkSamplerCreateFlagBits
@@ -5147,10 +5147,10 @@ typedef enum VkSamplerReductionMode
     VK_SAMPLER_REDUCTION_MODE_MIN = 1,
     VK_SAMPLER_REDUCTION_MODE_MAX = 2,
     VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_RANGECLAMP_QCOM = 1000521000,
+    VK_SAMPLER_REDUCTION_MODE_MAX_ENUM = 0x7fffffff,
     VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE,
     VK_SAMPLER_REDUCTION_MODE_MIN_EXT = VK_SAMPLER_REDUCTION_MODE_MIN,
     VK_SAMPLER_REDUCTION_MODE_MAX_EXT = VK_SAMPLER_REDUCTION_MODE_MAX,
-    VK_SAMPLER_REDUCTION_MODE_MAX_ENUM = 0x7fffffff,
 } VkSamplerReductionMode;
 typedef VkSamplerReductionMode VkSamplerReductionModeEXT;
 
@@ -5161,12 +5161,12 @@ typedef enum VkSamplerYcbcrModelConversion
     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709 = 2,
     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601 = 3,
     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 = 4,
+    VK_SAMPLER_YCBCR_MODEL_CONVERSION_MAX_ENUM = 0x7fffffff,
     VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY,
     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY,
     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709,
     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601,
     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020,
-    VK_SAMPLER_YCBCR_MODEL_CONVERSION_MAX_ENUM = 0x7fffffff,
 } VkSamplerYcbcrModelConversion;
 typedef VkSamplerYcbcrModelConversion VkSamplerYcbcrModelConversionKHR;
 
@@ -5174,9 +5174,9 @@ typedef enum VkSamplerYcbcrRange
 {
     VK_SAMPLER_YCBCR_RANGE_ITU_FULL = 0,
     VK_SAMPLER_YCBCR_RANGE_ITU_NARROW = 1,
+    VK_SAMPLER_YCBCR_RANGE_MAX_ENUM = 0x7fffffff,
     VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_FULL,
     VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW,
-    VK_SAMPLER_YCBCR_RANGE_MAX_ENUM = 0x7fffffff,
 } VkSamplerYcbcrRange;
 typedef VkSamplerYcbcrRange VkSamplerYcbcrRangeKHR;
 
@@ -5186,19 +5186,19 @@ typedef enum VkScopeKHR
     VK_SCOPE_WORKGROUP_KHR = 2,
     VK_SCOPE_SUBGROUP_KHR = 3,
     VK_SCOPE_QUEUE_FAMILY_KHR = 5,
+    VK_SCOPE_KHR_MAX_ENUM = 0x7fffffff,
     VK_SCOPE_DEVICE_NV = VK_SCOPE_DEVICE_KHR,
     VK_SCOPE_WORKGROUP_NV = VK_SCOPE_WORKGROUP_KHR,
     VK_SCOPE_SUBGROUP_NV = VK_SCOPE_SUBGROUP_KHR,
     VK_SCOPE_QUEUE_FAMILY_NV = VK_SCOPE_QUEUE_FAMILY_KHR,
-    VK_SCOPE_KHR_MAX_ENUM = 0x7fffffff,
 } VkScopeKHR;
 typedef VkScopeKHR VkScopeNV;
 
 typedef enum VkSemaphoreImportFlagBits
 {
     VK_SEMAPHORE_IMPORT_TEMPORARY_BIT = 0x00000001,
-    VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT,
     VK_SEMAPHORE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7fffffff,
+    VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT,
 } VkSemaphoreImportFlagBits;
 typedef VkSemaphoreImportFlagBits VkSemaphoreImportFlagBitsKHR;
 
@@ -5206,17 +5206,17 @@ typedef enum VkSemaphoreType
 {
     VK_SEMAPHORE_TYPE_BINARY = 0,
     VK_SEMAPHORE_TYPE_TIMELINE = 1,
+    VK_SEMAPHORE_TYPE_MAX_ENUM = 0x7fffffff,
     VK_SEMAPHORE_TYPE_BINARY_KHR = VK_SEMAPHORE_TYPE_BINARY,
     VK_SEMAPHORE_TYPE_TIMELINE_KHR = VK_SEMAPHORE_TYPE_TIMELINE,
-    VK_SEMAPHORE_TYPE_MAX_ENUM = 0x7fffffff,
 } VkSemaphoreType;
 typedef VkSemaphoreType VkSemaphoreTypeKHR;
 
 typedef enum VkSemaphoreWaitFlagBits
 {
     VK_SEMAPHORE_WAIT_ANY_BIT = 0x00000001,
-    VK_SEMAPHORE_WAIT_ANY_BIT_KHR = VK_SEMAPHORE_WAIT_ANY_BIT,
     VK_SEMAPHORE_WAIT_FLAG_BITS_MAX_ENUM = 0x7fffffff,
+    VK_SEMAPHORE_WAIT_ANY_BIT_KHR = VK_SEMAPHORE_WAIT_ANY_BIT,
 } VkSemaphoreWaitFlagBits;
 typedef VkSemaphoreWaitFlagBits VkSemaphoreWaitFlagBitsKHR;
 
@@ -5251,10 +5251,10 @@ typedef enum VkShaderFloatControlsIndependence
     VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY = 0,
     VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL = 1,
     VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE = 2,
+    VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_MAX_ENUM = 0x7fffffff,
     VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY,
     VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL,
     VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE,
-    VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_MAX_ENUM = 0x7fffffff,
 } VkShaderFloatControlsIndependence;
 typedef VkShaderFloatControlsIndependence VkShaderFloatControlsIndependenceKHR;
 
@@ -5294,6 +5294,7 @@ typedef enum VkShaderStageFlagBits
     VK_SHADER_STAGE_CALLABLE_BIT_KHR = 0x00002000,
     VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI = 0x00004000,
     VK_SHADER_STAGE_CLUSTER_CULLING_BIT_HUAWEI = 0x00080000,
+    VK_SHADER_STAGE_ALL = 0x7fffffff,
     VK_SHADER_STAGE_RAYGEN_BIT_NV = VK_SHADER_STAGE_RAYGEN_BIT_KHR,
     VK_SHADER_STAGE_ANY_HIT_BIT_NV = VK_SHADER_STAGE_ANY_HIT_BIT_KHR,
     VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV = VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR,
@@ -5302,7 +5303,6 @@ typedef enum VkShaderStageFlagBits
     VK_SHADER_STAGE_CALLABLE_BIT_NV = VK_SHADER_STAGE_CALLABLE_BIT_KHR,
     VK_SHADER_STAGE_TASK_BIT_NV = VK_SHADER_STAGE_TASK_BIT_EXT,
     VK_SHADER_STAGE_MESH_BIT_NV = VK_SHADER_STAGE_MESH_BIT_EXT,
-    VK_SHADER_STAGE_ALL = 0x7fffffff,
 } VkShaderStageFlagBits;
 
 typedef enum VkShadingRatePaletteEntryNV
@@ -5348,8 +5348,8 @@ typedef enum VkStencilFaceFlagBits
     VK_STENCIL_FACE_FRONT_BIT = 0x00000001,
     VK_STENCIL_FACE_BACK_BIT = 0x00000002,
     VK_STENCIL_FACE_FRONT_AND_BACK = 0x00000003,
-    VK_STENCIL_FRONT_AND_BACK = VK_STENCIL_FACE_FRONT_AND_BACK,
     VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
+    VK_STENCIL_FRONT_AND_BACK = VK_STENCIL_FACE_FRONT_AND_BACK,
 } VkStencilFaceFlagBits;
 
 typedef enum VkStencilOp
@@ -6345,6 +6345,7 @@ typedef enum VkStructureType
     VK_STRUCTURE_TYPE_RESOLVE_IMAGE_MODE_INFO_KHR = 1000630004,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC = 1000637000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT = 1000642000,
+    VK_STRUCTURE_TYPE_MAX_ENUM = 0x7fffffff,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES,
     VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT,
@@ -6597,7 +6598,6 @@ typedef enum VkStructureType
     VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO_KHR = VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO,
     VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO_KHR = VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO,
     VK_STRUCTURE_TYPE_RENDERING_END_INFO_EXT = VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR,
-    VK_STRUCTURE_TYPE_MAX_ENUM = 0x7fffffff,
 } VkStructureType;
 
 typedef enum VkSubgroupFeatureFlagBits
@@ -6613,16 +6613,16 @@ typedef enum VkSubgroupFeatureFlagBits
     VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV = 0x00000100,
     VK_SUBGROUP_FEATURE_ROTATE_BIT = 0x00000200,
     VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT = 0x00000400,
+    VK_SUBGROUP_FEATURE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
     VK_SUBGROUP_FEATURE_ROTATE_BIT_KHR = VK_SUBGROUP_FEATURE_ROTATE_BIT,
     VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT_KHR = VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT,
-    VK_SUBGROUP_FEATURE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
 } VkSubgroupFeatureFlagBits;
 
 typedef enum VkSubmitFlagBits
 {
     VK_SUBMIT_PROTECTED_BIT = 0x00000001,
-    VK_SUBMIT_PROTECTED_BIT_KHR = VK_SUBMIT_PROTECTED_BIT,
     VK_SUBMIT_FLAG_BITS_MAX_ENUM = 0x7fffffff,
+    VK_SUBMIT_PROTECTED_BIT_KHR = VK_SUBMIT_PROTECTED_BIT,
 } VkSubmitFlagBits;
 typedef VkSubmitFlagBits VkSubmitFlagBitsKHR;
 
@@ -6631,8 +6631,8 @@ typedef enum VkSubpassContents
     VK_SUBPASS_CONTENTS_INLINE = 0,
     VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1,
     VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_KHR = 1000451000,
-    VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_EXT = VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_KHR,
     VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7fffffff,
+    VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_EXT = VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_KHR,
 } VkSubpassContents;
 
 typedef enum VkSubpassDescriptionFlagBits
@@ -6644,12 +6644,12 @@ typedef enum VkSubpassDescriptionFlagBits
     VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT = 0x00000040,
     VK_SUBPASS_DESCRIPTION_ENABLE_LEGACY_DITHERING_BIT_EXT = 0x00000080,
     VK_SUBPASS_DESCRIPTION_TILE_SHADING_APRON_BIT_QCOM = 0x00000100,
+    VK_SUBPASS_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7fffffff,
     VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM = VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_EXT,
     VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM = VK_SUBPASS_DESCRIPTION_CUSTOM_RESOLVE_BIT_EXT,
     VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_ARM = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT,
     VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT,
     VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT,
-    VK_SUBPASS_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7fffffff,
 } VkSubpassDescriptionFlagBits;
 
 typedef enum VkSubpassMergeStatusEXT
@@ -6693,8 +6693,8 @@ typedef enum VkSwapchainCreateFlagBitsKHR
     VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_KHR = 0x00000008,
     VK_SWAPCHAIN_CREATE_PRESENT_ID_2_BIT_KHR = 0x00000040,
     VK_SWAPCHAIN_CREATE_PRESENT_WAIT_2_BIT_KHR = 0x00000080,
-    VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_EXT = VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_KHR,
     VK_SWAPCHAIN_CREATE_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff,
+    VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_EXT = VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_KHR,
 } VkSwapchainCreateFlagBitsKHR;
 
 typedef enum VkSystemAllocationScope
@@ -6736,9 +6736,9 @@ typedef enum VkTessellationDomainOrigin
 {
     VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT = 0,
     VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT = 1,
+    VK_TESSELLATION_DOMAIN_ORIGIN_MAX_ENUM = 0x7fffffff,
     VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT,
     VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT,
-    VK_TESSELLATION_DOMAIN_ORIGIN_MAX_ENUM = 0x7fffffff,
 } VkTessellationDomainOrigin;
 typedef VkTessellationDomainOrigin VkTessellationDomainOriginKHR;
 
@@ -6755,11 +6755,11 @@ typedef enum VkTimeDomainKHR
     VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR = 1,
     VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR = 2,
     VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR = 3,
+    VK_TIME_DOMAIN_KHR_MAX_ENUM = 0x7fffffff,
     VK_TIME_DOMAIN_DEVICE_EXT = VK_TIME_DOMAIN_DEVICE_KHR,
     VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT = VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR,
     VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT = VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR,
     VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT = VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR,
-    VK_TIME_DOMAIN_KHR_MAX_ENUM = 0x7fffffff,
 } VkTimeDomainKHR;
 typedef VkTimeDomainKHR VkTimeDomainEXT;
 
@@ -6772,12 +6772,12 @@ typedef enum VkToolPurposeFlagBits
     VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT = 0x00000010,
     VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT = 0x00000020,
     VK_TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT = 0x00000040,
+    VK_TOOL_PURPOSE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
     VK_TOOL_PURPOSE_VALIDATION_BIT_EXT = VK_TOOL_PURPOSE_VALIDATION_BIT,
     VK_TOOL_PURPOSE_PROFILING_BIT_EXT = VK_TOOL_PURPOSE_PROFILING_BIT,
     VK_TOOL_PURPOSE_TRACING_BIT_EXT = VK_TOOL_PURPOSE_TRACING_BIT,
     VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT_EXT = VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT,
     VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT_EXT = VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT,
-    VK_TOOL_PURPOSE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
 } VkToolPurposeFlagBits;
 typedef VkToolPurposeFlagBits VkToolPurposeFlagBitsEXT;
 
-- 
GitLab


https://gitlab.winehq.org/wine/wine/-/merge_requests/9586

[PATCH 3/6] winevulkan: Split get_dyn_array_len into params / member classes.

[Rémi Bernon]

From: Rémi Bernon <rbernon(a)codeweavers.com>

---
 dlls/winevulkan/make_vulkan | 104 +++++++++++++++++++-----------------
 1 file changed, 54 insertions(+), 50 deletions(-)

diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan
index 20970482063..72bbe822978 100755
--- a/dlls/winevulkan/make_vulkan
+++ b/dlls/winevulkan/make_vulkan
@@ -316,21 +316,19 @@ STRUCT_CHAIN_CONVERSIONS = {
 # Some struct members are conditionally ignored and callers are free to leave them uninitialized.
 # We can't deduce that from XML, so we allow expressing it here.
 MEMBER_LENGTH_EXPRESSIONS = {
-    "VkWriteDescriptorSet": {
-        "pImageInfo":
-            "{struct}descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER || " +
-            "{struct}descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER || " +
-            "{struct}descriptorType == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE || " +
-            "{struct}descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE || " +
-            "{struct}descriptorType == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT || " +
-            "{struct}descriptorType == VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM || " +
-            "{struct}descriptorType == VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM ? {len} : 0",
-        "pBufferInfo":
-            "{struct}descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER || " +
-            "{struct}descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER || " +
-            "{struct}descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC || " +
-            "{struct}descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC ? {len} : 0",
-    }
+    ("VkWriteDescriptorSet", "pImageInfo"):
+            "{prefix}descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER || " +
+            "{prefix}descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER || " +
+            "{prefix}descriptorType == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE || " +
+            "{prefix}descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE || " +
+            "{prefix}descriptorType == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT || " +
+            "{prefix}descriptorType == VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM || " +
+            "{prefix}descriptorType == VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM ? {length} : 0",
+    ("VkWriteDescriptorSet", "pBufferInfo"):
+            "{prefix}descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER || " +
+            "{prefix}descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER || " +
+            "{prefix}descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC || " +
+            "{prefix}descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC ? {length} : 0",
 }
 
 class Direction(Enum):
@@ -1097,37 +1095,6 @@ class VkVariable(object):
         self.handle = type_info["data"] if type_info["category"] == "handle" else None
         self.struct = type_info["data"] if type_info["category"] == "struct" or type_info["category"] == "union" else None
 
-    def get_dyn_array_len(self, prefix, conv):
-        if isinstance(self.dyn_array_len, int):
-            return self.dyn_array_len
-
-        len_str = self.dyn_array_len
-        parent = self.parent
-        len = prefix
-
-        # check if length is a member of another struct (for example pAllocateInfo->commandBufferCount)
-        i = len_str.find("->")
-        if i != -1:
-            var = parent[parent.index(len_str[0:i])]
-            len_str = len_str[i+2:]
-            len = "({0})->".format(var.value(len, conv))
-            parent = var.struct
-
-        if len_str in parent:
-            var = parent[parent.index(len_str)]
-            len = var.value(len, conv);
-            if var.is_pointer():
-                len = "*" + len
-        else:
-            len += len_str
-
-        if isinstance(self.parent, VkStruct) and self.parent.name in MEMBER_LENGTH_EXPRESSIONS:
-            exprs = MEMBER_LENGTH_EXPRESSIONS[self.parent.name]
-            if self.name in exprs:
-                len = exprs[self.name].format(struct=prefix, len=len)
-
-        return len
-
     def is_const(self):
         return self.const
 
@@ -1233,9 +1200,7 @@ class VkVariable(object):
 
         return self.is_pointer() or self.is_pointer_size() or self.is_static_array()
 
-    def value(self, prefix, conv):
-        """ Returns code accessing member value, casting 32-bit pointers when needed. """
-
+    def value(self, prefix, conv, deref=False):
         if not conv or not self.needs_ptr32_type() or (not self.is_pointer() and self.type == "size_t"):
             return prefix + self.name
 
@@ -1255,7 +1220,14 @@ class VkVariable(object):
             elif self.is_static_array():
                 cast_type += " *"
 
-        return "({0})UlongToPtr({1}{2})".format(cast_type, prefix, self.name)
+        if self.is_pointer():
+            ptr = self.pointer if deref else ""
+        elif self.is_static_array():
+            ptr = "*" if deref else ""
+        else:
+            ptr = ""
+
+        return f"{ptr}({cast_type})UlongToPtr({prefix}{self.name})"
 
 
 class VkMember(VkVariable):
@@ -1337,6 +1309,19 @@ class VkMember(VkVariable):
                         values=values, object_type=object_type, bit_width=bit_width, returnedonly=returnedonly,
                         parent=parent, selection=selection, selector=selector)
 
+    def get_dyn_array_len(self, prefix, conv):
+        if isinstance(self.dyn_array_len, int):
+            return self.dyn_array_len
+
+        length = self.dyn_array_len
+        parent = self.parent
+
+        var = parent[parent.index(length)]
+        length = var.value(prefix, conv, deref=True)
+
+        expr = MEMBER_LENGTH_EXPRESSIONS.get((parent.name, self.name), "{length}")
+        return expr.format(prefix=prefix, length=length)
+
     def copy(self, input, output, direction, conv, unwrap, parent_const, conversions):
         """ Helper method for use by conversion logic to generate a C-code statement to copy this member.
             - `conv` indicates whether the statement is in a struct alignment conversion path. """
@@ -1597,6 +1582,25 @@ class VkParam(VkVariable):
             else:
                 LOGGER.warn("Unhandled type: {0}".format(self.type_info))
 
+    def get_dyn_array_len(self, prefix, conv):
+        if isinstance(self.dyn_array_len, int):
+            return self.dyn_array_len
+
+        length = self.dyn_array_len
+        params = self.parent
+
+        if "->" in length:
+            # length is a member of another struct (for example pAllocateInfo->commandBufferCount)
+            (param, length) = length.split("->")
+            var = params[params.index(param)]
+            prefix = var.value(prefix, conv)
+
+            var = var.struct[var.struct.index(length)]
+            return var.value(f"({prefix})->", conv, deref=True)
+
+        var = params[params.index(length)]
+        return var.value(prefix, conv, deref=True)
+
     def copy(self, direction, conv, unwrap, conversions, prefix=""):
         win_type = "win32" if conv else "win64"
         suffix = convert_suffix(direction, win_type, unwrap, self.is_wrapped())
-- 
GitLab


https://gitlab.winehq.org/wine/wine/-/merge_requests/9586

[PATCH 4/6] winevulkan: Pass parent / params to get_dyn_array_len directly.

[Rémi Bernon]

From: Rémi Bernon <rbernon(a)codeweavers.com>

---
 dlls/winevulkan/make_vulkan | 52 ++++++++++++++++---------------------
 1 file changed, 23 insertions(+), 29 deletions(-)

diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan
index 72bbe822978..932db2d9a83 100755
--- a/dlls/winevulkan/make_vulkan
+++ b/dlls/winevulkan/make_vulkan
@@ -584,7 +584,7 @@ class VkFunction(object):
 
         params = []
         for param in filter(is_api_supported, command.findall("param")):
-            vk_param = VkParam.from_xml(registry, param, types, params)
+            vk_param = VkParam.from_xml(registry, param, types)
             params.append(vk_param)
 
         return VkFunction(_type=func_type, name=func_name, params=params)
@@ -777,10 +777,10 @@ class VkFunction(object):
         unwrap = self.name not in MANUAL_UNIX_THUNKS
         for p in self.params:
             if p.needs_conversion(conv, self.unwrap, Direction.INPUT):
-                body += p.copy(Direction.INPUT, conv, self.unwrap, conversions, prefix=params_prefix)
+                body += p.copy(Direction.INPUT, conv, self.unwrap, conversions, self.params, prefix=params_prefix)
             elif p.is_dynamic_array() and p.needs_conversion(conv, self.unwrap, Direction.OUTPUT):
                 body += "    {0}_host = ({2}{0} && {1}) ? conversion_context_alloc(ctx, sizeof(*{0}_host) * {1}) : NULL;\n".format(
-                    p.name, p.get_dyn_array_len(params_prefix, conv), params_prefix)
+                    p.name, p.get_dyn_array_len(self.params, params_prefix, conv), params_prefix)
 
         # Build list of parameters containing converted and non-converted parameters.
         # The param itself knows if conversion is needed and applies it when we set conv=True.
@@ -808,7 +808,7 @@ class VkFunction(object):
         # Call any host_to_win conversion calls.
         for p in self.params:
             if p.needs_conversion(conv, self.unwrap, Direction.OUTPUT):
-                body += p.copy(Direction.OUTPUT, conv, self.unwrap, conversions, prefix=params_prefix)
+                body += p.copy(Direction.OUTPUT, conv, self.unwrap, conversions, self.params, prefix=params_prefix)
 
         if needs_alloc:
             if deferred_op is not None:
@@ -1056,13 +1056,12 @@ class VkHandle(object):
 
 class VkVariable(object):
     def __init__(self, const=False, type_info=None, type=None, name=None, pointer=None, array_lens=[],
-                 dyn_array_len=None, object_type=None, optional=False, returnedonly=False, parent=None,
+                 dyn_array_len=None, object_type=None, optional=False, returnedonly=False,
                  selection=None, selector=None):
         self.const = const
         self.type_info = type_info
         self.type = type
         self.name = name
-        self.parent = parent
         self.object_type = object_type
         self.optional = optional
         self.returnedonly = returnedonly
@@ -1233,10 +1232,10 @@ class VkVariable(object):
 class VkMember(VkVariable):
     def __init__(self, const=False, struct_fwd_decl=False,_type=None, pointer=None, name=None, array_lens=[],
                  dyn_array_len=None, optional=False, values=None, object_type=None, bit_width=None,
-                 returnedonly=False, parent=None, selection=None, selector=None):
+                 returnedonly=False, selection=None, selector=None):
         VkVariable.__init__(self, const=const, type=_type, name=name, pointer=pointer, array_lens=array_lens,
                             dyn_array_len=dyn_array_len, object_type=object_type, optional=optional,
-                            returnedonly=returnedonly, parent=parent, selection=selection, selector=selector)
+                            returnedonly=returnedonly, selection=selection, selector=selector)
         self.struct_fwd_decl = struct_fwd_decl
         self.values = values
         self.bit_width = bit_width
@@ -1246,7 +1245,7 @@ class VkMember(VkVariable):
                 self.name, self.array_lens, self.dyn_array_len)
 
     @staticmethod
-    def from_xml(registry, member, returnedonly, parent):
+    def from_xml(registry, member, returnedonly):
         """ Helper function for parsing a member tag within a struct or union. """
         name_elem = member.find("name")
         type_elem = member.find("type")
@@ -1307,14 +1306,12 @@ class VkMember(VkVariable):
         return VkMember(const=const, struct_fwd_decl=struct_fwd_decl, _type=member_type, pointer=pointer,
                         name=name_elem.text, array_lens=array_lens, dyn_array_len=dyn_array_len, optional=optional,
                         values=values, object_type=object_type, bit_width=bit_width, returnedonly=returnedonly,
-                        parent=parent, selection=selection, selector=selector)
+                        selection=selection, selector=selector)
 
-    def get_dyn_array_len(self, prefix, conv):
+    def get_dyn_array_len(self, parent, prefix, conv):
         if isinstance(self.dyn_array_len, int):
             return self.dyn_array_len
-
         length = self.dyn_array_len
-        parent = self.parent
 
         var = parent[parent.index(length)]
         length = var.value(prefix, conv, deref=True)
@@ -1322,7 +1319,7 @@ class VkMember(VkVariable):
         expr = MEMBER_LENGTH_EXPRESSIONS.get((parent.name, self.name), "{length}")
         return expr.format(prefix=prefix, length=length)
 
-    def copy(self, input, output, direction, conv, unwrap, parent_const, conversions):
+    def copy(self, input, output, direction, conv, unwrap, parent_const, conversions, parent):
         """ Helper method for use by conversion logic to generate a C-code statement to copy this member.
             - `conv` indicates whether the statement is in a struct alignment conversion path. """
 
@@ -1333,7 +1330,7 @@ class VkMember(VkVariable):
         if self.needs_conversion(conv, unwrap, direction, False):
             if self.is_dynamic_array():
                 # Array length is either a variable name (string) or an int.
-                count = self.get_dyn_array_len(input, conv)
+                count = self.get_dyn_array_len(parent, input, conv)
                 pointer_part = "pointer_" if self.pointer_array else ""
                 conversions.append(ArrayConversionFunction(self, direction, conv, unwrap))
                 if direction == Direction.OUTPUT:
@@ -1486,11 +1483,11 @@ class VkMember(VkVariable):
 class VkParam(VkVariable):
     """ Helper class which describes a parameter to a function call. """
 
-    def __init__(self, type_info, const=None, pointer=None, name=None, parent=None, array_lens=None,
+    def __init__(self, type_info, const=None, pointer=None, name=None, array_lens=None,
                  dyn_array_len=None, object_type=None, optional=False):
         VkVariable.__init__(self, const=const, type_info=type_info, type=type_info["name"], name=name,
                             pointer=pointer, array_lens=array_lens, dyn_array_len=dyn_array_len,
-                            object_type=object_type, optional=optional, parent=parent)
+                            object_type=object_type, optional=optional)
 
         self._set_format_string()
 
@@ -1498,7 +1495,7 @@ class VkParam(VkVariable):
         return "{0} {1} {2} {3} {4} {5}".format(self.const, self.type, self.pointer, self.name, self.array_lens, self.dyn_array_len)
 
     @staticmethod
-    def from_xml(registry, param, types, parent):
+    def from_xml(registry, param, types):
         # Parameter parsing is slightly tricky. All the data is contained within
         # a param tag, but some data is within subtags while others are text
         # before or after the type tag.
@@ -1531,8 +1528,7 @@ class VkParam(VkVariable):
             LOGGER.error("type info not found for: {0}".format(type_elem.text))
 
         return VkParam(type_info, const=const, pointer=pointer, name=name, array_lens=array_lens,
-                       dyn_array_len=dyn_array_len, object_type=object_type, optional=optional,
-                       parent=parent)
+                       dyn_array_len=dyn_array_len, object_type=object_type, optional=optional)
 
     def _set_format_string(self):
         """ Internal helper function to be used by constructor to set format string. """
@@ -1582,12 +1578,10 @@ class VkParam(VkVariable):
             else:
                 LOGGER.warn("Unhandled type: {0}".format(self.type_info))
 
-    def get_dyn_array_len(self, prefix, conv):
+    def get_dyn_array_len(self, params, prefix, conv):
         if isinstance(self.dyn_array_len, int):
             return self.dyn_array_len
-
         length = self.dyn_array_len
-        params = self.parent
 
         if "->" in length:
             # length is a member of another struct (for example pAllocateInfo->commandBufferCount)
@@ -1601,7 +1595,7 @@ class VkParam(VkVariable):
         var = params[params.index(length)]
         return var.value(prefix, conv, deref=True)
 
-    def copy(self, direction, conv, unwrap, conversions, prefix=""):
+    def copy(self, direction, conv, unwrap, conversions, params, prefix=""):
         win_type = "win32" if conv else "win64"
         suffix = convert_suffix(direction, win_type, unwrap, self.is_wrapped())
         is_const = self.is_const() if self.is_pointer() else False
@@ -1611,7 +1605,7 @@ class VkParam(VkVariable):
             if self.is_dynamic_array():
                 conversions.append(ArrayConversionFunction(self, direction, conv, unwrap))
                 return "    {0}_host = convert_{2}_array_{4}({5}{1}, {3});\n".format(self.name, self.value(prefix, conv),
-                    self.type, self.get_dyn_array_len(prefix, conv), suffix, ctx_param)
+                    self.type, self.get_dyn_array_len(params, prefix, conv), suffix, ctx_param)
             elif self.optional:
                 conversions.append(StructConversionFunction(self.struct, direction, conv, unwrap, is_const))
                 ret  = "    if ({0}{1})\n".format(prefix, self.name)
@@ -1634,7 +1628,7 @@ class VkParam(VkVariable):
                 conversions.append(ArrayConversionFunction(self, direction, conv, unwrap))
                 return "    convert_{0}_array_{1}({2}_host, {3}, {4});\n".format(
                     self.type, suffix, self.name, self.value(prefix, conv).replace('const ', ''),
-                    self.get_dyn_array_len(prefix, conv))
+                    self.get_dyn_array_len(params, prefix, conv))
             elif self.is_struct():
                 ref_part = "" if self.optional else "&"
                 conversions.append(StructConversionFunction(self.struct, direction, conv, unwrap, is_const))
@@ -1862,7 +1856,7 @@ class VkStruct(Sequence):
 
         s = VkStruct(registry, name, [], returnedonly, structextends, union=union)
         for member in filter(is_api_supported, struct.findall("member")):
-            vk_member = VkMember.from_xml(registry, member, returnedonly, s)
+            vk_member = VkMember.from_xml(registry, member, returnedonly)
             s.members.append(vk_member)
 
         return s
@@ -2207,7 +2201,7 @@ class StructConversionFunction(object):
                 body += " || ".join("selector == {}".format(s) for s in m.selection)
                 body += ")\n    "
 
-            body += "    " + m.copy("in->", "out->", self.direction, self.conv, self.unwrap, self.const, conversions)
+            body += "    " + m.copy("in->", "out->", self.direction, self.conv, self.unwrap, self.const, conversions, self.operand)
 
         if needs_extensions:
             if self.conv and self.direction == Direction.INPUT:
@@ -2262,7 +2256,7 @@ class StructConversionFunction(object):
                     if m.name == "pNext":
                         copy_body += ident + "out_ext->pNext = NULL;\n"
                         continue
-                    copy_body += ident + m.copy("in_ext->", "out_ext->", self.direction, self.conv, Unwrap.HOST, self.const, conversions)
+                    copy_body += ident + m.copy("in_ext->", "out_ext->", self.direction, self.conv, Unwrap.HOST, self.const, conversions, ext)
 
                 # Generate the definition of "in_ext" if we need it
                 if "in_ext->" in copy_body:
-- 
GitLab


https://gitlab.winehq.org/wine/wine/-/merge_requests/9586

[PATCH 5/6] winevulkan: Create function param and struct member lists beforehand.

[Rémi Bernon]

From: Rémi Bernon <rbernon(a)codeweavers.com>

---
 dlls/winevulkan/make_vulkan | 25 ++++++++-----------------
 1 file changed, 8 insertions(+), 17 deletions(-)

diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan
index 932db2d9a83..fef3ce413db 100755
--- a/dlls/winevulkan/make_vulkan
+++ b/dlls/winevulkan/make_vulkan
@@ -547,7 +547,7 @@ class EnumValue(object):
 
 
 class VkFunction(object):
-    def __init__(self, _type=None, name=None, params=[], alias=None):
+    def __init__(self, _type, name, params, alias=None):
         self.extensions = set()
         self.name = name
         self.type = _type
@@ -571,10 +571,7 @@ class VkFunction(object):
     @staticmethod
     def from_alias(registry, command, alias):
         func_name = command.attrib.get("name")
-        func_type = alias.type
-        params = alias.params
-
-        return VkFunction(_type=func_type, name=func_name, params=params, alias=alias)
+        return VkFunction(alias.type, func_name, alias.params, alias=alias)
 
     @staticmethod
     def from_xml(registry, command, types):
@@ -582,12 +579,9 @@ class VkFunction(object):
         func_name = proto.find("name").text
         func_type = proto.find("type").text
 
-        params = []
-        for param in filter(is_api_supported, command.findall("param")):
-            vk_param = VkParam.from_xml(registry, param, types)
-            params.append(vk_param)
-
-        return VkFunction(_type=func_type, name=func_name, params=params)
+        params = filter(is_api_supported, command.findall("param"))
+        params = [VkParam.from_xml(registry, param, types) for param in params]
+        return VkFunction(func_type, func_name, params)
 
     def is_alias(self):
         return bool(self.alias)
@@ -1854,12 +1848,9 @@ class VkStruct(Sequence):
         structextends = struct.attrib.get("structextends")
         structextends = structextends.split(",") if structextends else []
 
-        s = VkStruct(registry, name, [], returnedonly, structextends, union=union)
-        for member in filter(is_api_supported, struct.findall("member")):
-            vk_member = VkMember.from_xml(registry, member, returnedonly)
-            s.members.append(vk_member)
-
-        return s
+        members = filter(is_api_supported, struct.findall("member"))
+        members = [VkMember.from_xml(registry, member, returnedonly) for member in members]
+        return VkStruct(registry, name, members, returnedonly, structextends, union=union)
 
     def set_order(self, order, structs):
         if order < self.order:
-- 
GitLab


https://gitlab.winehq.org/wine/wine/-/merge_requests/9586

[PATCH 6/6] winevulkan: Precompute struct type constant from member list.

[Rémi Bernon]

From: Rémi Bernon <rbernon(a)codeweavers.com>

---
 dlls/winevulkan/make_vulkan | 29 ++++++++++++++---------------
 1 file changed, 14 insertions(+), 15 deletions(-)

diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan
index fef3ce413db..b734937a749 100755
--- a/dlls/winevulkan/make_vulkan
+++ b/dlls/winevulkan/make_vulkan
@@ -1810,6 +1810,10 @@ class VkStruct(Sequence):
         self.aliased_by = []
         self.order = 0
 
+        # struct type is the (only one possible) value of the sType member, if present
+        member = next((x for x in self.members if x.name == "sType"), None)
+        self.struct_type = member.values if member else None
+
     def __getitem__(self, i):
         return self.members[i]
 
@@ -2218,7 +2222,6 @@ class StructConversionFunction(object):
                 if self.direction == Direction.OUTPUT and not any([self.member_needs_copy(ext, m) for m in ext]):
                     continue
 
-                stype = next(x for x in ext.members if x.name == "sType").values
                 win_type = ext.name + "32" if self.conv and ext.needs_win32_type() else ext.name
                 if self.direction == Direction.INPUT:
                     in_type = "const " + win_type
@@ -2227,32 +2230,28 @@ class StructConversionFunction(object):
                     in_type = "const " + ext.name
                     out_type = win_type
 
-                body += "        case {0}:\n".format(stype)
-                body += "        {\n"
+                body += f"        case {ext.struct_type}:\n"
+                body += u"        {\n"
                 if self.direction == Direction.INPUT:
-                    body += ident + "{0} *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));\n".format(out_type)
+                    body += f"            {out_type} *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));\n"
                 elif self.conv:
-                    body += ident + "{0} *out_ext = find_next_struct32(out_header, {1});\n".format(out_type, stype)
+                    body += f"            {out_type} *out_ext = find_next_struct32(out_header, {ext.struct_type});\n"
                 else:
-                    body += ident + "{0} *out_ext = find_next_struct(out_header, {1});\n".format(out_type, stype)
+                    body += f"            {out_type} *out_ext = find_next_struct(out_header, {ext.struct_type});\n"
 
-                copy_body = ""
+                if any(self.member_needs_copy(ext, m) for m in ext if m.name not in ("sType", "pNext")):
+                    body += f"            {in_type} *in_ext = ({in_type} *)in_header;\n"
 
                 for m in ext:
                     if m.name == "sType":
-                        copy_body += ident + "out_ext->sType = {0};\n".format(stype)
+                        body += f"            out_ext->sType = {ext.struct_type};\n"
                         continue
                     if not self.member_needs_copy(ext, m):
                         continue
                     if m.name == "pNext":
-                        copy_body += ident + "out_ext->pNext = NULL;\n"
+                        body += u"            out_ext->pNext = NULL;\n"
                         continue
-                    copy_body += ident + m.copy("in_ext->", "out_ext->", self.direction, self.conv, Unwrap.HOST, self.const, conversions, ext)
-
-                # Generate the definition of "in_ext" if we need it
-                if "in_ext->" in copy_body:
-                    body += ident + "{0} *in_ext = ({0} *)in_header;\n".format(in_type)
-                body += copy_body
+                    body += ident + m.copy("in_ext->", "out_ext->", self.direction, self.conv, Unwrap.HOST, self.const, conversions, ext)
 
                 if self.direction == Direction.INPUT:
                     body += ident + "out_header->pNext = (void *)out_ext;\n"
-- 
GitLab

https://gitlab.winehq.org/wine/wine/-/merge_requests/9586