winevulkan: Convert struct chain conversions for all structs that need it.

dlls/winevulkan/make_vulkan

@@ -1208,15 +1208,6 @@ class VkVariable(object):
         required.
         """
 
-        if self.is_struct():
-            self.struct.needs_struct_extensions_conversion()
-            for m in self.struct:
-                if m.type == self.struct.name:
-                    continue
-                m.needs_struct_extensions_conversion()
-        elif not self.is_handle():
-            return []
-
         conversions = []
 
         # Collect any member conversions first, so we can guarantee
@@ -1465,13 +1456,6 @@ class VkMember(VkVariable):
 
         return False
 
-    def needs_struct_extensions_conversion(self):
-        if not self.is_struct():
-            return False
-
-        struct = self.type_info["data"]
-        return struct.needs_struct_extensions_conversion()
-
 class VkParam(VkVariable):
     """ Helper class which describes a parameter to a function call. """
 
@@ -1782,6 +1766,12 @@ class VkStruct(Sequence):
         # marked as 'returnedonly'.
         returnedonly = True if struct.attrib.get("returnedonly") else False
 
+        # Those structs seem to be broken in spec, they are specified as
+        # returned only, but documented as input structs.
+        if name in ["VkSubpassShadingPipelineCreateInfoHUAWEI",
+                    "VkPipelineShaderStageRequiredSubgroupSizeCreateInfo"]:
+            returnedonly = False
+
         structextends = struct.attrib.get("structextends")
         structextends = structextends.split(",") if structextends else []
 
@@ -1915,15 +1905,58 @@ class VkStruct(Sequence):
                 return True
         return False
 
-    def needs_conversion(self, conv, unwrap, direction, is_const):
+    def needs_extensions_conversion(self, conv, direction):
+        """ Check if struct contains extensions chain that needs to be converted """
+
+        if direction == Direction.INPUT and self.name in STRUCT_CHAIN_CONVERSIONS:
+            return True
+
+        if not "pNext" in self:
+            return False
+        is_const = self.members[self.members.index("pNext")].is_const()
+        # VkOpticalFlowSessionCreateInfoNV is missing const in its pNext pointer
+        if self.name == "VkOpticalFlowSessionCreateInfoNV":
+            is_const = True
+        needs_output_copy = False
+
+        for e in self.struct_extensions:
+            if not e.required:
+                continue
+            if e.needs_conversion(conv, True, direction, is_const, check_extensions=False):
+                return True
+            if direction == Direction.INPUT:
+                # we need input conversion of structs containing struct chain even if it's returnedonly,
+                # so that we have a chance to allocate buffers
+                if e.needs_conversion(conv, True, Direction.OUTPUT, is_const, check_extensions=False):
+                    return True
+            elif not needs_output_copy and not is_const:
+                for m in e:
+                    if m.name in ["sType", "pNext"]:
+                        continue
+                    # pointers will be handled by needs_conversion, but if we have any other non-const
+                    # member, we may need to copy output
+                    if not m.is_pointer() and not m.is_const():
+                        needs_output_copy = True
+                        break
+
+        # if output needs any copy and we need input conversion, then we also need output conversion
+        if needs_output_copy and self.needs_extensions_conversion(conv, Direction.INPUT):
+            return True
+        return False
+
+    def needs_conversion(self, conv, unwrap, direction, is_const, check_extensions=True):
         """ Check if struct needs conversion. """
 
         # VkAllocationCallbacks never needs conversion
         if self.name == "VkAllocationCallbacks":
             return False
 
-        if direction == Direction.INPUT and self.name in STRUCT_CHAIN_CONVERSIONS:
-            return True
+        # FIXME: needs pointer array support
+        if self.name == "VkAccelerationStructureGeometryKHR":
+            return False
+        # FIXME: get rid of private thunks conversion
+        if self.name == "VkPipelineCreationFeedback":
+            return False
 
         # pFixedRateFlags field is missing const, but it doesn't need output conversion
         if direction == Direction.OUTPUT and self.name == "VkImageCompressionControlEXT":
@@ -1958,12 +1991,12 @@ class VkStruct(Sequence):
             if m.needs_conversion(conv, unwrap, direction, is_const):
                 return True
 
-        return False
+        return check_extensions and self.needs_extensions_conversion(conv, direction)
 
     def needs_alloc(self, conv, unwrap):
         """ Check if any struct member needs some memory allocation."""
 
-        if self.name in STRUCT_CHAIN_CONVERSIONS:
+        if self.needs_extensions_conversion(conv, Direction.INPUT):
             return True
 
         for m in self.members:
@@ -1975,6 +2008,10 @@ class VkStruct(Sequence):
         return False
 
     def needs_host_type(self):
+        # FIXME: get rid of private thunks conversion
+        if self.name == "VkPipelineCreationFeedback":
+            return False
+
         for m in self.members:
             if self.name == m.type:
                 continue
@@ -1983,20 +2020,6 @@ class VkStruct(Sequence):
             if m.is_struct() and m.struct.needs_host_type():
                 return True
 
-    def needs_struct_extensions_conversion(self):
-        """ Checks if structure extensions in pNext chain need conversion. """
-        ret = False
-
-        for e in self.struct_extensions:
-            if e.required and e.needs_conversion(True, True, Direction.INPUT, False):
-                LOGGER.error("Unhandled pNext chain alignment conversion for {0}".format(e.name))
-                ret = True
-            if e.required and e.needs_unwrapping():
-                LOGGER.error("Unhandled pNext chain unwrapping conversion for {0}".format(e.name))
-                ret = True
-
-        return ret
-
     def set_type_info(self, types):
         """ Helper function to set type information from the type registry.
         This is needed, because not all type data is available at time of
@@ -2009,12 +2032,11 @@ class VkStruct(Sequence):
     def get_conversions(self, unwrap, parent_const):
         conversions = []
 
-        if self.name in STRUCT_CHAIN_CONVERSIONS:
-            # Collect any conversion for any extension structs.
-            for e in self.struct_extensions:
-                if not e.required:
-                    continue
-                conversions.extend(e.get_conversions(True, parent_const))
+        # Collect any conversion for any extension structs.
+        for e in self.struct_extensions:
+            if not e.required:
+                continue
+            conversions.extend(e.get_conversions(True, parent_const))
 
         # Collect any conversion for any member structs.
         for m in self:
@@ -2108,8 +2130,9 @@ class StructConversionFunction(object):
             body += ", ".join(p for p in params)
             body += ")\n"
 
+        needs_extensions = self.operand.needs_extensions_conversion(self.conv, self.direction)
+
         body += "{\n"
-        needs_extensions = self.type in STRUCT_CHAIN_CONVERSIONS
         if needs_extensions:
             body += "    const VkBaseInStructure *in_header;\n"
             body += "    VkBaseOutStructure *out_header = (void *)out;\n\n"
@@ -2126,17 +2149,14 @@ class StructConversionFunction(object):
             body += "    " + m.copy("in->", "out->", self.direction, self.conv, self.unwrap)
 
         if needs_extensions:
-            if self.conv and self.direction == Direction.INPUT:
-                body += "\n    for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))\n"
-            else:
-                body += "\n    for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)\n"
+            body += "\n    for (in_header = in->pNext; in_header; in_header = in_header->pNext)\n"
             body += "    {\n"
             body += "        switch (in_header->sType)\n"
             body += "        {\n"
 
             ident = "            "
 
-            if self.type in STRUCT_CHAIN_CONVERSIONS:
+            if self.direction == Direction.INPUT and self.type in STRUCT_CHAIN_CONVERSIONS:
                 for i in STRUCT_CHAIN_CONVERSIONS[self.type]:
                     body += "        case {0}:\n".format(i)
                 body += ident + "break;\n"
@@ -2145,14 +2165,17 @@ class StructConversionFunction(object):
                 if not ext.required:
                     continue
 
+                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
-                host_type = ext.name + "_host" if self.conv and self.operand.needs_host_type() else ext.name
+                host_type = ext.name + "_host" if self.conv and ext.needs_host_type() else ext.name
                 if self.direction == Direction.INPUT:
                     in_type = "const " + ext.name
                     out_type = host_type
                 else:
                     in_type = "const " + host_type
-                    out_type = ext_name
+                    out_type = ext.name
 
                 body += "        case {0}:\n".format(stype)
                 body += "        {\n"
@@ -2259,6 +2282,9 @@ class ArrayConversionFunction(object):
             params = ["const {0} *in".format(self.type), "uint32_t count"]
             return_type = self.type
 
+        needs_copy = not self.array.is_struct() or self.direction != Direction.INPUT or \
+            not self.array.struct.returnedonly or "pNext" in self.array.struct
+
         # Generate function prototype.
         if return_type:
             body += "static inline {0} *{1}(".format(return_type, self.name)
@@ -2271,8 +2297,8 @@ class ArrayConversionFunction(object):
 
         if return_type:
             body += "    {0} *out;\n".format(return_type)
-
-        body += "    unsigned int i;\n\n"
+        if needs_copy:
+            body += "    unsigned int i;\n\n"
 
         if return_type:
             body += "    if (!in || !count) return NULL;\n\n"
@@ -2282,31 +2308,33 @@ class ArrayConversionFunction(object):
         if self.direction == Direction.INPUT:
             body += "    out = conversion_context_alloc(ctx, count * sizeof(*out));\n"
 
-        body += "    for (i = 0; i < count; i++)\n"
-        body += "    {\n"
+        if needs_copy:
+            body += "    for (i = 0; i < count; i++)\n"
+            body += "    {\n"
 
-        if self.array.is_struct():
-            struct = self.array.struct
-            win_part = "win32" if self.conv else "win64"
-            host_part = "host" if self.unwrap else "unwrapped_host"
-            if self.direction == Direction.INPUT:
-                conv_suffix = "{0}_to_{1}".format(win_part, host_part)
+            if self.array.is_struct():
+                struct = self.array.struct
+                win_part = "win32" if self.conv else "win64"
+                host_part = "host" if self.unwrap else "unwrapped_host"
+                if self.direction == Direction.INPUT:
+                    conv_suffix = "{0}_to_{1}".format(win_part, host_part)
+                else:
+                    conv_suffix = "{0}_to_{1}".format(host_part, win_part)
+
+                ctx_part = ""
+                if self.direction == Direction.INPUT and struct.needs_alloc(self.conv, self.unwrap):
+                    ctx_part = "ctx, "
+
+                body += "        convert_{0}_{1}({2}&in[i], &out[i]);\n".format(
+                    struct.name, conv_suffix, ctx_part)
+            elif self.array.is_handle() and self.direction == Direction.INPUT:
+                body += "        out[i] = " + self.array.handle.driver_handle("in[i]") + ";\n"
             else:
-                conv_suffix = "{0}_to_{1}".format(host_part, win_part)
+                LOGGER.warning("Unhandled conversion operand type")
+                body += "        out[i] = in[i];\n"
 
-            ctx_part = ""
-            if self.direction == Direction.INPUT and struct.needs_alloc(self.conv, self.unwrap):
-                ctx_part = "ctx, "
+            body += "    }\n"
 
-            body += "        convert_{0}_{1}({2}&in[i], &out[i]);\n".format(
-                struct.name, conv_suffix, ctx_part)
-        elif self.array.is_handle() and self.direction == Direction.INPUT:
-            body += "        out[i] = " + self.array.handle.driver_handle("in[i]") + ";\n"
-        else:
-            LOGGER.warning("Unhandled conversion operand type")
-            body += "        out[i] = in[i];\n"
-
-        body += "    }\n"
         if return_type:
             body += "\n    return out;\n"
         body += "}\n"
@@ -2335,7 +2363,16 @@ class VkGenerator(object):
                 if not any(c == conv for c in self.conversions):
                     self.conversions.append(conv)
 
-                if not isinstance(conv, StructConversionFunction) or not conv.operand.needs_host_type():
+                if not isinstance(conv, StructConversionFunction):
+                    continue
+
+                for e in conv.operand.struct_extensions:
+                    if not e.required or not e.needs_host_type():
+                        continue
+                    if not any(s.name == e.name for s in self.host_structs):
+                        self.host_structs.append(e)
+
+                if not conv.operand.needs_host_type():
                     continue
 
                 # Structs can be used in different ways by different conversions

dlls/winevulkan/vulkan_thunks.h

@@ -67,6 +67,43 @@ typedef struct VkDescriptorSetAllocateInfo_host
 typedef VkDescriptorSetAllocateInfo VkDescriptorSetAllocateInfo_host;
 #endif
 
+#if defined(USE_STRUCT_CONVERSION)
+typedef struct VkDedicatedAllocationMemoryAllocateInfoNV_host
+{
+    VkStructureType sType;
+    const void *pNext;
+    VkImage image;
+    VkBuffer buffer;
+} VkDedicatedAllocationMemoryAllocateInfoNV_host;
+#else
+typedef VkDedicatedAllocationMemoryAllocateInfoNV VkDedicatedAllocationMemoryAllocateInfoNV_host;
+#endif
+
+#if defined(USE_STRUCT_CONVERSION)
+typedef struct VkMemoryDedicatedAllocateInfo_host
+{
+    VkStructureType sType;
+    const void *pNext;
+    VkImage image;
+    VkBuffer buffer;
+} VkMemoryDedicatedAllocateInfo_host;
+typedef VkMemoryDedicatedAllocateInfo VkMemoryDedicatedAllocateInfoKHR;
+#else
+typedef VkMemoryDedicatedAllocateInfo VkMemoryDedicatedAllocateInfo_host;
+#endif
+
+#if defined(USE_STRUCT_CONVERSION)
+typedef struct VkMemoryOpaqueCaptureAddressAllocateInfo_host
+{
+    VkStructureType sType;
+    const void *pNext;
+    uint64_t opaqueCaptureAddress;
+} VkMemoryOpaqueCaptureAddressAllocateInfo_host;
+typedef VkMemoryOpaqueCaptureAddressAllocateInfo VkMemoryOpaqueCaptureAddressAllocateInfoKHR;
+#else
+typedef VkMemoryOpaqueCaptureAddressAllocateInfo VkMemoryOpaqueCaptureAddressAllocateInfo_host;
+#endif
+
 #if defined(USE_STRUCT_CONVERSION)
 typedef struct VkMemoryAllocateInfo_host
 {
@@ -136,6 +173,18 @@ typedef VkBindBufferMemoryInfo VkBindBufferMemoryInfoKHR;
 typedef VkBindBufferMemoryInfo VkBindBufferMemoryInfo_host;
 #endif
 
+#if defined(USE_STRUCT_CONVERSION)
+typedef struct VkBindImageMemorySwapchainInfoKHR_host
+{
+    VkStructureType sType;
+    const void *pNext;
+    VkSwapchainKHR swapchain;
+    uint32_t imageIndex;
+} VkBindImageMemorySwapchainInfoKHR_host;
+#else
+typedef VkBindImageMemorySwapchainInfoKHR VkBindImageMemorySwapchainInfoKHR_host;
+#endif
+
 #if defined(USE_STRUCT_CONVERSION)
 typedef struct VkBindImageMemoryInfo_host
 {
@@ -237,6 +286,31 @@ typedef VkRenderingAttachmentInfo VkRenderingAttachmentInfoKHR;
 typedef VkRenderingAttachmentInfo VkRenderingAttachmentInfo_host;
 #endif
 
+#if defined(USE_STRUCT_CONVERSION)
+typedef struct VkRenderingFragmentShadingRateAttachmentInfoKHR_host
+{
+    VkStructureType sType;
+    const void *pNext;
+    VkImageView imageView;
+    VkImageLayout imageLayout;
+    VkExtent2D shadingRateAttachmentTexelSize;
+} VkRenderingFragmentShadingRateAttachmentInfoKHR_host;
+#else
+typedef VkRenderingFragmentShadingRateAttachmentInfoKHR VkRenderingFragmentShadingRateAttachmentInfoKHR_host;
+#endif
+
+#if defined(USE_STRUCT_CONVERSION)
+typedef struct VkRenderingFragmentDensityMapAttachmentInfoEXT_host
+{
+    VkStructureType sType;
+    const void *pNext;
+    VkImageView imageView;
+    VkImageLayout imageLayout;
+} VkRenderingFragmentDensityMapAttachmentInfoEXT_host;
+#else
+typedef VkRenderingFragmentDensityMapAttachmentInfoEXT VkRenderingFragmentDensityMapAttachmentInfoEXT_host;
+#endif
+
 #if defined(USE_STRUCT_CONVERSION)
 typedef struct VkRenderingInfo_host
 {
@@ -827,6 +901,29 @@ typedef struct VkAccelerationStructureCreateInfoNV_host
 typedef VkAccelerationStructureCreateInfoNV VkAccelerationStructureCreateInfoNV_host;
 #endif
 
+#if defined(USE_STRUCT_CONVERSION)
+typedef struct VkBufferOpaqueCaptureAddressCreateInfo_host
+{
+    VkStructureType sType;
+    const void *pNext;
+    uint64_t opaqueCaptureAddress;
+} VkBufferOpaqueCaptureAddressCreateInfo_host;
+typedef VkBufferOpaqueCaptureAddressCreateInfo VkBufferOpaqueCaptureAddressCreateInfoKHR;
+#else
+typedef VkBufferOpaqueCaptureAddressCreateInfo VkBufferOpaqueCaptureAddressCreateInfo_host;
+#endif
+
+#if defined(USE_STRUCT_CONVERSION)
+typedef struct VkBufferDeviceAddressCreateInfoEXT_host
+{
+    VkStructureType sType;
+    const void *pNext;
+    VkDeviceAddress deviceAddress;
+} VkBufferDeviceAddressCreateInfoEXT_host;
+#else
+typedef VkBufferDeviceAddressCreateInfoEXT VkBufferDeviceAddressCreateInfoEXT_host;
+#endif
+
 #if defined(USE_STRUCT_CONVERSION)
 typedef struct VkBufferCreateInfo_host
 {
@@ -858,6 +955,30 @@ typedef struct VkBufferViewCreateInfo_host
 typedef VkBufferViewCreateInfo VkBufferViewCreateInfo_host;
 #endif
 
+#if defined(USE_STRUCT_CONVERSION)
+typedef struct VkShaderModuleValidationCacheCreateInfoEXT_host
+{
+    VkStructureType sType;
+    const void *pNext;
+    VkValidationCacheEXT validationCache;
+} VkShaderModuleValidationCacheCreateInfoEXT_host;
+#else
+typedef VkShaderModuleValidationCacheCreateInfoEXT VkShaderModuleValidationCacheCreateInfoEXT_host;
+#endif
+
+#if defined(USE_STRUCT_CONVERSION)
+typedef struct VkDebugUtilsObjectNameInfoEXT_host
+{
+    VkStructureType sType;
+    const void *pNext;
+    VkObjectType objectType;
+    uint64_t objectHandle;
+    const char *pObjectName;
+} VkDebugUtilsObjectNameInfoEXT_host;
+#else
+typedef VkDebugUtilsObjectNameInfoEXT VkDebugUtilsObjectNameInfoEXT_host;
+#endif
+
 #if defined(USE_STRUCT_CONVERSION)
 typedef struct VkPipelineShaderStageCreateInfo_host
 {
@@ -873,6 +994,18 @@ typedef struct VkPipelineShaderStageCreateInfo_host
 typedef VkPipelineShaderStageCreateInfo VkPipelineShaderStageCreateInfo_host;
 #endif
 
+#if defined(USE_STRUCT_CONVERSION)
+typedef struct VkSubpassShadingPipelineCreateInfoHUAWEI_host
+{
+    VkStructureType sType;
+    void *pNext;
+    VkRenderPass renderPass;
+    uint32_t subpass;
+} VkSubpassShadingPipelineCreateInfoHUAWEI_host;
+#else
+typedef VkSubpassShadingPipelineCreateInfoHUAWEI VkSubpassShadingPipelineCreateInfoHUAWEI_host;
+#endif
+
 #if defined(USE_STRUCT_CONVERSION)
 typedef struct VkComputePipelineCreateInfo_host
 {
@@ -936,6 +1069,34 @@ typedef struct VkFramebufferCreateInfo_host
 typedef VkFramebufferCreateInfo VkFramebufferCreateInfo_host;
 #endif
 
+#if defined(USE_STRUCT_CONVERSION)
+typedef struct VkGraphicsShaderGroupCreateInfoNV_host
+{
+    VkStructureType sType;
+    const void *pNext;
+    uint32_t stageCount;
+    const VkPipelineShaderStageCreateInfo_host *pStages;
+    const VkPipelineVertexInputStateCreateInfo *pVertexInputState;
+    const VkPipelineTessellationStateCreateInfo *pTessellationState;
+} VkGraphicsShaderGroupCreateInfoNV_host;
+#else
+typedef VkGraphicsShaderGroupCreateInfoNV VkGraphicsShaderGroupCreateInfoNV_host;
+#endif
+
+#if defined(USE_STRUCT_CONVERSION)
+typedef struct VkGraphicsPipelineShaderGroupsCreateInfoNV_host
+{
+    VkStructureType sType;
+    const void *pNext;
+    uint32_t groupCount;
+    const VkGraphicsShaderGroupCreateInfoNV_host *pGroups;
+    uint32_t pipelineCount;
+    const VkPipeline *pPipelines;
+} VkGraphicsPipelineShaderGroupsCreateInfoNV_host;
+#else
+typedef VkGraphicsPipelineShaderGroupsCreateInfoNV VkGraphicsPipelineShaderGroupsCreateInfoNV_host;
+#endif
+
 #if defined(USE_STRUCT_CONVERSION)
 typedef struct VkGraphicsPipelineCreateInfo_host
 {
@@ -963,6 +1124,29 @@ typedef struct VkGraphicsPipelineCreateInfo_host
 typedef VkGraphicsPipelineCreateInfo VkGraphicsPipelineCreateInfo_host;
 #endif
 
+#if defined(USE_STRUCT_CONVERSION)
+typedef struct VkImageSwapchainCreateInfoKHR_host
+{
+    VkStructureType sType;
+    const void *pNext;
+    VkSwapchainKHR swapchain;
+} VkImageSwapchainCreateInfoKHR_host;
+#else
+typedef VkImageSwapchainCreateInfoKHR VkImageSwapchainCreateInfoKHR_host;
+#endif
+
+#if defined(USE_STRUCT_CONVERSION)
+typedef struct VkSamplerYcbcrConversionInfo_host
+{
+    VkStructureType sType;
+    const void *pNext;
+    VkSamplerYcbcrConversion conversion;
+} VkSamplerYcbcrConversionInfo_host;
+typedef VkSamplerYcbcrConversionInfo VkSamplerYcbcrConversionInfoKHR;
+#else
+typedef VkSamplerYcbcrConversionInfo VkSamplerYcbcrConversionInfo_host;
+#endif
+
 #if defined(USE_STRUCT_CONVERSION)
 typedef struct VkImageViewCreateInfo_host
 {
@@ -1075,6 +1259,19 @@ typedef struct VkRayTracingPipelineCreateInfoNV_host
 typedef VkRayTracingPipelineCreateInfoNV VkRayTracingPipelineCreateInfoNV_host;
 #endif
 
+#if defined(USE_STRUCT_CONVERSION)
+typedef struct VkSemaphoreTypeCreateInfo_host
+{
+    VkStructureType sType;
+    const void *pNext;
+    VkSemaphoreType semaphoreType;
+    uint64_t initialValue;
+} VkSemaphoreTypeCreateInfo_host;
+typedef VkSemaphoreTypeCreateInfo VkSemaphoreTypeCreateInfoKHR;
+#else
+typedef VkSemaphoreTypeCreateInfo VkSemaphoreTypeCreateInfo_host;
+#endif
+
 #if defined(USE_STRUCT_CONVERSION)
 typedef struct VkSwapchainCreateInfoKHR_host
 {
@@ -1494,6 +1691,18 @@ typedef struct VkPhysicalDeviceMemoryProperties_host
 typedef VkPhysicalDeviceMemoryProperties VkPhysicalDeviceMemoryProperties_host;
 #endif
 
+#if defined(USE_STRUCT_CONVERSION)
+typedef struct VkPhysicalDeviceMemoryBudgetPropertiesEXT_host
+{
+    VkStructureType sType;
+    void *pNext;
+    VkDeviceSize heapBudget[VK_MAX_MEMORY_HEAPS];
+    VkDeviceSize heapUsage[VK_MAX_MEMORY_HEAPS];
+} VkPhysicalDeviceMemoryBudgetPropertiesEXT_host;
+#else
+typedef VkPhysicalDeviceMemoryBudgetPropertiesEXT VkPhysicalDeviceMemoryBudgetPropertiesEXT_host;
+#endif
+
 #if defined(USE_STRUCT_CONVERSION)
 typedef struct VkPhysicalDeviceMemoryProperties2_host
 {
@@ -1637,6 +1846,304 @@ typedef struct VkPhysicalDeviceProperties_host
 typedef VkPhysicalDeviceProperties VkPhysicalDeviceProperties_host;
 #endif
 
+#if defined(USE_STRUCT_CONVERSION)
+typedef struct VkPhysicalDeviceMaintenance3Properties_host
+{
+    VkStructureType sType;
+    void *pNext;
+    uint32_t maxPerSetDescriptors;
+    VkDeviceSize maxMemoryAllocationSize;
+} VkPhysicalDeviceMaintenance3Properties_host;
+typedef VkPhysicalDeviceMaintenance3Properties VkPhysicalDeviceMaintenance3PropertiesKHR;
+#else
+typedef VkPhysicalDeviceMaintenance3Properties VkPhysicalDeviceMaintenance3Properties_host;
+#endif
+
+#if defined(USE_STRUCT_CONVERSION)
+typedef struct VkPhysicalDeviceMaintenance4Properties_host
+{
+    VkStructureType sType;
+    void *pNext;
+    VkDeviceSize maxBufferSize;
+} VkPhysicalDeviceMaintenance4Properties_host;
+typedef VkPhysicalDeviceMaintenance4Properties VkPhysicalDeviceMaintenance4PropertiesKHR;
+#else
+typedef VkPhysicalDeviceMaintenance4Properties VkPhysicalDeviceMaintenance4Properties_host;
+#endif
+
+#if defined(USE_STRUCT_CONVERSION)
+typedef struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT_host
+{
+    VkStructureType sType;
+    void *pNext;
+    VkDeviceSize minImportedHostPointerAlignment;
+} VkPhysicalDeviceExternalMemoryHostPropertiesEXT_host;
+#else
+typedef VkPhysicalDeviceExternalMemoryHostPropertiesEXT VkPhysicalDeviceExternalMemoryHostPropertiesEXT_host;
+#endif
+
+#if defined(USE_STRUCT_CONVERSION)
+typedef struct VkPhysicalDeviceTimelineSemaphoreProperties_host
+{
+    VkStructureType sType;
+    void *pNext;
+    uint64_t maxTimelineSemaphoreValueDifference;
+} VkPhysicalDeviceTimelineSemaphoreProperties_host;
+typedef VkPhysicalDeviceTimelineSemaphoreProperties VkPhysicalDeviceTimelineSemaphorePropertiesKHR;
+#else
+typedef VkPhysicalDeviceTimelineSemaphoreProperties VkPhysicalDeviceTimelineSemaphoreProperties_host;
+#endif
+
+#if defined(USE_STRUCT_CONVERSION)
+typedef struct VkPhysicalDeviceTransformFeedbackPropertiesEXT_host
+{
+    VkStructureType sType;
+    void *pNext;
+    uint32_t maxTransformFeedbackStreams;
+    uint32_t maxTransformFeedbackBuffers;
+    VkDeviceSize maxTransformFeedbackBufferSize;
+    uint32_t maxTransformFeedbackStreamDataSize;
+    uint32_t maxTransformFeedbackBufferDataSize;
+    uint32_t maxTransformFeedbackBufferDataStride;
+    VkBool32 transformFeedbackQueries;
+    VkBool32 transformFeedbackStreamsLinesTriangles;
+    VkBool32 transformFeedbackRasterizationStreamSelect;
+    VkBool32 transformFeedbackDraw;
+} VkPhysicalDeviceTransformFeedbackPropertiesEXT_host;
+#else
+typedef VkPhysicalDeviceTransformFeedbackPropertiesEXT VkPhysicalDeviceTransformFeedbackPropertiesEXT_host;
+#endif
+
+#if defined(USE_STRUCT_CONVERSION)
+typedef struct VkPhysicalDeviceMemoryDecompressionPropertiesNV_host
+{
+    VkStructureType sType;
+    void *pNext;
+    VkMemoryDecompressionMethodFlagsNV decompressionMethods;
+    uint64_t maxDecompressionIndirectCount;
+} VkPhysicalDeviceMemoryDecompressionPropertiesNV_host;
+#else
+typedef VkPhysicalDeviceMemoryDecompressionPropertiesNV VkPhysicalDeviceMemoryDecompressionPropertiesNV_host;
+#endif
+
+#if defined(USE_STRUCT_CONVERSION)
+typedef struct VkPhysicalDeviceAccelerationStructurePropertiesKHR_host
+{
+    VkStructureType sType;
+    void *pNext;
+    uint64_t maxGeometryCount;
+    uint64_t maxInstanceCount;
+    uint64_t maxPrimitiveCount;
+    uint32_t maxPerStageDescriptorAccelerationStructures;
+    uint32_t maxPerStageDescriptorUpdateAfterBindAccelerationStructures;
+    uint32_t maxDescriptorSetAccelerationStructures;
+    uint32_t maxDescriptorSetUpdateAfterBindAccelerationStructures;
+    uint32_t minAccelerationStructureScratchOffsetAlignment;
+} VkPhysicalDeviceAccelerationStructurePropertiesKHR_host;
+#else
+typedef VkPhysicalDeviceAccelerationStructurePropertiesKHR VkPhysicalDeviceAccelerationStructurePropertiesKHR_host;
+#endif
+
+#if defined(USE_STRUCT_CONVERSION)
+typedef struct VkPhysicalDeviceRayTracingPropertiesNV_host
+{
+    VkStructureType sType;
+    void *pNext;
+    uint32_t shaderGroupHandleSize;
+    uint32_t maxRecursionDepth;
+    uint32_t maxShaderGroupStride;
+    uint32_t shaderGroupBaseAlignment;
+    uint64_t maxGeometryCount;
+    uint64_t maxInstanceCount;
+    uint64_t maxTriangleCount;
+    uint32_t maxDescriptorSetAccelerationStructures;
+} VkPhysicalDeviceRayTracingPropertiesNV_host;
+#else
+typedef VkPhysicalDeviceRayTracingPropertiesNV VkPhysicalDeviceRayTracingPropertiesNV_host;
+#endif
+
+#if defined(USE_STRUCT_CONVERSION)
+typedef struct VkPhysicalDeviceTexelBufferAlignmentProperties_host
+{
+    VkStructureType sType;
+    void *pNext;
+    VkDeviceSize storageTexelBufferOffsetAlignmentBytes;
+    VkBool32 storageTexelBufferOffsetSingleTexelAlignment;
+    VkDeviceSize uniformTexelBufferOffsetAlignmentBytes;
+    VkBool32 uniformTexelBufferOffsetSingleTexelAlignment;
+} VkPhysicalDeviceTexelBufferAlignmentProperties_host;
+typedef VkPhysicalDeviceTexelBufferAlignmentProperties VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT;
+#else
+typedef VkPhysicalDeviceTexelBufferAlignmentProperties VkPhysicalDeviceTexelBufferAlignmentProperties_host;
+#endif
+
+#if defined(USE_STRUCT_CONVERSION)
+typedef struct VkPhysicalDeviceVulkan11Properties_host
+{
+    VkStructureType sType;
+    void *pNext;
+    uint8_t deviceUUID[VK_UUID_SIZE];
+    uint8_t driverUUID[VK_UUID_SIZE];
+    uint8_t deviceLUID[VK_LUID_SIZE];
+    uint32_t deviceNodeMask;
+    VkBool32 deviceLUIDValid;
+    uint32_t subgroupSize;
+    VkShaderStageFlags subgroupSupportedStages;
+    VkSubgroupFeatureFlags subgroupSupportedOperations;
+    VkBool32 subgroupQuadOperationsInAllStages;
+    VkPointClippingBehavior pointClippingBehavior;
+    uint32_t maxMultiviewViewCount;
+    uint32_t maxMultiviewInstanceIndex;
+    VkBool32 protectedNoFault;
+    uint32_t maxPerSetDescriptors;
+    VkDeviceSize maxMemoryAllocationSize;
+} VkPhysicalDeviceVulkan11Properties_host;
+#else
+typedef VkPhysicalDeviceVulkan11Properties VkPhysicalDeviceVulkan11Properties_host;
+#endif
+
+#if defined(USE_STRUCT_CONVERSION)
+typedef struct VkPhysicalDeviceVulkan12Properties_host
+{
+    VkStructureType sType;
+    void *pNext;
+    VkDriverId driverID;
+    char driverName[VK_MAX_DRIVER_NAME_SIZE];
+    char driverInfo[VK_MAX_DRIVER_INFO_SIZE];
+    VkConformanceVersion conformanceVersion;
+    VkShaderFloatControlsIndependence denormBehaviorIndependence;
+    VkShaderFloatControlsIndependence roundingModeIndependence;
+    VkBool32 shaderSignedZeroInfNanPreserveFloat16;
+    VkBool32 shaderSignedZeroInfNanPreserveFloat32;
+    VkBool32 shaderSignedZeroInfNanPreserveFloat64;
+    VkBool32 shaderDenormPreserveFloat16;
+    VkBool32 shaderDenormPreserveFloat32;
+    VkBool32 shaderDenormPreserveFloat64;
+    VkBool32 shaderDenormFlushToZeroFloat16;
+    VkBool32 shaderDenormFlushToZeroFloat32;
+    VkBool32 shaderDenormFlushToZeroFloat64;
+    VkBool32 shaderRoundingModeRTEFloat16;
+    VkBool32 shaderRoundingModeRTEFloat32;
+    VkBool32 shaderRoundingModeRTEFloat64;
+    VkBool32 shaderRoundingModeRTZFloat16;
+    VkBool32 shaderRoundingModeRTZFloat32;
+    VkBool32 shaderRoundingModeRTZFloat64;
+    uint32_t maxUpdateAfterBindDescriptorsInAllPools;
+    VkBool32 shaderUniformBufferArrayNonUniformIndexingNative;
+    VkBool32 shaderSampledImageArrayNonUniformIndexingNative;
+    VkBool32 shaderStorageBufferArrayNonUniformIndexingNative;
+    VkBool32 shaderStorageImageArrayNonUniformIndexingNative;
+    VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative;
+    VkBool32 robustBufferAccessUpdateAfterBind;
+    VkBool32 quadDivergentImplicitLod;
+    uint32_t maxPerStageDescriptorUpdateAfterBindSamplers;
+    uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers;
+    uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers;
+    uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages;
+    uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages;
+    uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments;
+    uint32_t maxPerStageUpdateAfterBindResources;
+    uint32_t maxDescriptorSetUpdateAfterBindSamplers;
+    uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers;
+    uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
+    uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers;
+    uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
+    uint32_t maxDescriptorSetUpdateAfterBindSampledImages;
+    uint32_t maxDescriptorSetUpdateAfterBindStorageImages;
+    uint32_t maxDescriptorSetUpdateAfterBindInputAttachments;
+    VkResolveModeFlags supportedDepthResolveModes;
+    VkResolveModeFlags supportedStencilResolveModes;
+    VkBool32 independentResolveNone;
+    VkBool32 independentResolve;
+    VkBool32 filterMinmaxSingleComponentFormats;
+    VkBool32 filterMinmaxImageComponentMapping;
+    uint64_t maxTimelineSemaphoreValueDifference;
+    VkSampleCountFlags framebufferIntegerColorSampleCounts;
+} VkPhysicalDeviceVulkan12Properties_host;
+#else
+typedef VkPhysicalDeviceVulkan12Properties VkPhysicalDeviceVulkan12Properties_host;
+#endif
+
+#if defined(USE_STRUCT_CONVERSION)
+typedef struct VkPhysicalDeviceVulkan13Properties_host
+{
+    VkStructureType sType;
+    void *pNext;
+    uint32_t minSubgroupSize;
+    uint32_t maxSubgroupSize;
+    uint32_t maxComputeWorkgroupSubgroups;
+    VkShaderStageFlags requiredSubgroupSizeStages;
+    uint32_t maxInlineUniformBlockSize;
+    uint32_t maxPerStageDescriptorInlineUniformBlocks;
+    uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
+    uint32_t maxDescriptorSetInlineUniformBlocks;
+    uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
+    uint32_t maxInlineUniformTotalSize;
+    VkBool32 integerDotProduct8BitUnsignedAccelerated;
+    VkBool32 integerDotProduct8BitSignedAccelerated;
+    VkBool32 integerDotProduct8BitMixedSignednessAccelerated;
+    VkBool32 integerDotProduct4x8BitPackedUnsignedAccelerated;
+    VkBool32 integerDotProduct4x8BitPackedSignedAccelerated;
+    VkBool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated;
+    VkBool32 integerDotProduct16BitUnsignedAccelerated;
+    VkBool32 integerDotProduct16BitSignedAccelerated;
+    VkBool32 integerDotProduct16BitMixedSignednessAccelerated;
+    VkBool32 integerDotProduct32BitUnsignedAccelerated;
+    VkBool32 integerDotProduct32BitSignedAccelerated;
+    VkBool32 integerDotProduct32BitMixedSignednessAccelerated;
+    VkBool32 integerDotProduct64BitUnsignedAccelerated;
+    VkBool32 integerDotProduct64BitSignedAccelerated;
+    VkBool32 integerDotProduct64BitMixedSignednessAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated;
+    VkDeviceSize storageTexelBufferOffsetAlignmentBytes;
+    VkBool32 storageTexelBufferOffsetSingleTexelAlignment;
+    VkDeviceSize uniformTexelBufferOffsetAlignmentBytes;
+    VkBool32 uniformTexelBufferOffsetSingleTexelAlignment;
+    VkDeviceSize maxBufferSize;
+} VkPhysicalDeviceVulkan13Properties_host;
+#else
+typedef VkPhysicalDeviceVulkan13Properties VkPhysicalDeviceVulkan13Properties_host;
+#endif
+
+#if defined(USE_STRUCT_CONVERSION)
+typedef struct VkPhysicalDeviceRobustness2PropertiesEXT_host
+{
+    VkStructureType sType;
+    void *pNext;
+    VkDeviceSize robustStorageBufferAccessSizeAlignment;
+    VkDeviceSize robustUniformBufferAccessSizeAlignment;
+} VkPhysicalDeviceRobustness2PropertiesEXT_host;
+#else
+typedef VkPhysicalDeviceRobustness2PropertiesEXT VkPhysicalDeviceRobustness2PropertiesEXT_host;
+#endif
+
+#if defined(USE_STRUCT_CONVERSION)
+typedef struct VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM_host
+{
+    VkStructureType sType;
+    void *pNext;
+    uint64_t shaderCoreMask;
+    uint32_t shaderCoreCount;
+    uint32_t shaderWarpsPerCore;
+} VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM_host;
+#else
+typedef VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM_host;
+#endif
+
 #if defined(USE_STRUCT_CONVERSION)
 typedef struct VkPhysicalDeviceProperties2_host
 {
@@ -1808,19 +2315,6 @@ typedef VkSubmitInfo2 VkSubmitInfo2KHR;
 typedef VkSubmitInfo2 VkSubmitInfo2_host;
 #endif
 
-#if defined(USE_STRUCT_CONVERSION)
-typedef struct VkDebugUtilsObjectNameInfoEXT_host
-{
-    VkStructureType sType;
-    const void *pNext;
-    VkObjectType objectType;
-    uint64_t objectHandle;
-    const char *pObjectName;
-} VkDebugUtilsObjectNameInfoEXT_host;
-#else
-typedef VkDebugUtilsObjectNameInfoEXT VkDebugUtilsObjectNameInfoEXT_host;
-#endif
-
 #if defined(USE_STRUCT_CONVERSION)
 typedef struct VkDebugUtilsObjectTagInfoEXT_host
 {
@@ -1849,6 +2343,20 @@ typedef VkSemaphoreSignalInfo VkSemaphoreSignalInfoKHR;
 typedef VkSemaphoreSignalInfo VkSemaphoreSignalInfo_host;
 #endif
 
+#if defined(USE_STRUCT_CONVERSION)
+typedef struct VkDeviceAddressBindingCallbackDataEXT_host
+{
+    VkStructureType sType;
+    void *pNext;
+    VkDeviceAddressBindingFlagsEXT flags;
+    VkDeviceAddress baseAddress;
+    VkDeviceSize size;
+    VkDeviceAddressBindingTypeEXT bindingType;
+} VkDeviceAddressBindingCallbackDataEXT_host;
+#else
+typedef VkDeviceAddressBindingCallbackDataEXT VkDeviceAddressBindingCallbackDataEXT_host;
+#endif
+
 #if defined(USE_STRUCT_CONVERSION)
 typedef struct VkDebugUtilsMessengerCallbackDataEXT_host
 {