[PATCH 0/8] MR1256: winevulkan: Separate array and struct conversions.

[PATCH 1/8] winevulkan: Remove no longer used Direction.INPUT_OUTPUT.

[Jacek Caban]

From: Jacek Caban

---
 dlls/winevulkan/make_vulkan | 1 -
 1 file changed, 1 deletion(-)

diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan
index dcdf2c4ab10..783b781ff41 100755
--- a/dlls/winevulkan/make_vulkan
+++ b/dlls/winevulkan/make_vulkan
@@ -279,7 +279,6 @@ class Direction(Enum):
     """ Parameter direction: input, output, input_output. """
     INPUT = 1
     OUTPUT = 2
-    INPUT_OUTPUT = 3

class VkBaseType(object):

[PATCH 2/8] winevulkan: Pass type as uint32_t to wine_vk_unwrap_handle.

[Jacek Caban]

From: Jacek Caban

Fixes -Wenum-conversion warning when VkDebugReportObjectTypeEXT is used as a type.
---
 dlls/winevulkan/make_vulkan      | 40 +++++++++++------------
 dlls/winevulkan/vulkan_private.h |  1 -
 dlls/winevulkan/vulkan_thunks.c  | 54 ++++++++++++++++----------------
 3 files changed, 47 insertions(+), 48 deletions(-)

diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan
index 783b781ff41..a2e3d6e2017 100755
--- a/dlls/winevulkan/make_vulkan
+++ b/dlls/winevulkan/make_vulkan
@@ -2349,6 +2349,26 @@ class VkGenerator(object):

f.write("WINE_DEFAULT_DEBUG_CHANNEL(vulkan);\n\n")

+        f.write("static uint64_t wine_vk_unwrap_handle(uint32_t type, uint64_t handle)\n")
+        f.write("{\n")
+        f.write("    switch(type)\n")
+        f.write("    {\n")
+        for handle in self.registry.handles:
+            if not handle.is_required() or not handle.is_wrapped() or handle.is_alias():
+                continue
+            f.write("    case {}:\n".format(handle.object_type))
+            if handle.is_dispatchable():
+                f.write("        return (uint64_t) (uintptr_t) ")
+                f.write(handle.native_handle("(({}) (uintptr_t) handle)".format(handle.name)))
+            else:
+                f.write("        return (uint64_t) ")
+                f.write(handle.native_handle("handle"))
+            f.write(";\n");
+        f.write("    default:\n")
+        f.write("       return handle;\n")
+        f.write("    }\n")
+        f.write("}\n\n")
+
         # Generate any conversion helper functions.
         for conv in self.conversions:
             f.write(conv.definition())
@@ -2426,26 +2446,6 @@ class VkGenerator(object):
         f.write(";\n")
         f.write("}\n\n")

-        f.write("uint64_t wine_vk_unwrap_handle(VkObjectType type, uint64_t handle)\n")
-        f.write("{\n")
-        f.write("    switch(type)\n")
-        f.write("    {\n")
-        for handle in self.registry.handles:
-            if not handle.is_required() or not handle.is_wrapped() or handle.is_alias():
-                continue
-            f.write("    case {}:\n".format(handle.object_type))
-            if handle.is_dispatchable():
-                f.write("        return (uint64_t) (uintptr_t) ")
-                f.write(handle.native_handle("(({}) (uintptr_t) handle)".format(handle.name)))
-            else:
-                f.write("        return (uint64_t) ")
-                f.write(handle.native_handle("handle"))
-            f.write(";\n");
-        f.write("    default:\n")
-        f.write("       return handle;\n")
-        f.write("    }\n")
-        f.write("}\n\n")
-
         f.write("#if !defined(USE_STRUCT_CONVERSION)\n\n")

f.write("const unixlib_entry_t __wine_unix_call_funcs[] =\n")
diff --git a/dlls/winevulkan/vulkan_private.h b/dlls/winevulkan/vulkan_private.h
index 4221e97b73a..25890f00471 100644
--- a/dlls/winevulkan/vulkan_private.h
+++ b/dlls/winevulkan/vulkan_private.h
@@ -230,7 +230,6 @@ BOOL wine_vk_device_extension_supported(const char *name) DECLSPEC_HIDDEN;
 BOOL wine_vk_instance_extension_supported(const char *name) DECLSPEC_HIDDEN;

BOOL wine_vk_is_type_wrapped(VkObjectType type) DECLSPEC_HIDDEN;
-uint64_t wine_vk_unwrap_handle(VkObjectType type, uint64_t handle) DECLSPEC_HIDDEN;

NTSTATUS init_vulkan(void *args) DECLSPEC_HIDDEN;

diff --git a/dlls/winevulkan/vulkan_thunks.c b/dlls/winevulkan/vulkan_thunks.c
index 6a8b15b6e32..dbdd0368b2a 100644
--- a/dlls/winevulkan/vulkan_thunks.c
+++ b/dlls/winevulkan/vulkan_thunks.c
@@ -21,6 +21,33 @@

WINE_DEFAULT_DEBUG_CHANNEL(vulkan);

+static uint64_t wine_vk_unwrap_handle(uint32_t type, uint64_t handle)
+{
+    switch(type)
+    {
+    case VK_OBJECT_TYPE_COMMAND_BUFFER:
+        return (uint64_t) (uintptr_t) wine_cmd_buffer_from_handle(((VkCommandBuffer) (uintptr_t) handle))->command_buffer;
+    case VK_OBJECT_TYPE_COMMAND_POOL:
+        return (uint64_t) wine_cmd_pool_from_handle(handle)->command_pool;
+    case VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT:
+        return (uint64_t) wine_debug_report_callback_from_handle(handle)->debug_callback;
+    case VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT:
+        return (uint64_t) wine_debug_utils_messenger_from_handle(handle)->debug_messenger;
+    case VK_OBJECT_TYPE_DEVICE:
+        return (uint64_t) (uintptr_t) wine_device_from_handle(((VkDevice) (uintptr_t) handle))->device;
+    case VK_OBJECT_TYPE_INSTANCE:
+        return (uint64_t) (uintptr_t) wine_instance_from_handle(((VkInstance) (uintptr_t) handle))->instance;
+    case VK_OBJECT_TYPE_PHYSICAL_DEVICE:
+        return (uint64_t) (uintptr_t) wine_phys_dev_from_handle(((VkPhysicalDevice) (uintptr_t) handle))->phys_dev;
+    case VK_OBJECT_TYPE_QUEUE:
+        return (uint64_t) (uintptr_t) wine_queue_from_handle(((VkQueue) (uintptr_t) handle))->queue;
+    case VK_OBJECT_TYPE_SURFACE_KHR:
+        return (uint64_t) wine_surface_from_handle(handle)->surface;
+    default:
+       return handle;
+    }
+}
+
 #if defined(USE_STRUCT_CONVERSION)
 static inline void convert_VkAcquireNextImageInfoKHR_win32_to_host(const VkAcquireNextImageInfoKHR *in, VkAcquireNextImageInfoKHR_host *out)
 {
@@ -19636,33 +19663,6 @@ BOOL wine_vk_is_type_wrapped(VkObjectType type)
         type == VK_OBJECT_TYPE_SURFACE_KHR;
 }

-uint64_t wine_vk_unwrap_handle(VkObjectType type, uint64_t handle)
-{
-    switch(type)
-    {
-    case VK_OBJECT_TYPE_COMMAND_BUFFER:
-        return (uint64_t) (uintptr_t) wine_cmd_buffer_from_handle(((VkCommandBuffer) (uintptr_t) handle))->command_buffer;
-    case VK_OBJECT_TYPE_COMMAND_POOL:
-        return (uint64_t) wine_cmd_pool_from_handle(handle)->command_pool;
-    case VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT:
-        return (uint64_t) wine_debug_report_callback_from_handle(handle)->debug_callback;
-    case VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT:
-        return (uint64_t) wine_debug_utils_messenger_from_handle(handle)->debug_messenger;
-    case VK_OBJECT_TYPE_DEVICE:
-        return (uint64_t) (uintptr_t) wine_device_from_handle(((VkDevice) (uintptr_t) handle))->device;
-    case VK_OBJECT_TYPE_INSTANCE:
-        return (uint64_t) (uintptr_t) wine_instance_from_handle(((VkInstance) (uintptr_t) handle))->instance;
-    case VK_OBJECT_TYPE_PHYSICAL_DEVICE:
-        return (uint64_t) (uintptr_t) wine_phys_dev_from_handle(((VkPhysicalDevice) (uintptr_t) handle))->phys_dev;
-    case VK_OBJECT_TYPE_QUEUE:
-        return (uint64_t) (uintptr_t) wine_queue_from_handle(((VkQueue) (uintptr_t) handle))->queue;
-    case VK_OBJECT_TYPE_SURFACE_KHR:
-        return (uint64_t) wine_surface_from_handle(handle)->surface;
-    default:
-       return handle;
-    }
-}
-
 #if !defined(USE_STRUCT_CONVERSION)

const unixlib_entry_t __wine_unix_call_funcs[] =

[PATCH 3/8] winevulkan: Support output array conversion in _generate_array_conversion_func.

[Jacek Caban]

From: Jacek Caban

And get rid of _generate_static_array_conversion_func.
---
 dlls/winevulkan/make_vulkan     | 82 +++++++++------------------------
 dlls/winevulkan/vulkan_thunks.c |  2 +-
 2 files changed, 23 insertions(+), 61 deletions(-)

diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan
index a2e3d6e2017..0125831dc84 100755
--- a/dlls/winevulkan/make_vulkan
+++ b/dlls/winevulkan/make_vulkan
@@ -2003,6 +2003,9 @@ class ConversionFunction(object):
         self.unwrap = unwrap or not self.operand.needs_unwrapping()
         self.needs_alloc = direction != Direction.OUTPUT and variable.needs_alloc(conv, unwrap)

+        if variable.is_static_array() and direction == Direction.INPUT:
+            LOGGER.error("Static array input conversion is not supported")
+
         self._set_name()

def __eq__(self, other):
@@ -2025,8 +2028,8 @@ class ConversionFunction(object):

if self.conv:
             if self.direction == Direction.OUTPUT:
-                params = ["const {0} *in".format(host_type), "uint32_t count"]
-                return_type = self.type
+                params = ["const {0} *in".format(host_type), "{0} *out".format(self.type), "uint32_t count"]
+                return_type = None
             else:
                 params = ["const {0} *in".format(self.type), "uint32_t count"]
                 return_type = host_type
@@ -2035,18 +2038,27 @@ class ConversionFunction(object):
             return_type = self.type

# Generate function prototype.
-        body += "static inline {0} *{1}(".format(return_type, self.name)
+        if return_type:
+            body += "static inline {0} *{1}(".format(return_type, self.name)
+        else:
+            body += "static inline void {0}(".format(self.name)
         if self.needs_alloc:
             body += "struct conversion_context *ctx, "
         body += ", ".join(p for p in params)
         body += ")\n{\n"

-        body += "    {0} *out;\n".format(return_type)
+        if return_type:
+            body += "    {0} *out;\n".format(return_type)

body += "    unsigned int i;\n\n"
-        body += "    if (!in || !count) return NULL;\n\n"

-        body += "    out = conversion_context_alloc(ctx, count * sizeof(*out));\n"
+        if return_type:
+            body += "    if (!in || !count) return NULL;\n\n"
+        else:
+            body += "    if (!in) return;\n\n"
+
+        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"
@@ -2063,8 +2075,9 @@ class ConversionFunction(object):
             LOGGER.warn("Unhandled conversion operand type")
             body += "        out[i] = in[i];\n"

-        body += "    }\n\n"
-        body += "    return out;\n"
+        body += "    }\n"
+        if return_type:
+            body += "\n    return out;\n"
         body += "}\n"

body += "#endif /* USE_STRUCT_CONVERSION */\n"
@@ -2133,55 +2146,6 @@ class ConversionFunction(object):

return body

-    def _generate_static_array_conversion_func(self):
-        """ Helper function for generating a conversion function for array operands. """
-
-        body = ""
-
-        if self.conv:
-            body += "#if defined(USE_STRUCT_CONVERSION)\n"
-            if self.direction == Direction.OUTPUT:
-                params = ["const {0}_host *in".format(self.type), "{0} *out".format(self.type), "uint32_t count"]
-            else:
-                params = ["const {0} *in".format(self.type), "{0} *out_host".format(self.type), "uint32_t count"]
-
-
-            # Generate function prototype.
-            body += "static inline void {0}(".format(self.name)
-            body += ", ".join(p for p in params)
-            body += ")\n"
-        else:
-            body += "#if !defined(USE_STRUCT_CONVERSION)\n"
-
-            params = ["const {0} *in".format(self.type), "{0} *out".format(self.type), "uint32_t count"]
-
-            # Generate function prototype.
-            body += "static inline void {0}(".format(self.name)
-            body += ", ".join(p for p in params)
-            body += ")\n"
-
-        body += "{\n"
-        body += "    unsigned int i;\n\n"
-        body += "    if (!in) return;\n\n"
-        body += "    for (i = 0; i < count; i++)\n"
-        body += "    {\n"
-
-        if isinstance(self.operand, VkStruct):
-            for m in self.operand:
-                # TODO: support copying of pNext extension structures!
-                body += "        " + m.copy("in[i].", "out[i].", self.direction, self.conv, self.unwrap)
-        elif isinstance(self.operand, VkHandle) and self.direction == Direction.INPUT:
-            body += "        out[i] = " + self.operand.driver_handle("in[i]") + ";\n"
-        else:
-            LOGGER.warn("Unhandled conversion operand type")
-            body += "        out[i] = in[i];\n"
-
-        body += "    }\n"
-        body += "}\n"
-        body += "#endif /* USE_STRUCT_CONVERSION) */\n\n"
-
-        return body
-
     def _set_name(self):
         name = "convert_{0}_".format(self.type)
         if self.array:
@@ -2199,9 +2163,7 @@ class ConversionFunction(object):
         self.name = name

def definition(self):
-        if self.array:
-            return self._generate_static_array_conversion_func()
-        elif self.dyn_array:
+        if self.array or self.dyn_array:
             return self._generate_array_conversion_func()
         else:
             return self._generate_conversion_func()
diff --git a/dlls/winevulkan/vulkan_thunks.c b/dlls/winevulkan/vulkan_thunks.c
index dbdd0368b2a..18039ca3c6f 100644
--- a/dlls/winevulkan/vulkan_thunks.c
+++ b/dlls/winevulkan/vulkan_thunks.c
@@ -2036,7 +2036,7 @@ static inline void convert_VkMemoryHeap_static_array_host_to_win32(const VkMemor
         out[i].flags = in[i].flags;
     }
 }
-#endif /* USE_STRUCT_CONVERSION) */
+#endif /* USE_STRUCT_CONVERSION */

#if defined(USE_STRUCT_CONVERSION)
 static inline void convert_VkPhysicalDeviceMemoryProperties_host_to_win32(const VkPhysicalDeviceMemoryProperties_host *in, VkPhysicalDeviceMemoryProperties *out)

[PATCH 4/8] winevulkan: Drop "static_array" from conversion function names.

[Jacek Caban]

From: Jacek Caban

Static arrays need only output conversion and output conversion is the same for static and dynamic arrays.
---
 dlls/winevulkan/make_vulkan     | 6 ++----
 dlls/winevulkan/vulkan_thunks.c | 4 ++--
 2 files changed, 4 insertions(+), 6 deletions(-)

diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan
index 0125831dc84..5949cea9543 100755
--- a/dlls/winevulkan/make_vulkan
+++ b/dlls/winevulkan/make_vulkan
@@ -1323,7 +1323,7 @@ class VkMember(VkVariable):
                 count = self.array_len
                 if direction == Direction.OUTPUT:
                     # Needed by VkMemoryHeap.memoryHeaps
-                    return "convert_{0}_static_array_host_to_{5}({2}{1}, {3}{1}, {4});\n".format(self.type, self.name, input, output, count, win_type)
+                    return "convert_{0}_array_host_to_{5}({2}{1}, {3}{1}, {4});\n".format(self.type, self.name, input, output, count, win_type)
                 else:
                     # Nothing needed this yet.
                     LOGGER.warn("TODO: implement copying of static array for {0}.{1}".format(self.type, self.name))
@@ -2148,9 +2148,7 @@ class ConversionFunction(object):

def _set_name(self):
         name = "convert_{0}_".format(self.type)
-        if self.array:
-            name += "static_array_"
-        elif self.dyn_array:
+        if self.array or self.dyn_array:
             name += "array_"

win_type = "win32" if self.conv else "win64"
diff --git a/dlls/winevulkan/vulkan_thunks.c b/dlls/winevulkan/vulkan_thunks.c
index 18039ca3c6f..cd00aa0b6fb 100644
--- a/dlls/winevulkan/vulkan_thunks.c
+++ b/dlls/winevulkan/vulkan_thunks.c
@@ -2024,7 +2024,7 @@ static inline void convert_VkImageFormatProperties2_host_to_win32(const VkImageF
 #endif /* USE_STRUCT_CONVERSION */

#if defined(USE_STRUCT_CONVERSION)
-static inline void convert_VkMemoryHeap_static_array_host_to_win32(const VkMemoryHeap_host *in, VkMemoryHeap *out, uint32_t count)
+static inline void convert_VkMemoryHeap_array_host_to_win32(const VkMemoryHeap_host *in, VkMemoryHeap *out, uint32_t count)
 {
     unsigned int i;

@@ -2046,7 +2046,7 @@ static inline void convert_VkPhysicalDeviceMemoryProperties_host_to_win32(const
     out->memoryTypeCount = in->memoryTypeCount;
     memcpy(out->memoryTypes, in->memoryTypes, VK_MAX_MEMORY_TYPES * sizeof(VkMemoryType));
     out->memoryHeapCount = in->memoryHeapCount;
-    convert_VkMemoryHeap_static_array_host_to_win32(in->memoryHeaps, out->memoryHeaps, VK_MAX_MEMORY_HEAPS);
+    convert_VkMemoryHeap_array_host_to_win32(in->memoryHeaps, out->memoryHeaps, VK_MAX_MEMORY_HEAPS);
 }
 #endif /* USE_STRUCT_CONVERSION */

[PATCH 5/8] winevulkan: Use separated classes for struct and array conversions.

[Jacek Caban]

From: Jacek Caban

---
 dlls/winevulkan/make_vulkan | 232 ++++++++++++++++++++----------------
 1 file changed, 130 insertions(+), 102 deletions(-)

diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan
index 5949cea9543..2ea6446da4e 100755
--- a/dlls/winevulkan/make_vulkan
+++ b/dlls/winevulkan/make_vulkan
@@ -1203,12 +1203,18 @@ class VkVariable(object):

conversions.extend(m.get_conversions(unwrap, is_const))

-        # Conversion requirements for the 'parent' parameter.
-        for conv in [False, True]:
-            if self.needs_conversion(conv, unwrap, Direction.INPUT, parent_const):
-                conversions.append(ConversionFunction(self, Direction.INPUT, conv, unwrap))
-            if self.needs_conversion(conv, unwrap, Direction.OUTPUT, parent_const):
-                conversions.append(ConversionFunction(self, Direction.OUTPUT, conv, unwrap))
+        if self.is_static_array() or self.is_dynamic_array():
+            for conv in [False, True]:
+                if self.needs_conversion(conv, unwrap, Direction.INPUT, parent_const):
+                    conversions.append(ArrayConversionFunction(self, Direction.INPUT, conv, unwrap))
+                if self.needs_conversion(conv, unwrap, Direction.OUTPUT, parent_const):
+                    conversions.append(ArrayConversionFunction(self, Direction.OUTPUT, conv, unwrap))
+        elif self.is_struct():
+            for conv in [False, True]:
+                if self.needs_conversion(conv, unwrap, Direction.INPUT, parent_const):
+                    conversions.append(StructConversionFunction(self.struct, Direction.INPUT, conv, unwrap))
+                if self.needs_conversion(conv, unwrap, Direction.OUTPUT, parent_const):
+                    conversions.append(StructConversionFunction(self.struct, Direction.OUTPUT, conv, unwrap))

return conversions

@@ -1992,102 +1998,28 @@ class VkStruct(Sequence):
             m.set_type_info(type_info)

-class ConversionFunction(object):
-    def __init__(self, variable, direction, conv, unwrap):
+class StructConversionFunction(object):
+    def __init__(self, struct, direction, conv, unwrap):
         self.direction = direction
-        self.array = variable.is_static_array()
-        self.dyn_array = variable.is_dynamic_array()
-        self.operand = variable.struct if variable.is_struct() else variable.handle
-        self.type = variable.type
+        self.operand = struct
+        self.type = struct.name
         self.conv = conv
         self.unwrap = unwrap or not self.operand.needs_unwrapping()
-        self.needs_alloc = direction != Direction.OUTPUT and variable.needs_alloc(conv, unwrap)
-
-        if variable.is_static_array() and direction == Direction.INPUT:
-            LOGGER.error("Static array input conversion is not supported")

-        self._set_name()
+        name = "convert_{0}_".format(self.type)
+        win_type = "win32" if self.conv else "win64"
+        host_part = "host" if self.unwrap else "unwrapped_host"
+        if self.direction == Direction.INPUT:
+            name += "{0}_to_{1}".format(win_type, host_part)
+        else: # Direction.OUTPUT
+            name += "{0}_to_{1}".format(host_part, win_type)
+        self.name = name

def __eq__(self, other):
         return self.name == other.name

-    def _generate_array_conversion_func(self):
-        """ Helper function for generating a conversion function for array operands. """
-
-        body = ""
-
-        if self.conv:
-            body += "#if defined(USE_STRUCT_CONVERSION)\n"
-        else:
-            body += "#if !defined(USE_STRUCT_CONVERSION)\n"
-
-        if self.conv and isinstance(self.operand, VkStruct) and self.operand.needs_host_type():
-            host_type = "{0}_host".format(self.type)
-        else:
-            host_type = self.type
-
-        if self.conv:
-            if self.direction == Direction.OUTPUT:
-                params = ["const {0} *in".format(host_type), "{0} *out".format(self.type), "uint32_t count"]
-                return_type = None
-            else:
-                params = ["const {0} *in".format(self.type), "uint32_t count"]
-                return_type = host_type
-        else:
-            params = ["const {0} *in".format(self.type), "uint32_t count"]
-            return_type = self.type
-
-        # Generate function prototype.
-        if return_type:
-            body += "static inline {0} *{1}(".format(return_type, self.name)
-        else:
-            body += "static inline void {0}(".format(self.name)
-        if self.needs_alloc:
-            body += "struct conversion_context *ctx, "
-        body += ", ".join(p for p in params)
-        body += ")\n{\n"
-
-        if return_type:
-            body += "    {0} *out;\n".format(return_type)
-
-        body += "    unsigned int i;\n\n"
-
-        if return_type:
-            body += "    if (!in || !count) return NULL;\n\n"
-        else:
-            body += "    if (!in) return;\n\n"
-
-        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 isinstance(self.operand, VkStruct):
-            for m in self.operand:
-                # TODO: support copying of pNext extension structures!
-                # Luckily though no extension struct at this point needs conversion.
-                body += "        " + m.copy("in[i].", "out[i].", self.direction, self.conv, self.unwrap)
-
-        elif isinstance(self.operand, VkHandle) and self.direction == Direction.INPUT:
-            body += "        out[i] = " + self.operand.driver_handle("in[i]") + ";\n"
-        else:
-            LOGGER.warn("Unhandled conversion operand type")
-            body += "        out[i] = in[i];\n"
-
-        body += "    }\n"
-        if return_type:
-            body += "\n    return out;\n"
-        body += "}\n"
-
-        body += "#endif /* USE_STRUCT_CONVERSION */\n"
-
-        body += "\n"
-
-        return body
-
-    def _generate_conversion_func(self):
-        """ Helper function for generating a conversion function for non-array operands. """
+    def definition(self):
+        """ Helper function for generating a struct conversion function. """

# It doesn't make sense to generate conversion functions for non-struct variables
         # which aren't in arrays, as this should be handled by the copy() function
@@ -2101,6 +2033,8 @@ class ConversionFunction(object):
         else:
             body += "#if !defined(USE_STRUCT_CONVERSION)\n"

+        needs_alloc = self.direction != Direction.OUTPUT and self.operand.needs_alloc(self.conv, self.unwrap)
+
         if self.conv:
             body += "static inline void {0}(".format(self.name)

@@ -2110,7 +2044,7 @@ class ConversionFunction(object):
                 params = ["const {0} *in".format(self.type), "{0}_host *out".format(self.type)]

# Generate parameter list
-            if self.needs_alloc:
+            if needs_alloc:
                 body += "struct conversion_context *ctx, "
             body += ", ".join(p for p in params)
             body += ")\n"
@@ -2121,7 +2055,7 @@ class ConversionFunction(object):
             params = ["const {0} *in".format(self.type), "{0} *out".format(self.type)]

# Generate parameter list
-            if self.needs_alloc:
+            if needs_alloc:
                 body += "struct conversion_context *ctx, "
             body += ", ".join(p for p in params)
             body += ")\n"
@@ -2148,9 +2082,6 @@ class ConversionFunction(object):

def _set_name(self):
         name = "convert_{0}_".format(self.type)
-        if self.array or self.dyn_array:
-            name += "array_"
-
         win_type = "win32" if self.conv else "win64"
         host_part = "host" if self.unwrap else "unwrapped_host"
         if self.direction == Direction.INPUT:
@@ -2160,11 +2091,108 @@ class ConversionFunction(object):

self.name = name

+
+class ArrayConversionFunction(object):
+    def __init__(self, array, direction, conv, unwrap):
+        self.array = array
+        self.direction = direction
+        self.operand = array.struct if array.is_struct() else array.handle
+        self.type = array.type
+        self.conv = conv
+        self.unwrap = unwrap or not array.needs_unwrapping()
+
+        if array.is_static_array() and direction == Direction.INPUT:
+            LOGGER.error("Static array input conversion is not supported")
+
+        name = "convert_{0}_array_".format(array.type)
+        win_type = "win32" if self.conv else "win64"
+        host_part = "host" if self.unwrap else "unwrapped_host"
+        if self.direction == Direction.INPUT:
+            name += "{0}_to_{1}".format(win_type, host_part)
+        else: # Direction.OUTPUT
+            name += "{0}_to_{1}".format(host_part, win_type)
+        self.name = name
+
+    def __eq__(self, other):
+        return self.name == other.name
+
     def definition(self):
-        if self.array or self.dyn_array:
-            return self._generate_array_conversion_func()
+        """ Helper function for generating a conversion function for array operands. """
+
+        body = ""
+
+        if self.conv:
+            body += "#if defined(USE_STRUCT_CONVERSION)\n"
+        else:
+            body += "#if !defined(USE_STRUCT_CONVERSION)\n"
+
+        needs_alloc = self.direction != Direction.OUTPUT and self.array.needs_alloc(self.conv, self.unwrap)
+
+        if self.conv and self.array.is_struct() and self.array.struct.needs_host_type():
+            host_type = "{0}_host".format(self.type)
+        else:
+            host_type = self.type
+
+        if self.conv:
+            if self.direction == Direction.OUTPUT:
+                params = ["const {0} *in".format(host_type), "{0} *out".format(self.type), "uint32_t count"]
+                return_type = None
+            else:
+                params = ["const {0} *in".format(self.type), "uint32_t count"]
+                return_type = host_type
+        else:
+            params = ["const {0} *in".format(self.type), "uint32_t count"]
+            return_type = self.type
+
+        # Generate function prototype.
+        if return_type:
+            body += "static inline {0} *{1}(".format(return_type, self.name)
+        else:
+            body += "static inline void {0}(".format(self.name)
+        if needs_alloc:
+            body += "struct conversion_context *ctx, "
+        body += ", ".join(p for p in params)
+        body += ")\n{\n"
+
+        if return_type:
+            body += "    {0} *out;\n".format(return_type)
+
+        body += "    unsigned int i;\n\n"
+
+        if return_type:
+            body += "    if (!in || !count) return NULL;\n\n"
+        else:
+            body += "    if (!in) return;\n\n"
+
+        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 self.array.is_struct():
+            for m in self.array.struct:
+                # TODO: support copying of pNext extension structures!
+                # Luckily though no extension struct at this point needs conversion.
+                body += "        " + m.copy("in[i].", "out[i].", self.direction, self.conv, self.unwrap)
+
+        elif self.array.is_handle() and self.direction == Direction.INPUT:
+            body += "        out[i] = " + self.array.handle.driver_handle("in[i]") + ";\n"
         else:
-            return self._generate_conversion_func()
+            LOGGER.warning("Unhandled conversion operand type")
+            body += "        out[i] = in[i];\n"
+
+        body += "    }\n"
+        if return_type:
+            body += "\n    return out;\n"
+        body += "}\n"
+
+        body += "#endif /* USE_STRUCT_CONVERSION */\n"
+
+        body += "\n"
+
+        return body
+

class StructChainConversionFunction(object):
     def __init__(self, direction, struct, ignores):

[PATCH 6/8] winevulkan: Use struct conversion functions for array conversion implementations.

[Jacek Caban]

From: Jacek Caban

---
 dlls/winevulkan/make_vulkan     |   34 +-
 dlls/winevulkan/vulkan_thunks.c | 1117 ++++++++++++++++++++-----------
 2 files changed, 744 insertions(+), 407 deletions(-)

diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan
index 2ea6446da4e..56f3db64389 100755
--- a/dlls/winevulkan/make_vulkan
+++ b/dlls/winevulkan/make_vulkan
@@ -1203,18 +1203,18 @@ class VkVariable(object):

conversions.extend(m.get_conversions(unwrap, is_const))

-        if self.is_static_array() or self.is_dynamic_array():
             for conv in [False, True]:
                 if self.needs_conversion(conv, unwrap, Direction.INPUT, parent_const):
-                    conversions.append(ArrayConversionFunction(self, Direction.INPUT, conv, unwrap))
+                    conversions.append(StructConversionFunction(self.struct, Direction.INPUT, conv, unwrap))
                 if self.needs_conversion(conv, unwrap, Direction.OUTPUT, parent_const):
-                    conversions.append(ArrayConversionFunction(self, Direction.OUTPUT, conv, unwrap))
-        elif self.is_struct():
+                    conversions.append(StructConversionFunction(self.struct, Direction.OUTPUT, conv, unwrap))
+
+        if self.is_static_array() or self.is_dynamic_array():
             for conv in [False, True]:
                 if self.needs_conversion(conv, unwrap, Direction.INPUT, parent_const):
-                    conversions.append(StructConversionFunction(self.struct, Direction.INPUT, conv, unwrap))
+                    conversions.append(ArrayConversionFunction(self, Direction.INPUT, conv, unwrap))
                 if self.needs_conversion(conv, unwrap, Direction.OUTPUT, parent_const):
-                    conversions.append(StructConversionFunction(self.struct, Direction.OUTPUT, conv, unwrap))
+                    conversions.append(ArrayConversionFunction(self, Direction.OUTPUT, conv, unwrap))

return conversions

@@ -2034,14 +2034,15 @@ class StructConversionFunction(object):
             body += "#if !defined(USE_STRUCT_CONVERSION)\n"

needs_alloc = self.direction != Direction.OUTPUT and self.operand.needs_alloc(self.conv, self.unwrap)
+        host_type = self.type + "_host" if self.operand.needs_host_type() else self.type

if self.conv:
             body += "static inline void {0}(".format(self.name)

if self.direction == Direction.OUTPUT:
-                params = ["const {0}_host *in".format(self.type), "{0} *out".format(self.type)]
+                params = ["const {0} *in".format(host_type), "{0} *out".format(self.type)]
             else:
-                params = ["const {0} *in".format(self.type), "{0}_host *out".format(self.type)]
+                params = ["const {0} *in".format(self.type), "{0} *out".format(host_type)]

# Generate parameter list
             if needs_alloc:
@@ -2171,11 +2172,20 @@ class ArrayConversionFunction(object):
         body += "    {\n"

if self.array.is_struct():
-            for m in self.array.struct:
-                # TODO: support copying of pNext extension structures!
-                # Luckily though no extension struct at this point needs conversion.
-                body += "        " + m.copy("in[i].", "out[i].", self.direction, self.conv, self.unwrap)
+            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:
diff --git a/dlls/winevulkan/vulkan_thunks.c b/dlls/winevulkan/vulkan_thunks.c
index cd00aa0b6fb..7a04cfba6a7 100644
--- a/dlls/winevulkan/vulkan_thunks.c
+++ b/dlls/winevulkan/vulkan_thunks.c
@@ -113,6 +113,22 @@ static inline void convert_VkMemoryAllocateInfo_win32_to_host(const VkMemoryAllo
 }
 #endif /* USE_STRUCT_CONVERSION */

+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkCommandBufferInheritanceInfo_win32_to_host(const VkCommandBufferInheritanceInfo *in, VkCommandBufferInheritanceInfo_host *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    out->renderPass = in->renderPass;
+    out->subpass = in->subpass;
+    out->framebuffer = in->framebuffer;
+    out->occlusionQueryEnable = in->occlusionQueryEnable;
+    out->queryFlags = in->queryFlags;
+    out->pipelineStatistics = in->pipelineStatistics;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
 #if defined(USE_STRUCT_CONVERSION)
 static inline VkCommandBufferInheritanceInfo_host *convert_VkCommandBufferInheritanceInfo_array_win32_to_host(struct conversion_context *ctx, const VkCommandBufferInheritanceInfo *in, uint32_t count)
 {
@@ -124,14 +140,7 @@ static inline VkCommandBufferInheritanceInfo_host *convert_VkCommandBufferInheri
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i].sType = in[i].sType;
-        out[i].pNext = in[i].pNext;
-        out[i].renderPass = in[i].renderPass;
-        out[i].subpass = in[i].subpass;
-        out[i].framebuffer = in[i].framebuffer;
-        out[i].occlusionQueryEnable = in[i].occlusionQueryEnable;
-        out[i].queryFlags = in[i].queryFlags;
-        out[i].pipelineStatistics = in[i].pipelineStatistics;
+        convert_VkCommandBufferInheritanceInfo_win32_to_host(&in[i], &out[i]);
     }

return out;
@@ -150,6 +159,21 @@ static inline void convert_VkCommandBufferBeginInfo_win32_to_host(struct convers
 }
 #endif /* USE_STRUCT_CONVERSION */

+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkBindAccelerationStructureMemoryInfoNV_win32_to_host(const VkBindAccelerationStructureMemoryInfoNV *in, VkBindAccelerationStructureMemoryInfoNV_host *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    out->accelerationStructure = in->accelerationStructure;
+    out->memory = in->memory;
+    out->memoryOffset = in->memoryOffset;
+    out->deviceIndexCount = in->deviceIndexCount;
+    out->pDeviceIndices = in->pDeviceIndices;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
 #if defined(USE_STRUCT_CONVERSION)
 static inline VkBindAccelerationStructureMemoryInfoNV_host *convert_VkBindAccelerationStructureMemoryInfoNV_array_win32_to_host(struct conversion_context *ctx, const VkBindAccelerationStructureMemoryInfoNV *in, uint32_t count)
 {
@@ -161,19 +185,26 @@ static inline VkBindAccelerationStructureMemoryInfoNV_host *convert_VkBindAccele
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i].sType = in[i].sType;
-        out[i].pNext = in[i].pNext;
-        out[i].accelerationStructure = in[i].accelerationStructure;
-        out[i].memory = in[i].memory;
-        out[i].memoryOffset = in[i].memoryOffset;
-        out[i].deviceIndexCount = in[i].deviceIndexCount;
-        out[i].pDeviceIndices = in[i].pDeviceIndices;
+        convert_VkBindAccelerationStructureMemoryInfoNV_win32_to_host(&in[i], &out[i]);
     }

return out;
 }
 #endif /* USE_STRUCT_CONVERSION */

+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkBindBufferMemoryInfo_win32_to_host(const VkBindBufferMemoryInfo *in, VkBindBufferMemoryInfo_host *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    out->buffer = in->buffer;
+    out->memory = in->memory;
+    out->memoryOffset = in->memoryOffset;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
 #if defined(USE_STRUCT_CONVERSION)
 static inline VkBindBufferMemoryInfo_host *convert_VkBindBufferMemoryInfo_array_win32_to_host(struct conversion_context *ctx, const VkBindBufferMemoryInfo *in, uint32_t count)
 {
@@ -185,17 +216,26 @@ static inline VkBindBufferMemoryInfo_host *convert_VkBindBufferMemoryInfo_array_
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i].sType = in[i].sType;
-        out[i].pNext = in[i].pNext;
-        out[i].buffer = in[i].buffer;
-        out[i].memory = in[i].memory;
-        out[i].memoryOffset = in[i].memoryOffset;
+        convert_VkBindBufferMemoryInfo_win32_to_host(&in[i], &out[i]);
     }

return out;
 }
 #endif /* USE_STRUCT_CONVERSION */

+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkBindImageMemoryInfo_win32_to_host(const VkBindImageMemoryInfo *in, VkBindImageMemoryInfo_host *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    out->image = in->image;
+    out->memory = in->memory;
+    out->memoryOffset = in->memoryOffset;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
 #if defined(USE_STRUCT_CONVERSION)
 static inline VkBindImageMemoryInfo_host *convert_VkBindImageMemoryInfo_array_win32_to_host(struct conversion_context *ctx, const VkBindImageMemoryInfo *in, uint32_t count)
 {
@@ -207,17 +247,32 @@ static inline VkBindImageMemoryInfo_host *convert_VkBindImageMemoryInfo_array_wi
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i].sType = in[i].sType;
-        out[i].pNext = in[i].pNext;
-        out[i].image = in[i].image;
-        out[i].memory = in[i].memory;
-        out[i].memoryOffset = in[i].memoryOffset;
+        convert_VkBindImageMemoryInfo_win32_to_host(&in[i], &out[i]);
     }

return out;
 }
 #endif /* USE_STRUCT_CONVERSION */

+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkAccelerationStructureBuildGeometryInfoKHR_win32_to_host(const VkAccelerationStructureBuildGeometryInfoKHR *in, VkAccelerationStructureBuildGeometryInfoKHR_host *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    out->type = in->type;
+    out->flags = in->flags;
+    out->mode = in->mode;
+    out->srcAccelerationStructure = in->srcAccelerationStructure;
+    out->dstAccelerationStructure = in->dstAccelerationStructure;
+    out->geometryCount = in->geometryCount;
+    out->pGeometries = in->pGeometries;
+    out->ppGeometries = in->ppGeometries;
+    out->scratchData = in->scratchData;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
 #if defined(USE_STRUCT_CONVERSION)
 static inline VkAccelerationStructureBuildGeometryInfoKHR_host *convert_VkAccelerationStructureBuildGeometryInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureBuildGeometryInfoKHR *in, uint32_t count)
 {
@@ -229,23 +284,34 @@ static inline VkAccelerationStructureBuildGeometryInfoKHR_host *convert_VkAccele
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i].sType = in[i].sType;
-        out[i].pNext = in[i].pNext;
-        out[i].type = in[i].type;
-        out[i].flags = in[i].flags;
-        out[i].mode = in[i].mode;
-        out[i].srcAccelerationStructure = in[i].srcAccelerationStructure;
-        out[i].dstAccelerationStructure = in[i].dstAccelerationStructure;
-        out[i].geometryCount = in[i].geometryCount;
-        out[i].pGeometries = in[i].pGeometries;
-        out[i].ppGeometries = in[i].ppGeometries;
-        out[i].scratchData = in[i].scratchData;
+        convert_VkAccelerationStructureBuildGeometryInfoKHR_win32_to_host(&in[i], &out[i]);
     }

return out;
 }
 #endif /* USE_STRUCT_CONVERSION */

+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkMicromapBuildInfoEXT_win32_to_host(const VkMicromapBuildInfoEXT *in, VkMicromapBuildInfoEXT_host *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    out->type = in->type;
+    out->flags = in->flags;
+    out->mode = in->mode;
+    out->dstMicromap = in->dstMicromap;
+    out->usageCountsCount = in->usageCountsCount;
+    out->pUsageCounts = in->pUsageCounts;
+    out->ppUsageCounts = in->ppUsageCounts;
+    out->data = in->data;
+    out->scratchData = in->scratchData;
+    out->triangleArray = in->triangleArray;
+    out->triangleArrayStride = in->triangleArrayStride;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
 #if defined(USE_STRUCT_CONVERSION)
 static inline VkMicromapBuildInfoEXT_host *convert_VkMicromapBuildInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkMicromapBuildInfoEXT *in, uint32_t count)
 {
@@ -257,19 +323,7 @@ static inline VkMicromapBuildInfoEXT_host *convert_VkMicromapBuildInfoEXT_array_
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i].sType = in[i].sType;
-        out[i].pNext = in[i].pNext;
-        out[i].type = in[i].type;
-        out[i].flags = in[i].flags;
-        out[i].mode = in[i].mode;
-        out[i].dstMicromap = in[i].dstMicromap;
-        out[i].usageCountsCount = in[i].usageCountsCount;
-        out[i].pUsageCounts = in[i].pUsageCounts;
-        out[i].ppUsageCounts = in[i].ppUsageCounts;
-        out[i].data = in[i].data;
-        out[i].scratchData = in[i].scratchData;
-        out[i].triangleArray = in[i].triangleArray;
-        out[i].triangleArrayStride = in[i].triangleArrayStride;
+        convert_VkMicromapBuildInfoEXT_win32_to_host(&in[i], &out[i]);
     }

return out;
@@ -304,6 +358,24 @@ static inline void convert_VkRenderPassBeginInfo_win32_to_host(const VkRenderPas
 }
 #endif /* USE_STRUCT_CONVERSION */

+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkRenderingAttachmentInfo_win32_to_host(const VkRenderingAttachmentInfo *in, VkRenderingAttachmentInfo_host *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    out->imageView = in->imageView;
+    out->imageLayout = in->imageLayout;
+    out->resolveMode = in->resolveMode;
+    out->resolveImageView = in->resolveImageView;
+    out->resolveImageLayout = in->resolveImageLayout;
+    out->loadOp = in->loadOp;
+    out->storeOp = in->storeOp;
+    out->clearValue = in->clearValue;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
 #if defined(USE_STRUCT_CONVERSION)
 static inline VkRenderingAttachmentInfo_host *convert_VkRenderingAttachmentInfo_array_win32_to_host(struct conversion_context *ctx, const VkRenderingAttachmentInfo *in, uint32_t count)
 {
@@ -315,16 +387,7 @@ static inline VkRenderingAttachmentInfo_host *convert_VkRenderingAttachmentInfo_
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i].sType = in[i].sType;
-        out[i].pNext = in[i].pNext;
-        out[i].imageView = in[i].imageView;
-        out[i].imageLayout = in[i].imageLayout;
-        out[i].resolveMode = in[i].resolveMode;
-        out[i].resolveImageView = in[i].resolveImageView;
-        out[i].resolveImageLayout = in[i].resolveImageLayout;
-        out[i].loadOp = in[i].loadOp;
-        out[i].storeOp = in[i].storeOp;
-        out[i].clearValue = in[i].clearValue;
+        convert_VkRenderingAttachmentInfo_win32_to_host(&in[i], &out[i]);
     }

return out;
@@ -411,6 +474,19 @@ static inline void convert_VkGeometryDataNV_win32_to_host(const VkGeometryDataNV
 }
 #endif /* USE_STRUCT_CONVERSION */

+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkGeometryNV_win32_to_host(const VkGeometryNV *in, VkGeometryNV_host *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    out->geometryType = in->geometryType;
+    convert_VkGeometryDataNV_win32_to_host(&in->geometry, &out->geometry);
+    out->flags = in->flags;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
 #if defined(USE_STRUCT_CONVERSION)
 static inline VkGeometryNV_host *convert_VkGeometryNV_array_win32_to_host(struct conversion_context *ctx, const VkGeometryNV *in, uint32_t count)
 {
@@ -422,11 +498,7 @@ static inline VkGeometryNV_host *convert_VkGeometryNV_array_win32_to_host(struct
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i].sType = in[i].sType;
-        out[i].pNext = in[i].pNext;
-        out[i].geometryType = in[i].geometryType;
-        convert_VkGeometryDataNV_win32_to_host(&in[i].geometry, &out[i].geometry);
-        out[i].flags = in[i].flags;
+        convert_VkGeometryNV_win32_to_host(&in[i], &out[i]);
     }

return out;
@@ -474,6 +546,17 @@ static inline void convert_VkCopyAccelerationStructureToMemoryInfoKHR_win32_to_h
 }
 #endif /* USE_STRUCT_CONVERSION */

+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkBufferCopy_win32_to_host(const VkBufferCopy *in, VkBufferCopy_host *out)
+{
+    if (!in) return;
+
+    out->srcOffset = in->srcOffset;
+    out->dstOffset = in->dstOffset;
+    out->size = in->size;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
 #if defined(USE_STRUCT_CONVERSION)
 static inline VkBufferCopy_host *convert_VkBufferCopy_array_win32_to_host(struct conversion_context *ctx, const VkBufferCopy *in, uint32_t count)
 {
@@ -485,15 +568,26 @@ static inline VkBufferCopy_host *convert_VkBufferCopy_array_win32_to_host(struct
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i].srcOffset = in[i].srcOffset;
-        out[i].dstOffset = in[i].dstOffset;
-        out[i].size = in[i].size;
+        convert_VkBufferCopy_win32_to_host(&in[i], &out[i]);
     }

return out;
 }
 #endif /* USE_STRUCT_CONVERSION */

+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkBufferCopy2_win32_to_host(const VkBufferCopy2 *in, VkBufferCopy2_host *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    out->srcOffset = in->srcOffset;
+    out->dstOffset = in->dstOffset;
+    out->size = in->size;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
 #if defined(USE_STRUCT_CONVERSION)
 static inline VkBufferCopy2_host *convert_VkBufferCopy2_array_win32_to_host(struct conversion_context *ctx, const VkBufferCopy2 *in, uint32_t count)
 {
@@ -505,11 +599,7 @@ static inline VkBufferCopy2_host *convert_VkBufferCopy2_array_win32_to_host(stru
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i].sType = in[i].sType;
-        out[i].pNext = in[i].pNext;
-        out[i].srcOffset = in[i].srcOffset;
-        out[i].dstOffset = in[i].dstOffset;
-        out[i].size = in[i].size;
+        convert_VkBufferCopy2_win32_to_host(&in[i], &out[i]);
     }

return out;
@@ -530,6 +620,20 @@ static inline void convert_VkCopyBufferInfo2_win32_to_host(struct conversion_con
 }
 #endif /* USE_STRUCT_CONVERSION */

+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkBufferImageCopy_win32_to_host(const VkBufferImageCopy *in, VkBufferImageCopy_host *out)
+{
+    if (!in) return;
+
+    out->bufferOffset = in->bufferOffset;
+    out->bufferRowLength = in->bufferRowLength;
+    out->bufferImageHeight = in->bufferImageHeight;
+    out->imageSubresource = in->imageSubresource;
+    out->imageOffset = in->imageOffset;
+    out->imageExtent = in->imageExtent;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
 #if defined(USE_STRUCT_CONVERSION)
 static inline VkBufferImageCopy_host *convert_VkBufferImageCopy_array_win32_to_host(struct conversion_context *ctx, const VkBufferImageCopy *in, uint32_t count)
 {
@@ -541,18 +645,29 @@ static inline VkBufferImageCopy_host *convert_VkBufferImageCopy_array_win32_to_h
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i].bufferOffset = in[i].bufferOffset;
-        out[i].bufferRowLength = in[i].bufferRowLength;
-        out[i].bufferImageHeight = in[i].bufferImageHeight;
-        out[i].imageSubresource = in[i].imageSubresource;
-        out[i].imageOffset = in[i].imageOffset;
-        out[i].imageExtent = in[i].imageExtent;
+        convert_VkBufferImageCopy_win32_to_host(&in[i], &out[i]);
     }

return out;
 }
 #endif /* USE_STRUCT_CONVERSION */

+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkBufferImageCopy2_win32_to_host(const VkBufferImageCopy2 *in, VkBufferImageCopy2_host *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    out->bufferOffset = in->bufferOffset;
+    out->bufferRowLength = in->bufferRowLength;
+    out->bufferImageHeight = in->bufferImageHeight;
+    out->imageSubresource = in->imageSubresource;
+    out->imageOffset = in->imageOffset;
+    out->imageExtent = in->imageExtent;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
 #if defined(USE_STRUCT_CONVERSION)
 static inline VkBufferImageCopy2_host *convert_VkBufferImageCopy2_array_win32_to_host(struct conversion_context *ctx, const VkBufferImageCopy2 *in, uint32_t count)
 {
@@ -564,14 +679,7 @@ static inline VkBufferImageCopy2_host *convert_VkBufferImageCopy2_array_win32_to
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i].sType = in[i].sType;
-        out[i].pNext = in[i].pNext;
-        out[i].bufferOffset = in[i].bufferOffset;
-        out[i].bufferRowLength = in[i].bufferRowLength;
-        out[i].bufferImageHeight = in[i].bufferImageHeight;
-        out[i].imageSubresource = in[i].imageSubresource;
-        out[i].imageOffset = in[i].imageOffset;
-        out[i].imageExtent = in[i].imageExtent;
+        convert_VkBufferImageCopy2_win32_to_host(&in[i], &out[i]);
     }

return out;
@@ -698,6 +806,19 @@ static inline void convert_VkCuLaunchInfoNVX_win32_to_host(const VkCuLaunchInfoN
 }
 #endif /* USE_STRUCT_CONVERSION */

+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkDecompressMemoryRegionNV_win32_to_host(const VkDecompressMemoryRegionNV *in, VkDecompressMemoryRegionNV_host *out)
+{
+    if (!in) return;
+
+    out->srcAddress = in->srcAddress;
+    out->dstAddress = in->dstAddress;
+    out->compressedSize = in->compressedSize;
+    out->decompressedSize = in->decompressedSize;
+    out->decompressionMethod = in->decompressionMethod;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
 #if defined(USE_STRUCT_CONVERSION)
 static inline VkDecompressMemoryRegionNV_host *convert_VkDecompressMemoryRegionNV_array_win32_to_host(struct conversion_context *ctx, const VkDecompressMemoryRegionNV *in, uint32_t count)
 {
@@ -709,11 +830,7 @@ static inline VkDecompressMemoryRegionNV_host *convert_VkDecompressMemoryRegionN
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i].srcAddress = in[i].srcAddress;
-        out[i].dstAddress = in[i].dstAddress;
-        out[i].compressedSize = in[i].compressedSize;
-        out[i].decompressedSize = in[i].decompressedSize;
-        out[i].decompressionMethod = in[i].decompressionMethod;
+        convert_VkDecompressMemoryRegionNV_win32_to_host(&in[i], &out[i]);
     }

return out;
@@ -756,6 +873,16 @@ static inline VkCommandBuffer *convert_VkCommandBuffer_array_win32_to_host(struc
 }
 #endif /* USE_STRUCT_CONVERSION */

+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkIndirectCommandsStreamNV_win32_to_host(const VkIndirectCommandsStreamNV *in, VkIndirectCommandsStreamNV_host *out)
+{
+    if (!in) return;
+
+    out->buffer = in->buffer;
+    out->offset = in->offset;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
 #if defined(USE_STRUCT_CONVERSION)
 static inline VkIndirectCommandsStreamNV_host *convert_VkIndirectCommandsStreamNV_array_win32_to_host(struct conversion_context *ctx, const VkIndirectCommandsStreamNV *in, uint32_t count)
 {
@@ -767,8 +894,7 @@ static inline VkIndirectCommandsStreamNV_host *convert_VkIndirectCommandsStreamN
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i].buffer = in[i].buffer;
-        out[i].offset = in[i].offset;
+        convert_VkIndirectCommandsStreamNV_win32_to_host(&in[i], &out[i]);
     }

return out;
@@ -798,6 +924,23 @@ static inline void convert_VkGeneratedCommandsInfoNV_win32_to_host(struct conver
 }
 #endif /* USE_STRUCT_CONVERSION */

+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkBufferMemoryBarrier_win32_to_host(const VkBufferMemoryBarrier *in, VkBufferMemoryBarrier_host *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    out->srcAccessMask = in->srcAccessMask;
+    out->dstAccessMask = in->dstAccessMask;
+    out->srcQueueFamilyIndex = in->srcQueueFamilyIndex;
+    out->dstQueueFamilyIndex = in->dstQueueFamilyIndex;
+    out->buffer = in->buffer;
+    out->offset = in->offset;
+    out->size = in->size;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
 #if defined(USE_STRUCT_CONVERSION)
 static inline VkBufferMemoryBarrier_host *convert_VkBufferMemoryBarrier_array_win32_to_host(struct conversion_context *ctx, const VkBufferMemoryBarrier *in, uint32_t count)
 {
@@ -809,21 +952,31 @@ static inline VkBufferMemoryBarrier_host *convert_VkBufferMemoryBarrier_array_wi
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i].sType = in[i].sType;
-        out[i].pNext = in[i].pNext;
-        out[i].srcAccessMask = in[i].srcAccessMask;
-        out[i].dstAccessMask = in[i].dstAccessMask;
-        out[i].srcQueueFamilyIndex = in[i].srcQueueFamilyIndex;
-        out[i].dstQueueFamilyIndex = in[i].dstQueueFamilyIndex;
-        out[i].buffer = in[i].buffer;
-        out[i].offset = in[i].offset;
-        out[i].size = in[i].size;
+        convert_VkBufferMemoryBarrier_win32_to_host(&in[i], &out[i]);
     }

return out;
 }
 #endif /* USE_STRUCT_CONVERSION */

+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkImageMemoryBarrier_win32_to_host(const VkImageMemoryBarrier *in, VkImageMemoryBarrier_host *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    out->srcAccessMask = in->srcAccessMask;
+    out->dstAccessMask = in->dstAccessMask;
+    out->oldLayout = in->oldLayout;
+    out->newLayout = in->newLayout;
+    out->srcQueueFamilyIndex = in->srcQueueFamilyIndex;
+    out->dstQueueFamilyIndex = in->dstQueueFamilyIndex;
+    out->image = in->image;
+    out->subresourceRange = in->subresourceRange;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
 #if defined(USE_STRUCT_CONVERSION)
 static inline VkImageMemoryBarrier_host *convert_VkImageMemoryBarrier_array_win32_to_host(struct conversion_context *ctx, const VkImageMemoryBarrier *in, uint32_t count)
 {
@@ -835,22 +988,32 @@ static inline VkImageMemoryBarrier_host *convert_VkImageMemoryBarrier_array_win3
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i].sType = in[i].sType;
-        out[i].pNext = in[i].pNext;
-        out[i].srcAccessMask = in[i].srcAccessMask;
-        out[i].dstAccessMask = in[i].dstAccessMask;
-        out[i].oldLayout = in[i].oldLayout;
-        out[i].newLayout = in[i].newLayout;
-        out[i].srcQueueFamilyIndex = in[i].srcQueueFamilyIndex;
-        out[i].dstQueueFamilyIndex = in[i].dstQueueFamilyIndex;
-        out[i].image = in[i].image;
-        out[i].subresourceRange = in[i].subresourceRange;
+        convert_VkImageMemoryBarrier_win32_to_host(&in[i], &out[i]);
     }

return out;
 }
 #endif /* USE_STRUCT_CONVERSION */

+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkBufferMemoryBarrier2_win32_to_host(const VkBufferMemoryBarrier2 *in, VkBufferMemoryBarrier2_host *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    out->srcStageMask = in->srcStageMask;
+    out->srcAccessMask = in->srcAccessMask;
+    out->dstStageMask = in->dstStageMask;
+    out->dstAccessMask = in->dstAccessMask;
+    out->srcQueueFamilyIndex = in->srcQueueFamilyIndex;
+    out->dstQueueFamilyIndex = in->dstQueueFamilyIndex;
+    out->buffer = in->buffer;
+    out->offset = in->offset;
+    out->size = in->size;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
 #if defined(USE_STRUCT_CONVERSION)
 static inline VkBufferMemoryBarrier2_host *convert_VkBufferMemoryBarrier2_array_win32_to_host(struct conversion_context *ctx, const VkBufferMemoryBarrier2 *in, uint32_t count)
 {
@@ -862,23 +1025,33 @@ static inline VkBufferMemoryBarrier2_host *convert_VkBufferMemoryBarrier2_array_
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i].sType = in[i].sType;
-        out[i].pNext = in[i].pNext;
-        out[i].srcStageMask = in[i].srcStageMask;
-        out[i].srcAccessMask = in[i].srcAccessMask;
-        out[i].dstStageMask = in[i].dstStageMask;
-        out[i].dstAccessMask = in[i].dstAccessMask;
-        out[i].srcQueueFamilyIndex = in[i].srcQueueFamilyIndex;
-        out[i].dstQueueFamilyIndex = in[i].dstQueueFamilyIndex;
-        out[i].buffer = in[i].buffer;
-        out[i].offset = in[i].offset;
-        out[i].size = in[i].size;
+        convert_VkBufferMemoryBarrier2_win32_to_host(&in[i], &out[i]);
     }

return out;
 }
 #endif /* USE_STRUCT_CONVERSION */

+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkImageMemoryBarrier2_win32_to_host(const VkImageMemoryBarrier2 *in, VkImageMemoryBarrier2_host *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    out->srcStageMask = in->srcStageMask;
+    out->srcAccessMask = in->srcAccessMask;
+    out->dstStageMask = in->dstStageMask;
+    out->dstAccessMask = in->dstAccessMask;
+    out->oldLayout = in->oldLayout;
+    out->newLayout = in->newLayout;
+    out->srcQueueFamilyIndex = in->srcQueueFamilyIndex;
+    out->dstQueueFamilyIndex = in->dstQueueFamilyIndex;
+    out->image = in->image;
+    out->subresourceRange = in->subresourceRange;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
 #if defined(USE_STRUCT_CONVERSION)
 static inline VkImageMemoryBarrier2_host *convert_VkImageMemoryBarrier2_array_win32_to_host(struct conversion_context *ctx, const VkImageMemoryBarrier2 *in, uint32_t count)
 {
@@ -890,18 +1063,7 @@ static inline VkImageMemoryBarrier2_host *convert_VkImageMemoryBarrier2_array_wi
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i].sType = in[i].sType;
-        out[i].pNext = in[i].pNext;
-        out[i].srcStageMask = in[i].srcStageMask;
-        out[i].srcAccessMask = in[i].srcAccessMask;
-        out[i].dstStageMask = in[i].dstStageMask;
-        out[i].dstAccessMask = in[i].dstAccessMask;
-        out[i].oldLayout = in[i].oldLayout;
-        out[i].newLayout = in[i].newLayout;
-        out[i].srcQueueFamilyIndex = in[i].srcQueueFamilyIndex;
-        out[i].dstQueueFamilyIndex = in[i].dstQueueFamilyIndex;
-        out[i].image = in[i].image;
-        out[i].subresourceRange = in[i].subresourceRange;
+        convert_VkImageMemoryBarrier2_win32_to_host(&in[i], &out[i]);
     }

return out;
@@ -925,6 +1087,17 @@ static inline void convert_VkDependencyInfo_win32_to_host(struct conversion_cont
 }
 #endif /* USE_STRUCT_CONVERSION */

+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkDescriptorImageInfo_win32_to_host(const VkDescriptorImageInfo *in, VkDescriptorImageInfo_host *out)
+{
+    if (!in) return;
+
+    out->sampler = in->sampler;
+    out->imageView = in->imageView;
+    out->imageLayout = in->imageLayout;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
 #if defined(USE_STRUCT_CONVERSION)
 static inline VkDescriptorImageInfo_host *convert_VkDescriptorImageInfo_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorImageInfo *in, uint32_t count)
 {
@@ -936,15 +1109,24 @@ static inline VkDescriptorImageInfo_host *convert_VkDescriptorImageInfo_array_wi
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i].sampler = in[i].sampler;
-        out[i].imageView = in[i].imageView;
-        out[i].imageLayout = in[i].imageLayout;
+        convert_VkDescriptorImageInfo_win32_to_host(&in[i], &out[i]);
     }

return out;
 }
 #endif /* USE_STRUCT_CONVERSION */

+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkDescriptorBufferInfo_win32_to_host(const VkDescriptorBufferInfo *in, VkDescriptorBufferInfo_host *out)
+{
+    if (!in) return;
+
+    out->buffer = in->buffer;
+    out->offset = in->offset;
+    out->range = in->range;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
 #if defined(USE_STRUCT_CONVERSION)
 static inline VkDescriptorBufferInfo_host *convert_VkDescriptorBufferInfo_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorBufferInfo *in, uint32_t count)
 {
@@ -956,15 +1138,31 @@ static inline VkDescriptorBufferInfo_host *convert_VkDescriptorBufferInfo_array_
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i].buffer = in[i].buffer;
-        out[i].offset = in[i].offset;
-        out[i].range = in[i].range;
+        convert_VkDescriptorBufferInfo_win32_to_host(&in[i], &out[i]);
     }

return out;
 }
 #endif /* USE_STRUCT_CONVERSION */

+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkWriteDescriptorSet_win32_to_host(struct conversion_context *ctx, const VkWriteDescriptorSet *in, VkWriteDescriptorSet_host *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    out->dstSet = in->dstSet;
+    out->dstBinding = in->dstBinding;
+    out->dstArrayElement = in->dstArrayElement;
+    out->descriptorCount = in->descriptorCount;
+    out->descriptorType = in->descriptorType;
+    out->pImageInfo = convert_VkDescriptorImageInfo_array_win32_to_host(ctx, in->pImageInfo, in->descriptorCount);
+    out->pBufferInfo = convert_VkDescriptorBufferInfo_array_win32_to_host(ctx, in->pBufferInfo, in->descriptorCount);
+    out->pTexelBufferView = in->pTexelBufferView;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
 #if defined(USE_STRUCT_CONVERSION)
 static inline VkWriteDescriptorSet_host *convert_VkWriteDescriptorSet_array_win32_to_host(struct conversion_context *ctx, const VkWriteDescriptorSet *in, uint32_t count)
 {
@@ -976,16 +1174,7 @@ static inline VkWriteDescriptorSet_host *convert_VkWriteDescriptorSet_array_win3
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i].sType = in[i].sType;
-        out[i].pNext = in[i].pNext;
-        out[i].dstSet = in[i].dstSet;
-        out[i].dstBinding = in[i].dstBinding;
-        out[i].dstArrayElement = in[i].dstArrayElement;
-        out[i].descriptorCount = in[i].descriptorCount;
-        out[i].descriptorType = in[i].descriptorType;
-        out[i].pImageInfo = convert_VkDescriptorImageInfo_array_win32_to_host(ctx, in[i].pImageInfo, in[i].descriptorCount);
-        out[i].pBufferInfo = convert_VkDescriptorBufferInfo_array_win32_to_host(ctx, in[i].pBufferInfo, in[i].descriptorCount);
-        out[i].pTexelBufferView = in[i].pTexelBufferView;
+        convert_VkWriteDescriptorSet_win32_to_host(ctx, &in[i], &out[i]);
     }

return out;
@@ -1054,15 +1243,7 @@ static inline VkDependencyInfo_host *convert_VkDependencyInfo_array_win32_to_hos
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i].sType = in[i].sType;
-        out[i].pNext = in[i].pNext;
-        out[i].dependencyFlags = in[i].dependencyFlags;
-        out[i].memoryBarrierCount = in[i].memoryBarrierCount;
-        out[i].pMemoryBarriers = in[i].pMemoryBarriers;
-        out[i].bufferMemoryBarrierCount = in[i].bufferMemoryBarrierCount;
-        out[i].pBufferMemoryBarriers = convert_VkBufferMemoryBarrier2_array_win32_to_host(ctx, in[i].pBufferMemoryBarriers, in[i].bufferMemoryBarrierCount);
-        out[i].imageMemoryBarrierCount = in[i].imageMemoryBarrierCount;
-        out[i].pImageMemoryBarriers = convert_VkImageMemoryBarrier2_array_win32_to_host(ctx, in[i].pImageMemoryBarriers, in[i].imageMemoryBarrierCount);
+        convert_VkDependencyInfo_win32_to_host(ctx, &in[i], &out[i]);
     }

return out;
@@ -1143,6 +1324,21 @@ static inline void convert_VkPipelineShaderStageCreateInfo_win32_to_host(const V
 }
 #endif /* USE_STRUCT_CONVERSION */

+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkComputePipelineCreateInfo_win32_to_host(const VkComputePipelineCreateInfo *in, VkComputePipelineCreateInfo_host *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    out->flags = in->flags;
+    convert_VkPipelineShaderStageCreateInfo_win32_to_host(&in->stage, &out->stage);
+    out->layout = in->layout;
+    out->basePipelineHandle = in->basePipelineHandle;
+    out->basePipelineIndex = in->basePipelineIndex;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
 #if defined(USE_STRUCT_CONVERSION)
 static inline VkComputePipelineCreateInfo_host *convert_VkComputePipelineCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkComputePipelineCreateInfo *in, uint32_t count)
 {
@@ -1154,13 +1350,7 @@ static inline VkComputePipelineCreateInfo_host *convert_VkComputePipelineCreateI
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i].sType = in[i].sType;
-        out[i].pNext = in[i].pNext;
-        out[i].flags = in[i].flags;
-        convert_VkPipelineShaderStageCreateInfo_win32_to_host(&in[i].stage, &out[i].stage);
-        out[i].layout = in[i].layout;
-        out[i].basePipelineHandle = in[i].basePipelineHandle;
-        out[i].basePipelineIndex = in[i].basePipelineIndex;
+        convert_VkComputePipelineCreateInfo_win32_to_host(&in[i], &out[i]);
     }

return out;
@@ -1225,19 +1415,40 @@ static inline VkPipelineShaderStageCreateInfo_host *convert_VkPipelineShaderStag
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i].sType = in[i].sType;
-        out[i].pNext = in[i].pNext;
-        out[i].flags = in[i].flags;
-        out[i].stage = in[i].stage;
-        out[i].module = in[i].module;
-        out[i].pName = in[i].pName;
-        out[i].pSpecializationInfo = in[i].pSpecializationInfo;
+        convert_VkPipelineShaderStageCreateInfo_win32_to_host(&in[i], &out[i]);
     }

return out;
 }
 #endif /* USE_STRUCT_CONVERSION */

+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkGraphicsPipelineCreateInfo_win32_to_host(struct conversion_context *ctx, const VkGraphicsPipelineCreateInfo *in, VkGraphicsPipelineCreateInfo_host *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    out->flags = in->flags;
+    out->stageCount = in->stageCount;
+    out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(ctx, in->pStages, in->stageCount);
+    out->pVertexInputState = in->pVertexInputState;
+    out->pInputAssemblyState = in->pInputAssemblyState;
+    out->pTessellationState = in->pTessellationState;
+    out->pViewportState = in->pViewportState;
+    out->pRasterizationState = in->pRasterizationState;
+    out->pMultisampleState = in->pMultisampleState;
+    out->pDepthStencilState = in->pDepthStencilState;
+    out->pColorBlendState = in->pColorBlendState;
+    out->pDynamicState = in->pDynamicState;
+    out->layout = in->layout;
+    out->renderPass = in->renderPass;
+    out->subpass = in->subpass;
+    out->basePipelineHandle = in->basePipelineHandle;
+    out->basePipelineIndex = in->basePipelineIndex;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
 #if defined(USE_STRUCT_CONVERSION)
 static inline VkGraphicsPipelineCreateInfo_host *convert_VkGraphicsPipelineCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkGraphicsPipelineCreateInfo *in, uint32_t count)
 {
@@ -1249,25 +1460,7 @@ static inline VkGraphicsPipelineCreateInfo_host *convert_VkGraphicsPipelineCreat
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i].sType = in[i].sType;
-        out[i].pNext = in[i].pNext;
-        out[i].flags = in[i].flags;
-        out[i].stageCount = in[i].stageCount;
-        out[i].pStages = convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(ctx, in[i].pStages, in[i].stageCount);
-        out[i].pVertexInputState = in[i].pVertexInputState;
-        out[i].pInputAssemblyState = in[i].pInputAssemblyState;
-        out[i].pTessellationState = in[i].pTessellationState;
-        out[i].pViewportState = in[i].pViewportState;
-        out[i].pRasterizationState = in[i].pRasterizationState;
-        out[i].pMultisampleState = in[i].pMultisampleState;
-        out[i].pDepthStencilState = in[i].pDepthStencilState;
-        out[i].pColorBlendState = in[i].pColorBlendState;
-        out[i].pDynamicState = in[i].pDynamicState;
-        out[i].layout = in[i].layout;
-        out[i].renderPass = in[i].renderPass;
-        out[i].subpass = in[i].subpass;
-        out[i].basePipelineHandle = in[i].basePipelineHandle;
-        out[i].basePipelineIndex = in[i].basePipelineIndex;
+        convert_VkGraphicsPipelineCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
     }

return out;
@@ -1290,6 +1483,29 @@ static inline void convert_VkImageViewCreateInfo_win32_to_host(const VkImageView
 }
 #endif /* USE_STRUCT_CONVERSION */

+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkIndirectCommandsLayoutTokenNV_win32_to_host(const VkIndirectCommandsLayoutTokenNV *in, VkIndirectCommandsLayoutTokenNV_host *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    out->tokenType = in->tokenType;
+    out->stream = in->stream;
+    out->offset = in->offset;
+    out->vertexBindingUnit = in->vertexBindingUnit;
+    out->vertexDynamicStride = in->vertexDynamicStride;
+    out->pushconstantPipelineLayout = in->pushconstantPipelineLayout;
+    out->pushconstantShaderStageFlags = in->pushconstantShaderStageFlags;
+    out->pushconstantOffset = in->pushconstantOffset;
+    out->pushconstantSize = in->pushconstantSize;
+    out->indirectStateFlags = in->indirectStateFlags;
+    out->indexTypeCount = in->indexTypeCount;
+    out->pIndexTypes = in->pIndexTypes;
+    out->pIndexTypeValues = in->pIndexTypeValues;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
 #if defined(USE_STRUCT_CONVERSION)
 static inline VkIndirectCommandsLayoutTokenNV_host *convert_VkIndirectCommandsLayoutTokenNV_array_win32_to_host(struct conversion_context *ctx, const VkIndirectCommandsLayoutTokenNV *in, uint32_t count)
 {
@@ -1301,21 +1517,7 @@ static inline VkIndirectCommandsLayoutTokenNV_host *convert_VkIndirectCommandsLa
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i].sType = in[i].sType;
-        out[i].pNext = in[i].pNext;
-        out[i].tokenType = in[i].tokenType;
-        out[i].stream = in[i].stream;
-        out[i].offset = in[i].offset;
-        out[i].vertexBindingUnit = in[i].vertexBindingUnit;
-        out[i].vertexDynamicStride = in[i].vertexDynamicStride;
-        out[i].pushconstantPipelineLayout = in[i].pushconstantPipelineLayout;
-        out[i].pushconstantShaderStageFlags = in[i].pushconstantShaderStageFlags;
-        out[i].pushconstantOffset = in[i].pushconstantOffset;
-        out[i].pushconstantSize = in[i].pushconstantSize;
-        out[i].indirectStateFlags = in[i].indirectStateFlags;
-        out[i].indexTypeCount = in[i].indexTypeCount;
-        out[i].pIndexTypes = in[i].pIndexTypes;
-        out[i].pIndexTypeValues = in[i].pIndexTypeValues;
+        convert_VkIndirectCommandsLayoutTokenNV_win32_to_host(&in[i], &out[i]);
     }

return out;
@@ -1354,6 +1556,28 @@ static inline void convert_VkMicromapCreateInfoEXT_win32_to_host(const VkMicroma
 }
 #endif /* USE_STRUCT_CONVERSION */

+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkRayTracingPipelineCreateInfoKHR_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoKHR *in, VkRayTracingPipelineCreateInfoKHR_host *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    out->flags = in->flags;
+    out->stageCount = in->stageCount;
+    out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(ctx, in->pStages, in->stageCount);
+    out->groupCount = in->groupCount;
+    out->pGroups = in->pGroups;
+    out->maxPipelineRayRecursionDepth = in->maxPipelineRayRecursionDepth;
+    out->pLibraryInfo = in->pLibraryInfo;
+    out->pLibraryInterface = in->pLibraryInterface;
+    out->pDynamicState = in->pDynamicState;
+    out->layout = in->layout;
+    out->basePipelineHandle = in->basePipelineHandle;
+    out->basePipelineIndex = in->basePipelineIndex;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
 #if defined(USE_STRUCT_CONVERSION)
 static inline VkRayTracingPipelineCreateInfoKHR_host *convert_VkRayTracingPipelineCreateInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoKHR *in, uint32_t count)
 {
@@ -1365,26 +1589,32 @@ static inline VkRayTracingPipelineCreateInfoKHR_host *convert_VkRayTracingPipeli
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i].sType = in[i].sType;
-        out[i].pNext = in[i].pNext;
-        out[i].flags = in[i].flags;
-        out[i].stageCount = in[i].stageCount;
-        out[i].pStages = convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(ctx, in[i].pStages, in[i].stageCount);
-        out[i].groupCount = in[i].groupCount;
-        out[i].pGroups = in[i].pGroups;
-        out[i].maxPipelineRayRecursionDepth = in[i].maxPipelineRayRecursionDepth;
-        out[i].pLibraryInfo = in[i].pLibraryInfo;
-        out[i].pLibraryInterface = in[i].pLibraryInterface;
-        out[i].pDynamicState = in[i].pDynamicState;
-        out[i].layout = in[i].layout;
-        out[i].basePipelineHandle = in[i].basePipelineHandle;
-        out[i].basePipelineIndex = in[i].basePipelineIndex;
+        convert_VkRayTracingPipelineCreateInfoKHR_win32_to_host(ctx, &in[i], &out[i]);
     }

return out;
 }
 #endif /* USE_STRUCT_CONVERSION */

+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkRayTracingPipelineCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoNV *in, VkRayTracingPipelineCreateInfoNV_host *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    out->flags = in->flags;
+    out->stageCount = in->stageCount;
+    out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(ctx, in->pStages, in->stageCount);
+    out->groupCount = in->groupCount;
+    out->pGroups = in->pGroups;
+    out->maxRecursionDepth = in->maxRecursionDepth;
+    out->layout = in->layout;
+    out->basePipelineHandle = in->basePipelineHandle;
+    out->basePipelineIndex = in->basePipelineIndex;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
 #if defined(USE_STRUCT_CONVERSION)
 static inline VkRayTracingPipelineCreateInfoNV_host *convert_VkRayTracingPipelineCreateInfoNV_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoNV *in, uint32_t count)
 {
@@ -1396,17 +1626,7 @@ static inline VkRayTracingPipelineCreateInfoNV_host *convert_VkRayTracingPipelin
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i].sType = in[i].sType;
-        out[i].pNext = in[i].pNext;
-        out[i].flags = in[i].flags;
-        out[i].stageCount = in[i].stageCount;
-        out[i].pStages = convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(ctx, in[i].pStages, in[i].stageCount);
-        out[i].groupCount = in[i].groupCount;
-        out[i].pGroups = in[i].pGroups;
-        out[i].maxRecursionDepth = in[i].maxRecursionDepth;
-        out[i].layout = in[i].layout;
-        out[i].basePipelineHandle = in[i].basePipelineHandle;
-        out[i].basePipelineIndex = in[i].basePipelineIndex;
+        convert_VkRayTracingPipelineCreateInfoNV_win32_to_host(ctx, &in[i], &out[i]);
     }

return out;
@@ -1521,6 +1741,19 @@ static inline void convert_VkDebugMarkerObjectTagInfoEXT_win32_to_host(const VkD
 }
 #endif /* USE_STRUCT_CONVERSION */

+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkMappedMemoryRange_win32_to_host(const VkMappedMemoryRange *in, VkMappedMemoryRange_host *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    out->memory = in->memory;
+    out->offset = in->offset;
+    out->size = in->size;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
 #if defined(USE_STRUCT_CONVERSION)
 static inline VkMappedMemoryRange_host *convert_VkMappedMemoryRange_array_win32_to_host(struct conversion_context *ctx, const VkMappedMemoryRange *in, uint32_t count)
 {
@@ -1532,36 +1765,13 @@ static inline VkMappedMemoryRange_host *convert_VkMappedMemoryRange_array_win32_
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i].sType = in[i].sType;
-        out[i].pNext = in[i].pNext;
-        out[i].memory = in[i].memory;
-        out[i].offset = in[i].offset;
-        out[i].size = in[i].size;
+        convert_VkMappedMemoryRange_win32_to_host(&in[i], &out[i]);
     }

return out;
 }
 #endif /* USE_STRUCT_CONVERSION */

-#if defined(USE_STRUCT_CONVERSION)
-static inline void convert_VkAccelerationStructureBuildGeometryInfoKHR_win32_to_host(const VkAccelerationStructureBuildGeometryInfoKHR *in, VkAccelerationStructureBuildGeometryInfoKHR_host *out)
-{
-    if (!in) return;
-
-    out->sType = in->sType;
-    out->pNext = in->pNext;
-    out->type = in->type;
-    out->flags = in->flags;
-    out->mode = in->mode;
-    out->srcAccelerationStructure = in->srcAccelerationStructure;
-    out->dstAccelerationStructure = in->dstAccelerationStructure;
-    out->geometryCount = in->geometryCount;
-    out->pGeometries = in->pGeometries;
-    out->ppGeometries = in->ppGeometries;
-    out->scratchData = in->scratchData;
-}
-#endif /* USE_STRUCT_CONVERSION */
-
 #if defined(USE_STRUCT_CONVERSION)
 static inline void convert_VkAccelerationStructureBuildSizesInfoKHR_win32_to_host(const VkAccelerationStructureBuildSizesInfoKHR *in, VkAccelerationStructureBuildSizesInfoKHR_host *out)
 {
@@ -1709,14 +1919,7 @@ static inline VkBufferCreateInfo_host *convert_VkBufferCreateInfo_array_win32_to
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i].sType = in[i].sType;
-        out[i].pNext = in[i].pNext;
-        out[i].flags = in[i].flags;
-        out[i].size = in[i].size;
-        out[i].usage = in[i].usage;
-        out[i].sharingMode = in[i].sharingMode;
-        out[i].queueFamilyIndexCount = in[i].queueFamilyIndexCount;
-        out[i].pQueueFamilyIndices = in[i].pQueueFamilyIndices;
+        convert_VkBufferCreateInfo_win32_to_host(&in[i], &out[i]);
     }

return out;
@@ -1760,6 +1963,17 @@ static inline void convert_VkDeviceFaultCountsEXT_host_to_win32(const VkDeviceFa
 }
 #endif /* USE_STRUCT_CONVERSION */

+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkDeviceFaultAddressInfoEXT_win32_to_host(const VkDeviceFaultAddressInfoEXT *in, VkDeviceFaultAddressInfoEXT_host *out)
+{
+    if (!in) return;
+
+    out->addressType = in->addressType;
+    out->reportedAddress = in->reportedAddress;
+    out->addressPrecision = in->addressPrecision;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
 #if defined(USE_STRUCT_CONVERSION)
 static inline VkDeviceFaultAddressInfoEXT_host *convert_VkDeviceFaultAddressInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDeviceFaultAddressInfoEXT *in, uint32_t count)
 {
@@ -1771,15 +1985,24 @@ static inline VkDeviceFaultAddressInfoEXT_host *convert_VkDeviceFaultAddressInfo
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i].addressType = in[i].addressType;
-        out[i].reportedAddress = in[i].reportedAddress;
-        out[i].addressPrecision = in[i].addressPrecision;
+        convert_VkDeviceFaultAddressInfoEXT_win32_to_host(&in[i], &out[i]);
     }

return out;
 }
 #endif /* USE_STRUCT_CONVERSION */

+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkDeviceFaultVendorInfoEXT_win32_to_host(const VkDeviceFaultVendorInfoEXT *in, VkDeviceFaultVendorInfoEXT_host *out)
+{
+    if (!in) return;
+
+    memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
+    out->vendorFaultCode = in->vendorFaultCode;
+    out->vendorFaultData = in->vendorFaultData;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
 #if defined(USE_STRUCT_CONVERSION)
 static inline VkDeviceFaultVendorInfoEXT_host *convert_VkDeviceFaultVendorInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDeviceFaultVendorInfoEXT *in, uint32_t count)
 {
@@ -1791,9 +2014,7 @@ static inline VkDeviceFaultVendorInfoEXT_host *convert_VkDeviceFaultVendorInfoEX
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        memcpy(out[i].description, in[i].description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
-        out[i].vendorFaultCode = in[i].vendorFaultCode;
-        out[i].vendorFaultData = in[i].vendorFaultData;
+        convert_VkDeviceFaultVendorInfoEXT_win32_to_host(&in[i], &out[i]);
     }

return out;
@@ -1942,27 +2163,6 @@ static inline void convert_VkMemoryGetWin32HandleInfoKHR_win32_to_host(const VkM
 }
 #endif /* USE_STRUCT_CONVERSION */

-#if defined(USE_STRUCT_CONVERSION)
-static inline void convert_VkMicromapBuildInfoEXT_win32_to_host(const VkMicromapBuildInfoEXT *in, VkMicromapBuildInfoEXT_host *out)
-{
-    if (!in) return;
-
-    out->sType = in->sType;
-    out->pNext = in->pNext;
-    out->type = in->type;
-    out->flags = in->flags;
-    out->mode = in->mode;
-    out->dstMicromap = in->dstMicromap;
-    out->usageCountsCount = in->usageCountsCount;
-    out->pUsageCounts = in->pUsageCounts;
-    out->ppUsageCounts = in->ppUsageCounts;
-    out->data = in->data;
-    out->scratchData = in->scratchData;
-    out->triangleArray = in->triangleArray;
-    out->triangleArrayStride = in->triangleArrayStride;
-}
-#endif /* USE_STRUCT_CONVERSION */
-
 #if defined(USE_STRUCT_CONVERSION)
 static inline void convert_VkMicromapBuildSizesInfoEXT_win32_to_host(const VkMicromapBuildSizesInfoEXT *in, VkMicromapBuildSizesInfoEXT_host *out)
 {
@@ -2023,6 +2223,16 @@ static inline void convert_VkImageFormatProperties2_host_to_win32(const VkImageF
 }
 #endif /* USE_STRUCT_CONVERSION */

+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkMemoryHeap_host_to_win32(const VkMemoryHeap_host *in, VkMemoryHeap *out)
+{
+    if (!in) return;
+
+    out->size = in->size;
+    out->flags = in->flags;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
 #if defined(USE_STRUCT_CONVERSION)
 static inline void convert_VkMemoryHeap_array_host_to_win32(const VkMemoryHeap_host *in, VkMemoryHeap *out, uint32_t count)
 {
@@ -2032,8 +2242,7 @@ static inline void convert_VkMemoryHeap_array_host_to_win32(const VkMemoryHeap_h

for (i = 0; i < count; i++)
     {
-        out[i].size = in[i].size;
-        out[i].flags = in[i].flags;
+        convert_VkMemoryHeap_host_to_win32(&in[i], &out[i]);
     }
 }
 #endif /* USE_STRUCT_CONVERSION */
@@ -2290,6 +2499,19 @@ static inline void convert_VkPipelineInfoEXT_win32_to_host(const VkPipelineInfoE
 }
 #endif /* USE_STRUCT_CONVERSION */

+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkSparseMemoryBind_win32_to_host(const VkSparseMemoryBind *in, VkSparseMemoryBind_host *out)
+{
+    if (!in) return;
+
+    out->resourceOffset = in->resourceOffset;
+    out->size = in->size;
+    out->memory = in->memory;
+    out->memoryOffset = in->memoryOffset;
+    out->flags = in->flags;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
 #if defined(USE_STRUCT_CONVERSION)
 static inline VkSparseMemoryBind_host *convert_VkSparseMemoryBind_array_win32_to_host(struct conversion_context *ctx, const VkSparseMemoryBind *in, uint32_t count)
 {
@@ -2301,17 +2523,24 @@ static inline VkSparseMemoryBind_host *convert_VkSparseMemoryBind_array_win32_to
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i].resourceOffset = in[i].resourceOffset;
-        out[i].size = in[i].size;
-        out[i].memory = in[i].memory;
-        out[i].memoryOffset = in[i].memoryOffset;
-        out[i].flags = in[i].flags;
+        convert_VkSparseMemoryBind_win32_to_host(&in[i], &out[i]);
     }

return out;
 }
 #endif /* USE_STRUCT_CONVERSION */

+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkSparseBufferMemoryBindInfo_win32_to_host(struct conversion_context *ctx, const VkSparseBufferMemoryBindInfo *in, VkSparseBufferMemoryBindInfo_host *out)
+{
+    if (!in) return;
+
+    out->buffer = in->buffer;
+    out->bindCount = in->bindCount;
+    out->pBinds = convert_VkSparseMemoryBind_array_win32_to_host(ctx, in->pBinds, in->bindCount);
+}
+#endif /* USE_STRUCT_CONVERSION */
+
 #if defined(USE_STRUCT_CONVERSION)
 static inline VkSparseBufferMemoryBindInfo_host *convert_VkSparseBufferMemoryBindInfo_array_win32_to_host(struct conversion_context *ctx, const VkSparseBufferMemoryBindInfo *in, uint32_t count)
 {
@@ -2323,15 +2552,24 @@ static inline VkSparseBufferMemoryBindInfo_host *convert_VkSparseBufferMemoryBin
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i].buffer = in[i].buffer;
-        out[i].bindCount = in[i].bindCount;
-        out[i].pBinds = convert_VkSparseMemoryBind_array_win32_to_host(ctx, in[i].pBinds, in[i].bindCount);
+        convert_VkSparseBufferMemoryBindInfo_win32_to_host(ctx, &in[i], &out[i]);
     }

return out;
 }
 #endif /* USE_STRUCT_CONVERSION */

+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkSparseImageOpaqueMemoryBindInfo_win32_to_host(struct conversion_context *ctx, const VkSparseImageOpaqueMemoryBindInfo *in, VkSparseImageOpaqueMemoryBindInfo_host *out)
+{
+    if (!in) return;
+
+    out->image = in->image;
+    out->bindCount = in->bindCount;
+    out->pBinds = convert_VkSparseMemoryBind_array_win32_to_host(ctx, in->pBinds, in->bindCount);
+}
+#endif /* USE_STRUCT_CONVERSION */
+
 #if defined(USE_STRUCT_CONVERSION)
 static inline VkSparseImageOpaqueMemoryBindInfo_host *convert_VkSparseImageOpaqueMemoryBindInfo_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageOpaqueMemoryBindInfo *in, uint32_t count)
 {
@@ -2343,15 +2581,27 @@ static inline VkSparseImageOpaqueMemoryBindInfo_host *convert_VkSparseImageOpaqu
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i].image = in[i].image;
-        out[i].bindCount = in[i].bindCount;
-        out[i].pBinds = convert_VkSparseMemoryBind_array_win32_to_host(ctx, in[i].pBinds, in[i].bindCount);
+        convert_VkSparseImageOpaqueMemoryBindInfo_win32_to_host(ctx, &in[i], &out[i]);
     }

return out;
 }
 #endif /* USE_STRUCT_CONVERSION */

+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkSparseImageMemoryBind_win32_to_host(const VkSparseImageMemoryBind *in, VkSparseImageMemoryBind_host *out)
+{
+    if (!in) return;
+
+    out->subresource = in->subresource;
+    out->offset = in->offset;
+    out->extent = in->extent;
+    out->memory = in->memory;
+    out->memoryOffset = in->memoryOffset;
+    out->flags = in->flags;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
 #if defined(USE_STRUCT_CONVERSION)
 static inline VkSparseImageMemoryBind_host *convert_VkSparseImageMemoryBind_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBind *in, uint32_t count)
 {
@@ -2363,18 +2613,24 @@ static inline VkSparseImageMemoryBind_host *convert_VkSparseImageMemoryBind_arra
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i].subresource = in[i].subresource;
-        out[i].offset = in[i].offset;
-        out[i].extent = in[i].extent;
-        out[i].memory = in[i].memory;
-        out[i].memoryOffset = in[i].memoryOffset;
-        out[i].flags = in[i].flags;
+        convert_VkSparseImageMemoryBind_win32_to_host(&in[i], &out[i]);
     }

return out;
 }
 #endif /* USE_STRUCT_CONVERSION */

+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkSparseImageMemoryBindInfo_win32_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBindInfo *in, VkSparseImageMemoryBindInfo_host *out)
+{
+    if (!in) return;
+
+    out->image = in->image;
+    out->bindCount = in->bindCount;
+    out->pBinds = convert_VkSparseImageMemoryBind_array_win32_to_host(ctx, in->pBinds, in->bindCount);
+}
+#endif /* USE_STRUCT_CONVERSION */
+
 #if defined(USE_STRUCT_CONVERSION)
 static inline VkSparseImageMemoryBindInfo_host *convert_VkSparseImageMemoryBindInfo_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBindInfo *in, uint32_t count)
 {
@@ -2386,15 +2642,33 @@ static inline VkSparseImageMemoryBindInfo_host *convert_VkSparseImageMemoryBindI
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i].image = in[i].image;
-        out[i].bindCount = in[i].bindCount;
-        out[i].pBinds = convert_VkSparseImageMemoryBind_array_win32_to_host(ctx, in[i].pBinds, in[i].bindCount);
+        convert_VkSparseImageMemoryBindInfo_win32_to_host(ctx, &in[i], &out[i]);
     }

return out;
 }
 #endif /* USE_STRUCT_CONVERSION */

+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkBindSparseInfo_win32_to_host(struct conversion_context *ctx, const VkBindSparseInfo *in, VkBindSparseInfo_host *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    out->waitSemaphoreCount = in->waitSemaphoreCount;
+    out->pWaitSemaphores = in->pWaitSemaphores;
+    out->bufferBindCount = in->bufferBindCount;
+    out->pBufferBinds = convert_VkSparseBufferMemoryBindInfo_array_win32_to_host(ctx, in->pBufferBinds, in->bufferBindCount);
+    out->imageOpaqueBindCount = in->imageOpaqueBindCount;
+    out->pImageOpaqueBinds = convert_VkSparseImageOpaqueMemoryBindInfo_array_win32_to_host(ctx, in->pImageOpaqueBinds, in->imageOpaqueBindCount);
+    out->imageBindCount = in->imageBindCount;
+    out->pImageBinds = convert_VkSparseImageMemoryBindInfo_array_win32_to_host(ctx, in->pImageBinds, in->imageBindCount);
+    out->signalSemaphoreCount = in->signalSemaphoreCount;
+    out->pSignalSemaphores = in->pSignalSemaphores;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
 #if defined(USE_STRUCT_CONVERSION)
 static inline VkBindSparseInfo_host *convert_VkBindSparseInfo_array_win32_to_host(struct conversion_context *ctx, const VkBindSparseInfo *in, uint32_t count)
 {
@@ -2406,24 +2680,47 @@ static inline VkBindSparseInfo_host *convert_VkBindSparseInfo_array_win32_to_hos
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i].sType = in[i].sType;
-        out[i].pNext = in[i].pNext;
-        out[i].waitSemaphoreCount = in[i].waitSemaphoreCount;
-        out[i].pWaitSemaphores = in[i].pWaitSemaphores;
-        out[i].bufferBindCount = in[i].bufferBindCount;
-        out[i].pBufferBinds = convert_VkSparseBufferMemoryBindInfo_array_win32_to_host(ctx, in[i].pBufferBinds, in[i].bufferBindCount);
-        out[i].imageOpaqueBindCount = in[i].imageOpaqueBindCount;
-        out[i].pImageOpaqueBinds = convert_VkSparseImageOpaqueMemoryBindInfo_array_win32_to_host(ctx, in[i].pImageOpaqueBinds, in[i].imageOpaqueBindCount);
-        out[i].imageBindCount = in[i].imageBindCount;
-        out[i].pImageBinds = convert_VkSparseImageMemoryBindInfo_array_win32_to_host(ctx, in[i].pImageBinds, in[i].imageBindCount);
-        out[i].signalSemaphoreCount = in[i].signalSemaphoreCount;
-        out[i].pSignalSemaphores = in[i].pSignalSemaphores;
+        convert_VkBindSparseInfo_win32_to_host(ctx, &in[i], &out[i]);
     }

return out;
 }
 #endif /* USE_STRUCT_CONVERSION */

+#if !defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkSubmitInfo_win64_to_host(struct conversion_context *ctx, const VkSubmitInfo *in, VkSubmitInfo *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    out->waitSemaphoreCount = in->waitSemaphoreCount;
+    out->pWaitSemaphores = in->pWaitSemaphores;
+    out->pWaitDstStageMask = in->pWaitDstStageMask;
+    out->commandBufferCount = in->commandBufferCount;
+    out->pCommandBuffers = convert_VkCommandBuffer_array_win64_to_host(ctx, in->pCommandBuffers, in->commandBufferCount);
+    out->signalSemaphoreCount = in->signalSemaphoreCount;
+    out->pSignalSemaphores = in->pSignalSemaphores;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkSubmitInfo_win32_to_host(struct conversion_context *ctx, const VkSubmitInfo *in, VkSubmitInfo *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    out->waitSemaphoreCount = in->waitSemaphoreCount;
+    out->pWaitSemaphores = in->pWaitSemaphores;
+    out->pWaitDstStageMask = in->pWaitDstStageMask;
+    out->commandBufferCount = in->commandBufferCount;
+    out->pCommandBuffers = convert_VkCommandBuffer_array_win32_to_host(ctx, in->pCommandBuffers, in->commandBufferCount);
+    out->signalSemaphoreCount = in->signalSemaphoreCount;
+    out->pSignalSemaphores = in->pSignalSemaphores;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
 #if !defined(USE_STRUCT_CONVERSION)
 static inline VkSubmitInfo *convert_VkSubmitInfo_array_win64_to_host(struct conversion_context *ctx, const VkSubmitInfo *in, uint32_t count)
 {
@@ -2435,15 +2732,7 @@ static inline VkSubmitInfo *convert_VkSubmitInfo_array_win64_to_host(struct conv
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i].sType = in[i].sType;
-        out[i].pNext = in[i].pNext;
-        out[i].waitSemaphoreCount = in[i].waitSemaphoreCount;
-        out[i].pWaitSemaphores = in[i].pWaitSemaphores;
-        out[i].pWaitDstStageMask = in[i].pWaitDstStageMask;
-        out[i].commandBufferCount = in[i].commandBufferCount;
-        out[i].pCommandBuffers = convert_VkCommandBuffer_array_win64_to_host(ctx, in[i].pCommandBuffers, in[i].commandBufferCount);
-        out[i].signalSemaphoreCount = in[i].signalSemaphoreCount;
-        out[i].pSignalSemaphores = in[i].pSignalSemaphores;
+        convert_VkSubmitInfo_win64_to_host(ctx, &in[i], &out[i]);
     }

return out;
@@ -2461,21 +2750,27 @@ static inline VkSubmitInfo *convert_VkSubmitInfo_array_win32_to_host(struct conv
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i].sType = in[i].sType;
-        out[i].pNext = in[i].pNext;
-        out[i].waitSemaphoreCount = in[i].waitSemaphoreCount;
-        out[i].pWaitSemaphores = in[i].pWaitSemaphores;
-        out[i].pWaitDstStageMask = in[i].pWaitDstStageMask;
-        out[i].commandBufferCount = in[i].commandBufferCount;
-        out[i].pCommandBuffers = convert_VkCommandBuffer_array_win32_to_host(ctx, in[i].pCommandBuffers, in[i].commandBufferCount);
-        out[i].signalSemaphoreCount = in[i].signalSemaphoreCount;
-        out[i].pSignalSemaphores = in[i].pSignalSemaphores;
+        convert_VkSubmitInfo_win32_to_host(ctx, &in[i], &out[i]);
     }

return out;
 }
 #endif /* USE_STRUCT_CONVERSION */

+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkSemaphoreSubmitInfo_win32_to_host(const VkSemaphoreSubmitInfo *in, VkSemaphoreSubmitInfo_host *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    out->semaphore = in->semaphore;
+    out->value = in->value;
+    out->stageMask = in->stageMask;
+    out->deviceIndex = in->deviceIndex;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
 #if defined(USE_STRUCT_CONVERSION)
 static inline VkSemaphoreSubmitInfo_host *convert_VkSemaphoreSubmitInfo_array_win32_to_host(struct conversion_context *ctx, const VkSemaphoreSubmitInfo *in, uint32_t count)
 {
@@ -2487,18 +2782,37 @@ static inline VkSemaphoreSubmitInfo_host *convert_VkSemaphoreSubmitInfo_array_wi
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i].sType = in[i].sType;
-        out[i].pNext = in[i].pNext;
-        out[i].semaphore = in[i].semaphore;
-        out[i].value = in[i].value;
-        out[i].stageMask = in[i].stageMask;
-        out[i].deviceIndex = in[i].deviceIndex;
+        convert_VkSemaphoreSubmitInfo_win32_to_host(&in[i], &out[i]);
     }

return out;
 }
 #endif /* USE_STRUCT_CONVERSION */

+#if !defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkCommandBufferSubmitInfo_win64_to_host(const VkCommandBufferSubmitInfo *in, VkCommandBufferSubmitInfo *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    out->commandBuffer = wine_cmd_buffer_from_handle(in->commandBuffer)->command_buffer;
+    out->deviceMask = in->deviceMask;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkCommandBufferSubmitInfo_win32_to_host(const VkCommandBufferSubmitInfo *in, VkCommandBufferSubmitInfo *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    out->commandBuffer = wine_cmd_buffer_from_handle(in->commandBuffer)->command_buffer;
+    out->deviceMask = in->deviceMask;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
 #if !defined(USE_STRUCT_CONVERSION)
 static inline VkCommandBufferSubmitInfo *convert_VkCommandBufferSubmitInfo_array_win64_to_host(struct conversion_context *ctx, const VkCommandBufferSubmitInfo *in, uint32_t count)
 {
@@ -2510,10 +2824,7 @@ static inline VkCommandBufferSubmitInfo *convert_VkCommandBufferSubmitInfo_array
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i].sType = in[i].sType;
-        out[i].pNext = in[i].pNext;
-        out[i].commandBuffer = wine_cmd_buffer_from_handle(in[i].commandBuffer)->command_buffer;
-        out[i].deviceMask = in[i].deviceMask;
+        convert_VkCommandBufferSubmitInfo_win64_to_host(&in[i], &out[i]);
     }

return out;
@@ -2531,16 +2842,47 @@ static inline VkCommandBufferSubmitInfo *convert_VkCommandBufferSubmitInfo_array
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i].sType = in[i].sType;
-        out[i].pNext = in[i].pNext;
-        out[i].commandBuffer = wine_cmd_buffer_from_handle(in[i].commandBuffer)->command_buffer;
-        out[i].deviceMask = in[i].deviceMask;
+        convert_VkCommandBufferSubmitInfo_win32_to_host(&in[i], &out[i]);
     }

return out;
 }
 #endif /* USE_STRUCT_CONVERSION */

+#if !defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkSubmitInfo2_win64_to_host(struct conversion_context *ctx, const VkSubmitInfo2 *in, VkSubmitInfo2 *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    out->flags = in->flags;
+    out->waitSemaphoreInfoCount = in->waitSemaphoreInfoCount;
+    out->pWaitSemaphoreInfos = in->pWaitSemaphoreInfos;
+    out->commandBufferInfoCount = in->commandBufferInfoCount;
+    out->pCommandBufferInfos = convert_VkCommandBufferSubmitInfo_array_win64_to_host(ctx, in->pCommandBufferInfos, in->commandBufferInfoCount);
+    out->signalSemaphoreInfoCount = in->signalSemaphoreInfoCount;
+    out->pSignalSemaphoreInfos = in->pSignalSemaphoreInfos;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkSubmitInfo2_win32_to_host(struct conversion_context *ctx, const VkSubmitInfo2 *in, VkSubmitInfo2_host *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    out->flags = in->flags;
+    out->waitSemaphoreInfoCount = in->waitSemaphoreInfoCount;
+    out->pWaitSemaphoreInfos = convert_VkSemaphoreSubmitInfo_array_win32_to_host(ctx, in->pWaitSemaphoreInfos, in->waitSemaphoreInfoCount);
+    out->commandBufferInfoCount = in->commandBufferInfoCount;
+    out->pCommandBufferInfos = convert_VkCommandBufferSubmitInfo_array_win32_to_host(ctx, in->pCommandBufferInfos, in->commandBufferInfoCount);
+    out->signalSemaphoreInfoCount = in->signalSemaphoreInfoCount;
+    out->pSignalSemaphoreInfos = convert_VkSemaphoreSubmitInfo_array_win32_to_host(ctx, in->pSignalSemaphoreInfos, in->signalSemaphoreInfoCount);
+}
+#endif /* USE_STRUCT_CONVERSION */
+
 #if !defined(USE_STRUCT_CONVERSION)
 static inline VkSubmitInfo2 *convert_VkSubmitInfo2_array_win64_to_host(struct conversion_context *ctx, const VkSubmitInfo2 *in, uint32_t count)
 {
@@ -2552,15 +2894,7 @@ static inline VkSubmitInfo2 *convert_VkSubmitInfo2_array_win64_to_host(struct co
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i].sType = in[i].sType;
-        out[i].pNext = in[i].pNext;
-        out[i].flags = in[i].flags;
-        out[i].waitSemaphoreInfoCount = in[i].waitSemaphoreInfoCount;
-        out[i].pWaitSemaphoreInfos = in[i].pWaitSemaphoreInfos;
-        out[i].commandBufferInfoCount = in[i].commandBufferInfoCount;
-        out[i].pCommandBufferInfos = convert_VkCommandBufferSubmitInfo_array_win64_to_host(ctx, in[i].pCommandBufferInfos, in[i].commandBufferInfoCount);
-        out[i].signalSemaphoreInfoCount = in[i].signalSemaphoreInfoCount;
-        out[i].pSignalSemaphoreInfos = in[i].pSignalSemaphoreInfos;
+        convert_VkSubmitInfo2_win64_to_host(ctx, &in[i], &out[i]);
     }

return out;
@@ -2578,15 +2912,7 @@ static inline VkSubmitInfo2_host *convert_VkSubmitInfo2_array_win32_to_host(stru
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i].sType = in[i].sType;
-        out[i].pNext = in[i].pNext;
-        out[i].flags = in[i].flags;
-        out[i].waitSemaphoreInfoCount = in[i].waitSemaphoreInfoCount;
-        out[i].pWaitSemaphoreInfos = convert_VkSemaphoreSubmitInfo_array_win32_to_host(ctx, in[i].pWaitSemaphoreInfos, in[i].waitSemaphoreInfoCount);
-        out[i].commandBufferInfoCount = in[i].commandBufferInfoCount;
-        out[i].pCommandBufferInfos = convert_VkCommandBufferSubmitInfo_array_win32_to_host(ctx, in[i].pCommandBufferInfos, in[i].commandBufferInfoCount);
-        out[i].signalSemaphoreInfoCount = in[i].signalSemaphoreInfoCount;
-        out[i].pSignalSemaphoreInfos = convert_VkSemaphoreSubmitInfo_array_win32_to_host(ctx, in[i].pSignalSemaphoreInfos, in[i].signalSemaphoreInfoCount);
+        convert_VkSubmitInfo2_win32_to_host(ctx, &in[i], &out[i]);
     }

return out;
@@ -2672,11 +2998,7 @@ static inline VkDebugUtilsObjectNameInfoEXT *convert_VkDebugUtilsObjectNameInfoE
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i].sType = in[i].sType;
-        out[i].pNext = in[i].pNext;
-        out[i].objectType = in[i].objectType;
-        out[i].objectHandle = wine_vk_unwrap_handle(in[i].objectType, in[i].objectHandle);
-        out[i].pObjectName = in[i].pObjectName;
+        convert_VkDebugUtilsObjectNameInfoEXT_win64_to_host(&in[i], &out[i]);
     }

return out;
@@ -2694,11 +3016,7 @@ static inline VkDebugUtilsObjectNameInfoEXT_host *convert_VkDebugUtilsObjectName
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i].sType = in[i].sType;
-        out[i].pNext = in[i].pNext;
-        out[i].objectType = in[i].objectType;
-        out[i].objectHandle = wine_vk_unwrap_handle(in[i].objectType, in[i].objectHandle);
-        out[i].pObjectName = in[i].pObjectName;
+        convert_VkDebugUtilsObjectNameInfoEXT_win32_to_host(&in[i], &out[i]);
     }

return out;
@@ -2745,6 +3063,23 @@ static inline void convert_VkDebugUtilsMessengerCallbackDataEXT_win32_to_host(st
 }
 #endif /* USE_STRUCT_CONVERSION */

+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkCopyDescriptorSet_win32_to_host(const VkCopyDescriptorSet *in, VkCopyDescriptorSet_host *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    out->srcSet = in->srcSet;
+    out->srcBinding = in->srcBinding;
+    out->srcArrayElement = in->srcArrayElement;
+    out->dstSet = in->dstSet;
+    out->dstBinding = in->dstBinding;
+    out->dstArrayElement = in->dstArrayElement;
+    out->descriptorCount = in->descriptorCount;
+}
+#endif /* USE_STRUCT_CONVERSION */
+
 #if defined(USE_STRUCT_CONVERSION)
 static inline VkCopyDescriptorSet_host *convert_VkCopyDescriptorSet_array_win32_to_host(struct conversion_context *ctx, const VkCopyDescriptorSet *in, uint32_t count)
 {
@@ -2756,15 +3091,7 @@ static inline VkCopyDescriptorSet_host *convert_VkCopyDescriptorSet_array_win32_
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i].sType = in[i].sType;
-        out[i].pNext = in[i].pNext;
-        out[i].srcSet = in[i].srcSet;
-        out[i].srcBinding = in[i].srcBinding;
-        out[i].srcArrayElement = in[i].srcArrayElement;
-        out[i].dstSet = in[i].dstSet;
-        out[i].dstBinding = in[i].dstBinding;
-        out[i].dstArrayElement = in[i].dstArrayElement;
-        out[i].descriptorCount = in[i].descriptorCount;
+        convert_VkCopyDescriptorSet_win32_to_host(&in[i], &out[i]);
     }

return out;

[PATCH 7/8] winevulkan: Don't declare host types for structs that don't need it.

[Jacek Caban]

From: Jacek Caban

---
 dlls/winevulkan/make_vulkan     |  3 +--
 dlls/winevulkan/vulkan_thunks.h | 30 ------------------------------
 2 files changed, 1 insertion(+), 32 deletions(-)

diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan
index 56f3db64389..2d506e031aa 100755
--- a/dlls/winevulkan/make_vulkan
+++ b/dlls/winevulkan/make_vulkan
@@ -2097,7 +2097,6 @@ class ArrayConversionFunction(object):
     def __init__(self, array, direction, conv, unwrap):
         self.array = array
         self.direction = direction
-        self.operand = array.struct if array.is_struct() else array.handle
         self.type = array.type
         self.conv = conv
         self.unwrap = unwrap or not array.needs_unwrapping()
@@ -2302,7 +2301,7 @@ class VkGenerator(object):
                 if not any(c == conv for c in self.conversions):
                     self.conversions.append(conv)

-                if not isinstance(conv.operand, VkStruct):
+                if not isinstance(conv, StructConversionFunction) or not conv.operand.needs_host_type():
                     continue

# Structs can be used in different ways by different conversions
diff --git a/dlls/winevulkan/vulkan_thunks.h b/dlls/winevulkan/vulkan_thunks.h
index 43e43664bd3..d77a6c0c3be 100644
--- a/dlls/winevulkan/vulkan_thunks.h
+++ b/dlls/winevulkan/vulkan_thunks.h
@@ -1762,23 +1762,6 @@ typedef struct VkBindSparseInfo_host
 typedef VkBindSparseInfo VkBindSparseInfo_host;
 #endif

-#if defined(USE_STRUCT_CONVERSION)
-typedef struct VkSubmitInfo_host
-{
-    VkStructureType sType;
-    const void *pNext;
-    uint32_t waitSemaphoreCount;
-    const VkSemaphore *pWaitSemaphores;
-    const VkPipelineStageFlags *pWaitDstStageMask;
-    uint32_t commandBufferCount;
-    const VkCommandBuffer *pCommandBuffers;
-    uint32_t signalSemaphoreCount;
-    const VkSemaphore *pSignalSemaphores;
-} VkSubmitInfo_host;
-#else
-typedef VkSubmitInfo VkSubmitInfo_host;
-#endif
-
 #if defined(USE_STRUCT_CONVERSION)
 typedef struct VkSemaphoreSubmitInfo_host
 {
@@ -1794,19 +1777,6 @@ typedef VkSemaphoreSubmitInfo VkSemaphoreSubmitInfoKHR;
 typedef VkSemaphoreSubmitInfo VkSemaphoreSubmitInfo_host;
 #endif

-#if defined(USE_STRUCT_CONVERSION)
-typedef struct VkCommandBufferSubmitInfo_host
-{
-    VkStructureType sType;
-    const void *pNext;
-    VkCommandBuffer commandBuffer;
-    uint32_t deviceMask;
-} VkCommandBufferSubmitInfo_host;
-typedef VkCommandBufferSubmitInfo VkCommandBufferSubmitInfoKHR;
-#else
-typedef VkCommandBufferSubmitInfo VkCommandBufferSubmitInfo_host;
-#endif
-
 #if defined(USE_STRUCT_CONVERSION)
 typedef struct VkSubmitInfo2_host
 {

[PATCH 8/8] winevulkan: Skip unsupported functions in a few more places.

[Jacek Caban]

From: Jacek Caban

---
 dlls/winevulkan/make_vulkan     | 10 +++++-----
 dlls/winevulkan/vulkan_thunks.c | 12 ------------
 dlls/winevulkan/vulkan_thunks.h | 16 ----------------
 3 files changed, 5 insertions(+), 33 deletions(-)

diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan
index 2d506e031aa..2d9053f7c05 100755
--- a/dlls/winevulkan/make_vulkan
+++ b/dlls/winevulkan/make_vulkan
@@ -2292,7 +2292,7 @@ class VkGenerator(object):
         self.struct_chain_conversions = []
         self.host_structs = []
         for func in self.registry.funcs.values():
-            if not func.is_required():
+            if not func.needs_exposing():
                 continue

conversions = func.get_conversions()
@@ -2517,7 +2517,7 @@ class VkGenerator(object):
         f.write("/* For use by vkDevice and children */\n")
         f.write("struct vulkan_device_funcs\n{\n")
         for vk_func in self.registry.device_funcs:
-            if not vk_func.is_required():
+            if not vk_func.needs_exposing():
                 continue

if not vk_func.needs_dispatch():
@@ -2530,7 +2530,7 @@ class VkGenerator(object):
         f.write("/* For use by vkInstance and children */\n")
         f.write("struct vulkan_instance_funcs\n{\n")
         for vk_func in self.registry.instance_funcs + self.registry.phys_dev_funcs:
-            if not vk_func.is_required():
+            if not vk_func.needs_exposing():
                 continue

if not vk_func.needs_dispatch():
@@ -2543,7 +2543,7 @@ class VkGenerator(object):
         f.write("#define ALL_VK_DEVICE_FUNCS() \\n")
         first = True
         for vk_func in self.registry.device_funcs:
-            if not vk_func.is_required():
+            if not vk_func.needs_exposing():
                 continue

if not vk_func.needs_dispatch():
@@ -2560,7 +2560,7 @@ class VkGenerator(object):
         f.write("#define ALL_VK_INSTANCE_FUNCS() \\n")
         first = True
         for vk_func in self.registry.instance_funcs + self.registry.phys_dev_funcs:
-            if not vk_func.is_required():
+            if not vk_func.needs_exposing():
                 continue

if not vk_func.needs_dispatch():
diff --git a/dlls/winevulkan/vulkan_thunks.c b/dlls/winevulkan/vulkan_thunks.c
index 7a04cfba6a7..4c87b807344 100644
--- a/dlls/winevulkan/vulkan_thunks.c
+++ b/dlls/winevulkan/vulkan_thunks.c
@@ -2151,18 +2151,6 @@ static inline void convert_VkImageViewHandleInfoNVX_win32_to_host(const VkImageV
 }
 #endif /* USE_STRUCT_CONVERSION */

-#if defined(USE_STRUCT_CONVERSION)
-static inline void convert_VkMemoryGetWin32HandleInfoKHR_win32_to_host(const VkMemoryGetWin32HandleInfoKHR *in, VkMemoryGetWin32HandleInfoKHR_host *out)
-{
-    if (!in) return;
-
-    out->sType = in->sType;
-    out->pNext = in->pNext;
-    out->memory = in->memory;
-    out->handleType = in->handleType;
-}
-#endif /* USE_STRUCT_CONVERSION */
-
 #if defined(USE_STRUCT_CONVERSION)
 static inline void convert_VkMicromapBuildSizesInfoEXT_win32_to_host(const VkMicromapBuildSizesInfoEXT *in, VkMicromapBuildSizesInfoEXT_host *out)
 {
diff --git a/dlls/winevulkan/vulkan_thunks.h b/dlls/winevulkan/vulkan_thunks.h
index d77a6c0c3be..13f2dcd21b0 100644
--- a/dlls/winevulkan/vulkan_thunks.h
+++ b/dlls/winevulkan/vulkan_thunks.h
@@ -1409,18 +1409,6 @@ typedef struct VkImageViewHandleInfoNVX_host
 typedef VkImageViewHandleInfoNVX VkImageViewHandleInfoNVX_host;
 #endif

-#if defined(USE_STRUCT_CONVERSION)
-typedef struct VkMemoryGetWin32HandleInfoKHR_host
-{
-    VkStructureType sType;
-    const void *pNext;
-    VkDeviceMemory memory;
-    VkExternalMemoryHandleTypeFlagBits handleType;
-} VkMemoryGetWin32HandleInfoKHR_host;
-#else
-typedef VkMemoryGetWin32HandleInfoKHR VkMemoryGetWin32HandleInfoKHR_host;
-#endif
-
 #if defined(USE_STRUCT_CONVERSION)
 typedef struct VkMicromapBuildSizesInfoEXT_host
 {
@@ -2308,8 +2296,6 @@ struct vulkan_device_funcs
     VkResult (*p_vkGetImageViewAddressNVX)(VkDevice, VkImageView, VkImageViewAddressPropertiesNVX_host *);
     uint32_t (*p_vkGetImageViewHandleNVX)(VkDevice, const VkImageViewHandleInfoNVX_host *);
     VkResult (*p_vkGetMemoryHostPointerPropertiesEXT)(VkDevice, VkExternalMemoryHandleTypeFlagBits, const void *, VkMemoryHostPointerPropertiesEXT *);
-    VkResult (*p_vkGetMemoryWin32HandleKHR)(VkDevice, const VkMemoryGetWin32HandleInfoKHR_host *, HANDLE *);
-    VkResult (*p_vkGetMemoryWin32HandlePropertiesKHR)(VkDevice, VkExternalMemoryHandleTypeFlagBits, HANDLE, VkMemoryWin32HandlePropertiesKHR *);
     void (*p_vkGetMicromapBuildSizesEXT)(VkDevice, VkAccelerationStructureBuildTypeKHR, const VkMicromapBuildInfoEXT_host *, VkMicromapBuildSizesInfoEXT_host *);
     VkResult (*p_vkGetPerformanceParameterINTEL)(VkDevice, VkPerformanceParameterTypeINTEL, VkPerformanceValueINTEL *);
     VkResult (*p_vkGetPipelineCacheData)(VkDevice, VkPipelineCache, size_t *, void *);
@@ -2823,8 +2809,6 @@ struct vulkan_instance_funcs
     USE_VK_FUNC(vkGetImageViewAddressNVX) \
     USE_VK_FUNC(vkGetImageViewHandleNVX) \
     USE_VK_FUNC(vkGetMemoryHostPointerPropertiesEXT) \
-    USE_VK_FUNC(vkGetMemoryWin32HandleKHR) \
-    USE_VK_FUNC(vkGetMemoryWin32HandlePropertiesKHR) \
     USE_VK_FUNC(vkGetMicromapBuildSizesEXT) \
     USE_VK_FUNC(vkGetPerformanceParameterINTEL) \
     USE_VK_FUNC(vkGetPipelineCacheData) \