[PATCH 0/2] MR1508: winevulkan: Union conversion and 1.3.235 spec update.

List overview All Threads

newer

older

[PATCH 0/1] MR1505: vbscript: Fix...

[PATCH v17 0/11] MR1180: Make all...

Georg Lehmann (＠DadSchoorse)

22 Nov 2022 22 Nov '22

5:23 p.m.

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

Show replies by date

Georg Lehmann

22 Nov 22 Nov

5:23 p.m.

New subject: [PATCH 1/2] winevulkan: Convert unions when nessecary.

From: Georg Lehmann dadschoorse@gmail.com

--- dlls/winevulkan/make_vulkan | 44 +++-- dlls/winevulkan/vulkan_thunks.c | 320 +++++++++++++++++++++++++++----- 2 files changed, 305 insertions(+), 59 deletions(-)

diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan index 71571bec180..95354f8fa0d 100755 --- a/dlls/winevulkan/make_vulkan +++ b/dlls/winevulkan/make_vulkan @@ -1105,7 +1105,8 @@ class VkHandle(object):

class VkVariable(object): def __init__(self, const=False, type_info=None, type=None, name=None, pointer=None, array_len=None, - dyn_array_len=None, object_type=None, optional=False, returnedonly=False, parent=None): + dyn_array_len=None, object_type=None, optional=False, returnedonly=False, parent=None, + selection=None, selector=None): self.const = const self.type_info = type_info self.type = type @@ -1114,6 +1115,8 @@ class VkVariable(object): self.object_type = object_type self.optional = optional self.returnedonly = returnedonly + self.selection = selection + self.selector = selector

self.pointer = pointer self.array_len = array_len @@ -1139,7 +1142,7 @@ class VkVariable(object): """ self.type_info = type_info self.handle = type_info["data"] if type_info["category"] == "handle" else None - self.struct = type_info["data"] if type_info["category"] == "struct" else None + self.struct = type_info["data"] if type_info["category"] == "struct" or type_info["category"] == "union" else None

def get_dyn_array_len(self, prefix, conv): if isinstance(self.dyn_array_len, int): @@ -1189,7 +1192,7 @@ class VkVariable(object): return self.handle is not None

def is_struct(self): - return self.struct is not None + return self.type_info["category"] == "struct"

def is_union(self): return self.type_info["category"] == "union" @@ -1264,10 +1267,10 @@ class VkVariable(object): return self.needs_conversion(conv, unwrap, Direction.INPUT, False) \ or self.needs_conversion(conv, unwrap, Direction.OUTPUT, False)

- return self.is_struct() and self.struct.needs_alloc(conv, unwrap) + return (self.is_struct() or self.is_union()) and self.struct.needs_alloc(conv, unwrap)

def needs_host_type(self): - return self.is_struct() and self.struct.needs_host_type() + return (self.is_struct() or self.is_union()) and self.struct.needs_host_type()

def get_conversions(self, unwrap, parent_const=False): """ Get a list of conversions required for this parameter if any. @@ -1281,7 +1284,7 @@ class VkVariable(object): # Collect any member conversions first, so we can guarantee # those functions will be defined prior to usage by the # 'parent' param requiring conversion. - if self.is_struct(): + if self.is_struct() or self.is_union(): struct = self.struct is_const = self.is_const() if self.is_pointer() else parent_const

@@ -1335,10 +1338,10 @@ class VkVariable(object): class VkMember(VkVariable): def __init__(self, const=False, struct_fwd_decl=False,_type=None, pointer=None, name=None, array_len=None, dyn_array_len=None, optional=False, values=None, object_type=None, bit_width=None, - returnedonly=False, parent=None): + returnedonly=False, parent=None, selection=None, selector=None): VkVariable.__init__(self, const=const, type=_type, name=name, pointer=pointer, array_len=array_len, dyn_array_len=dyn_array_len, object_type=object_type, optional=optional, - returnedonly=returnedonly, parent=parent) + returnedonly=returnedonly, parent=parent, selection=selection, selector=selector) self.struct_fwd_decl = struct_fwd_decl self.values = values self.bit_width = bit_width @@ -1411,10 +1414,13 @@ class VkMember(VkVariable): LOGGER.debug("Found bit field") bit_width = int(name_elem.tail[1:])

+ selection = member.get("selection").split(',') if member.get("selection") else None + selector = member.get("selector", None) + return VkMember(const=const, struct_fwd_decl=struct_fwd_decl, _type=member_type, pointer=pointer, name=name_elem.text, array_len=array_len, dyn_array_len=dyn_array_len, optional=optional, values=values, object_type=object_type, bit_width=bit_width, returnedonly=returnedonly, - parent=parent) + parent=parent, selection=selection, selector=selector)

def copy(self, input, output, direction, conv, unwrap): """ Helper method for use by conversion logic to generate a C-code statement to copy this member. @@ -1457,12 +1463,13 @@ class VkMember(VkVariable): else: return "{0}{1} = wine_vk_unwrap_handle({2}{3}, {2}{1});\n".format(output, self.name, input, self.object_type) else: + selector_part = ", {0}{1}".format(input, self.selector) if self.selector else "" if direction == Direction.OUTPUT: - return "convert_{0}_host_to_{4}(&{2}{1}, &{3}{1});\n".format(self.type, self.name, input, output, win_type) + return "convert_{0}_host_to_{4}(&{2}{1}, &{3}{1}{5});\n".format(self.type, self.name, input, output, win_type, selector_part) else: ctx_param = "ctx, " if self.needs_alloc(conv, unwrap) else "" host_part = "host" if unwrap else "unwrapped_host" - return "convert_{0}_{4}_to_{6}({5}&{2}{1}, &{3}{1});\n".format(self.type, self.name, input, output, win_type, ctx_param, host_part) + return "convert_{0}_{4}_to_{6}({5}&{2}{1}, &{3}{1}{7});\n".format(self.type, self.name, input, output, win_type, ctx_param, host_part, selector_part) elif self.is_static_array(): bytes_count = "{0} * sizeof({1})".format(self.array_len, self.type) return "memcpy({0}{1}, {2}{1}, {3});\n".format(output, self.name, input, bytes_count) @@ -1548,7 +1555,7 @@ class VkMember(VkVariable): elif self.is_generic_handle(): if unwrap: return True - elif self.is_struct(): + elif self.is_struct() or self.is_union(): if self.struct.needs_conversion(conv, unwrap, direction, is_const): return True

@@ -1895,7 +1902,8 @@ class VkStruct(Sequence):

# Those structs don't have returnedonly in spec, but they could (should?). if name in ["VkSurfaceCapabilitiesPresentBarrierNV", - "VkCooperativeMatrixPropertiesNV"]: + "VkCooperativeMatrixPropertiesNV", + "VkPerformanceValueINTEL"]: returnedonly = True

structextends = struct.attrib.get("structextends") @@ -2135,7 +2143,7 @@ class VkStruct(Sequence): return True if m.needs_alignment(): return True - if m.is_struct() and m.struct.needs_host_type(): + if (m.is_struct() or m.is_union()) and m.struct.needs_host_type(): return True

def set_type_info(self, types): @@ -2230,6 +2238,9 @@ class StructConversionFunction(object): else: params = ["const {0} *in".format(win_type), "{0} *out".format(self.type)]

+ if self.operand[0].selection: + params.append("VkFlags selector") + # Generate parameter list if needs_alloc: body += "struct conversion_context *ctx, " @@ -2273,6 +2284,11 @@ class StructConversionFunction(object): body += " out->pNext = NULL;\n" continue

+ if m.selection: + body += " if (" + body += " || ".join("selector == {}".format(s) for s in m.selection) + body += ")\n " + body += " " + m.copy("in->", "out->", self.direction, self.conv, self.unwrap)

if needs_extensions: diff --git a/dlls/winevulkan/vulkan_thunks.c b/dlls/winevulkan/vulkan_thunks.c index 98dd8b5eb97..9e5ab4d8c3b 100644 --- a/dlls/winevulkan/vulkan_thunks.c +++ b/dlls/winevulkan/vulkan_thunks.c @@ -308,15 +308,84 @@ typedef struct VkBindImageMemoryInfo32 } VkBindImageMemoryInfo32; typedef VkBindImageMemoryInfo32 VkBindImageMemoryInfoKHR32;

+typedef union VkDeviceOrHostAddressConstKHR32 +{ + VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress; + PTR32 hostAddress; +} VkDeviceOrHostAddressConstKHR32; + +typedef struct VkAccelerationStructureGeometryMotionTrianglesDataNV32 +{ + VkStructureType sType; + PTR32 pNext; + VkDeviceOrHostAddressConstKHR32 DECLSPEC_ALIGN(8) vertexData; +} VkAccelerationStructureGeometryMotionTrianglesDataNV32; + +typedef struct VkAccelerationStructureTrianglesOpacityMicromapEXT32 +{ + VkStructureType sType; + PTR32 pNext; + VkIndexType indexType; + VkDeviceOrHostAddressConstKHR32 DECLSPEC_ALIGN(8) indexBuffer; + VkDeviceSize DECLSPEC_ALIGN(8) indexStride; + uint32_t baseTriangle; + uint32_t usageCountsCount; + PTR32 pUsageCounts; + PTR32 ppUsageCounts; + VkMicromapEXT DECLSPEC_ALIGN(8) micromap; +} VkAccelerationStructureTrianglesOpacityMicromapEXT32; + +typedef struct VkAccelerationStructureGeometryTrianglesDataKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkFormat vertexFormat; + VkDeviceOrHostAddressConstKHR32 DECLSPEC_ALIGN(8) vertexData; + VkDeviceSize DECLSPEC_ALIGN(8) vertexStride; + uint32_t maxVertex; + VkIndexType indexType; + VkDeviceOrHostAddressConstKHR32 DECLSPEC_ALIGN(8) indexData; + VkDeviceOrHostAddressConstKHR32 DECLSPEC_ALIGN(8) transformData; +} VkAccelerationStructureGeometryTrianglesDataKHR32; + +typedef struct VkAccelerationStructureGeometryAabbsDataKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkDeviceOrHostAddressConstKHR32 DECLSPEC_ALIGN(8) data; + VkDeviceSize DECLSPEC_ALIGN(8) stride; +} VkAccelerationStructureGeometryAabbsDataKHR32; + +typedef struct VkAccelerationStructureGeometryInstancesDataKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 arrayOfPointers; + VkDeviceOrHostAddressConstKHR32 DECLSPEC_ALIGN(8) data; +} VkAccelerationStructureGeometryInstancesDataKHR32; + +typedef union VkAccelerationStructureGeometryDataKHR32 +{ + VkAccelerationStructureGeometryTrianglesDataKHR32 DECLSPEC_ALIGN(8) triangles; + VkAccelerationStructureGeometryAabbsDataKHR32 DECLSPEC_ALIGN(8) aabbs; + VkAccelerationStructureGeometryInstancesDataKHR32 DECLSPEC_ALIGN(8) instances; +} VkAccelerationStructureGeometryDataKHR32; + typedef struct VkAccelerationStructureGeometryKHR32 { VkStructureType sType; PTR32 pNext; VkGeometryTypeKHR geometryType; - VkAccelerationStructureGeometryDataKHR DECLSPEC_ALIGN(8) geometry; + VkAccelerationStructureGeometryDataKHR32 DECLSPEC_ALIGN(8) geometry; VkGeometryFlagsKHR flags; } VkAccelerationStructureGeometryKHR32;

+typedef union VkDeviceOrHostAddressKHR32 +{ + VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress; + PTR32 hostAddress; +} VkDeviceOrHostAddressKHR32; + typedef struct VkAccelerationStructureBuildGeometryInfoKHR32 { VkStructureType sType; @@ -329,7 +398,7 @@ typedef struct VkAccelerationStructureBuildGeometryInfoKHR32 uint32_t geometryCount; PTR32 pGeometries; PTR32 ppGeometries; - VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) scratchData; + VkDeviceOrHostAddressKHR32 DECLSPEC_ALIGN(8) scratchData; } VkAccelerationStructureBuildGeometryInfoKHR32;

typedef struct VkMicromapBuildInfoEXT32 @@ -343,9 +412,9 @@ typedef struct VkMicromapBuildInfoEXT32 uint32_t usageCountsCount; PTR32 pUsageCounts; PTR32 ppUsageCounts; - VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) data; - VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) scratchData; - VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) triangleArray; + VkDeviceOrHostAddressConstKHR32 DECLSPEC_ALIGN(8) data; + VkDeviceOrHostAddressKHR32 DECLSPEC_ALIGN(8) scratchData; + VkDeviceOrHostAddressConstKHR32 DECLSPEC_ALIGN(8) triangleArray; VkDeviceSize DECLSPEC_ALIGN(8) triangleArrayStride; } VkMicromapBuildInfoEXT32;

@@ -597,7 +666,7 @@ typedef struct VkCopyAccelerationStructureToMemoryInfoKHR32 VkStructureType sType; PTR32 pNext; VkAccelerationStructureKHR DECLSPEC_ALIGN(8) src; - VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) dst; + VkDeviceOrHostAddressKHR32 DECLSPEC_ALIGN(8) dst; VkCopyAccelerationStructureModeKHR mode; } VkCopyAccelerationStructureToMemoryInfoKHR32;

@@ -705,7 +774,7 @@ typedef struct VkCopyMemoryToAccelerationStructureInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) src; + VkDeviceOrHostAddressConstKHR32 DECLSPEC_ALIGN(8) src; VkAccelerationStructureKHR DECLSPEC_ALIGN(8) dst; VkCopyAccelerationStructureModeKHR mode; } VkCopyMemoryToAccelerationStructureInfoKHR32; @@ -714,7 +783,7 @@ typedef struct VkCopyMemoryToMicromapInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) src; + VkDeviceOrHostAddressConstKHR32 DECLSPEC_ALIGN(8) src; VkMicromapEXT DECLSPEC_ALIGN(8) dst; VkCopyMicromapModeEXT mode; } VkCopyMemoryToMicromapInfoEXT32; @@ -733,7 +802,7 @@ typedef struct VkCopyMicromapToMemoryInfoEXT32 VkStructureType sType; PTR32 pNext; VkMicromapEXT DECLSPEC_ALIGN(8) src; - VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) dst; + VkDeviceOrHostAddressKHR32 DECLSPEC_ALIGN(8) dst; VkCopyMicromapModeEXT mode; } VkCopyMicromapToMemoryInfoEXT32;

@@ -4168,10 +4237,19 @@ typedef struct VkMicromapBuildSizesInfoEXT32 VkBool32 discardable; } VkMicromapBuildSizesInfoEXT32;

+typedef union VkPerformanceValueDataINTEL32 +{ + uint32_t value32; + uint64_t DECLSPEC_ALIGN(8) value64; + float valueFloat; + VkBool32 valueBool; + PTR32 valueString; +} VkPerformanceValueDataINTEL32; + typedef struct VkPerformanceValueINTEL32 { VkPerformanceValueTypeINTEL type; - VkPerformanceValueDataINTEL DECLSPEC_ALIGN(8) data; + VkPerformanceValueDataINTEL32 DECLSPEC_ALIGN(8) data; } VkPerformanceValueINTEL32;

typedef struct VkCooperativeMatrixPropertiesNV32 @@ -5486,6 +5564,14 @@ typedef struct VkPipelineExecutablePropertiesKHR32 uint32_t subgroupSize; } VkPipelineExecutablePropertiesKHR32;

+typedef union VkPipelineExecutableStatisticValueKHR32 +{ + VkBool32 b32; + int64_t i64; + uint64_t DECLSPEC_ALIGN(8) u64; + double f64; +} VkPipelineExecutableStatisticValueKHR32; + typedef struct VkPipelineExecutableStatisticKHR32 { VkStructureType sType; @@ -5493,7 +5579,7 @@ typedef struct VkPipelineExecutableStatisticKHR32 char name[VK_MAX_DESCRIPTION_SIZE]; char description[VK_MAX_DESCRIPTION_SIZE]; VkPipelineExecutableStatisticFormatKHR format; - VkPipelineExecutableStatisticValueKHR DECLSPEC_ALIGN(8) value; + VkPipelineExecutableStatisticValueKHR32 DECLSPEC_ALIGN(8) value; } VkPipelineExecutableStatisticKHR32;

@@ -6366,14 +6452,131 @@ static inline const VkBindImageMemoryInfo *convert_VkBindImageMemoryInfo_array_w return out; }

-static inline void convert_VkAccelerationStructureGeometryKHR_win32_to_host(const VkAccelerationStructureGeometryKHR32 *in, VkAccelerationStructureGeometryKHR *out) +static inline void convert_VkDeviceOrHostAddressConstKHR_win32_to_host(const VkDeviceOrHostAddressConstKHR32 *in, VkDeviceOrHostAddressConstKHR *out) +{ + if (!in) return; + + out->deviceAddress = in->deviceAddress; + out->hostAddress = (const void *)UlongToPtr(in->hostAddress); +} + +static inline const VkMicromapUsageEXT * const*convert_VkMicromapUsageEXT_pointer_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count) +{ + VkMicromapUsageEXT **out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + out[i] = UlongToPtr(in[i]); + } + + return (void *)out; +} + +static inline void convert_VkAccelerationStructureGeometryTrianglesDataKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureGeometryTrianglesDataKHR32 *in, VkAccelerationStructureGeometryTrianglesDataKHR *out) +{ + const VkBaseInStructure32 *in_header; + VkBaseOutStructure *out_header = (void *)out; + + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->vertexFormat = in->vertexFormat; + convert_VkDeviceOrHostAddressConstKHR_win32_to_host(&in->vertexData, &out->vertexData); + out->vertexStride = in->vertexStride; + out->maxVertex = in->maxVertex; + out->indexType = in->indexType; + convert_VkDeviceOrHostAddressConstKHR_win32_to_host(&in->indexData, &out->indexData); + convert_VkDeviceOrHostAddressConstKHR_win32_to_host(&in->transformData, &out->transformData); + + for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext)) + { + switch (in_header->sType) + { + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV: + { + VkAccelerationStructureGeometryMotionTrianglesDataNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkAccelerationStructureGeometryMotionTrianglesDataNV32 *in_ext = (const VkAccelerationStructureGeometryMotionTrianglesDataNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV; + out_ext->pNext = NULL; + convert_VkDeviceOrHostAddressConstKHR_win32_to_host(&in_ext->vertexData, &out_ext->vertexData); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT: + { + VkAccelerationStructureTrianglesOpacityMicromapEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkAccelerationStructureTrianglesOpacityMicromapEXT32 *in_ext = (const VkAccelerationStructureTrianglesOpacityMicromapEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT; + out_ext->pNext = NULL; + out_ext->indexType = in_ext->indexType; + convert_VkDeviceOrHostAddressConstKHR_win32_to_host(&in_ext->indexBuffer, &out_ext->indexBuffer); + out_ext->indexStride = in_ext->indexStride; + out_ext->baseTriangle = in_ext->baseTriangle; + out_ext->usageCountsCount = in_ext->usageCountsCount; + out_ext->pUsageCounts = (const VkMicromapUsageEXT *)UlongToPtr(in_ext->pUsageCounts); + out_ext->ppUsageCounts = convert_VkMicromapUsageEXT_pointer_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(in_ext->ppUsageCounts), in_ext->usageCountsCount); + out_ext->micromap = in_ext->micromap; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + default: + FIXME("Unhandled sType %u.", in_header->sType); + break; + } + } +} + +static inline void convert_VkAccelerationStructureGeometryAabbsDataKHR_win32_to_host(const VkAccelerationStructureGeometryAabbsDataKHR32 *in, VkAccelerationStructureGeometryAabbsDataKHR *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + convert_VkDeviceOrHostAddressConstKHR_win32_to_host(&in->data, &out->data); + out->stride = in->stride; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static inline void convert_VkAccelerationStructureGeometryInstancesDataKHR_win32_to_host(const VkAccelerationStructureGeometryInstancesDataKHR32 *in, VkAccelerationStructureGeometryInstancesDataKHR *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->arrayOfPointers = in->arrayOfPointers; + convert_VkDeviceOrHostAddressConstKHR_win32_to_host(&in->data, &out->data); + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static inline void convert_VkAccelerationStructureGeometryDataKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureGeometryDataKHR32 *in, VkAccelerationStructureGeometryDataKHR *out, VkFlags selector) +{ + if (!in) return; + + if (selector == VK_GEOMETRY_TYPE_TRIANGLES_KHR) + convert_VkAccelerationStructureGeometryTrianglesDataKHR_win32_to_host(ctx, &in->triangles, &out->triangles); + if (selector == VK_GEOMETRY_TYPE_AABBS_KHR) + convert_VkAccelerationStructureGeometryAabbsDataKHR_win32_to_host(&in->aabbs, &out->aabbs); + if (selector == VK_GEOMETRY_TYPE_INSTANCES_KHR) + convert_VkAccelerationStructureGeometryInstancesDataKHR_win32_to_host(&in->instances, &out->instances); +} + +static inline void convert_VkAccelerationStructureGeometryKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureGeometryKHR32 *in, VkAccelerationStructureGeometryKHR *out) { if (!in) return;

out->sType = in->sType; out->pNext = NULL; out->geometryType = in->geometryType; - out->geometry = in->geometry; + convert_VkAccelerationStructureGeometryDataKHR_win32_to_host(ctx, &in->geometry, &out->geometry, in->geometryType); out->flags = in->flags; if (in->pNext) FIXME("Unexpected pNext\n"); @@ -6389,7 +6592,7 @@ static inline const VkAccelerationStructureGeometryKHR *convert_VkAccelerationSt out = conversion_context_alloc(ctx, count * sizeof(*out)); for (i = 0; i < count; i++) { - convert_VkAccelerationStructureGeometryKHR_win32_to_host(&in[i], &out[i]); + convert_VkAccelerationStructureGeometryKHR_win32_to_host(ctx, &in[i], &out[i]); }

return out; @@ -6408,7 +6611,7 @@ static inline const VkAccelerationStructureGeometryKHR * const*convert_VkAcceler if (in[i]) { out[i] = conversion_context_alloc(ctx, sizeof(*out[i])); - convert_VkAccelerationStructureGeometryKHR_win32_to_host((VkAccelerationStructureGeometryKHR32 *)UlongToPtr(in[i]), out[i]); + convert_VkAccelerationStructureGeometryKHR_win32_to_host(ctx, (VkAccelerationStructureGeometryKHR32 *)UlongToPtr(in[i]), out[i]); } else out[i] = NULL; @@ -6417,6 +6620,14 @@ static inline const VkAccelerationStructureGeometryKHR * const*convert_VkAcceler return (void *)out; }

+static inline void convert_VkDeviceOrHostAddressKHR_win32_to_host(const VkDeviceOrHostAddressKHR32 *in, VkDeviceOrHostAddressKHR *out) +{ + if (!in) return; + + out->deviceAddress = in->deviceAddress; + out->hostAddress = (void *)UlongToPtr(in->hostAddress); +} + static inline void convert_VkAccelerationStructureBuildGeometryInfoKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureBuildGeometryInfoKHR32 *in, VkAccelerationStructureBuildGeometryInfoKHR *out) { if (!in) return; @@ -6431,7 +6642,7 @@ static inline void convert_VkAccelerationStructureBuildGeometryInfoKHR_win32_to_ out->geometryCount = in->geometryCount; out->pGeometries = convert_VkAccelerationStructureGeometryKHR_array_win32_to_host(ctx, (const VkAccelerationStructureGeometryKHR32 *)UlongToPtr(in->pGeometries), in->geometryCount); out->ppGeometries = convert_VkAccelerationStructureGeometryKHR_pointer_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(in->ppGeometries), in->geometryCount); - out->scratchData = in->scratchData; + convert_VkDeviceOrHostAddressKHR_win32_to_host(&in->scratchData, &out->scratchData); if (in->pNext) FIXME("Unexpected pNext\n"); } @@ -6452,22 +6663,6 @@ static inline const VkAccelerationStructureBuildGeometryInfoKHR *convert_VkAccel return out; }

-static inline const VkMicromapUsageEXT * const*convert_VkMicromapUsageEXT_pointer_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count) -{ - VkMicromapUsageEXT **out; - unsigned int i; - - if (!in || !count) return NULL; - - out = conversion_context_alloc(ctx, count * sizeof(*out)); - for (i = 0; i < count; i++) - { - out[i] = UlongToPtr(in[i]); - } - - return (void *)out; -} - static inline void convert_VkMicromapBuildInfoEXT_win32_to_host(struct conversion_context *ctx, const VkMicromapBuildInfoEXT32 *in, VkMicromapBuildInfoEXT *out) { if (!in) return; @@ -6481,9 +6676,9 @@ static inline void convert_VkMicromapBuildInfoEXT_win32_to_host(struct conversio out->usageCountsCount = in->usageCountsCount; out->pUsageCounts = (const VkMicromapUsageEXT *)UlongToPtr(in->pUsageCounts); out->ppUsageCounts = convert_VkMicromapUsageEXT_pointer_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(in->ppUsageCounts), in->usageCountsCount); - out->data = in->data; - out->scratchData = in->scratchData; - out->triangleArray = in->triangleArray; + convert_VkDeviceOrHostAddressConstKHR_win32_to_host(&in->data, &out->data); + convert_VkDeviceOrHostAddressKHR_win32_to_host(&in->scratchData, &out->scratchData); + convert_VkDeviceOrHostAddressConstKHR_win32_to_host(&in->triangleArray, &out->triangleArray); out->triangleArrayStride = in->triangleArrayStride; if (in->pNext) FIXME("Unexpected pNext\n"); @@ -6980,7 +7175,7 @@ static inline void convert_VkCopyAccelerationStructureToMemoryInfoKHR_win32_to_h out->sType = in->sType; out->pNext = NULL; out->src = in->src; - out->dst = in->dst; + convert_VkDeviceOrHostAddressKHR_win32_to_host(&in->dst, &out->dst); out->mode = in->mode; if (in->pNext) FIXME("Unexpected pNext\n"); @@ -7219,7 +7414,7 @@ static inline void convert_VkCopyMemoryToAccelerationStructureInfoKHR_win32_to_h

out->sType = in->sType; out->pNext = NULL; - out->src = in->src; + convert_VkDeviceOrHostAddressConstKHR_win32_to_host(&in->src, &out->src); out->dst = in->dst; out->mode = in->mode; if (in->pNext) @@ -7259,7 +7454,7 @@ static inline void convert_VkCopyMicromapToMemoryInfoEXT_win32_to_host(const VkC out->sType = in->sType; out->pNext = NULL; out->src = in->src; - out->dst = in->dst; + convert_VkDeviceOrHostAddressKHR_win32_to_host(&in->dst, &out->dst); out->mode = in->mode; if (in->pNext) FIXME("Unexpected pNext\n"); @@ -16788,12 +16983,34 @@ static inline void convert_VkMicromapBuildSizesInfoEXT_host_to_win32(const VkMic out->discardable = in->discardable; }

-static inline void convert_VkPerformanceValueINTEL_win32_to_host(const VkPerformanceValueINTEL32 *in, VkPerformanceValueINTEL *out) +static inline void convert_VkPerformanceValueDataINTEL_win32_to_host(const VkPerformanceValueDataINTEL32 *in, VkPerformanceValueDataINTEL *out, VkFlags selector) { if (!in) return;

- out->type = in->type; - out->data = in->data; + if (selector == VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL) + out->value32 = in->value32; + if (selector == VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL) + out->value64 = in->value64; + if (selector == VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL) + out->valueFloat = in->valueFloat; + if (selector == VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL) + out->valueBool = in->valueBool; + if (selector == VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL) + out->valueString = (const char *)UlongToPtr(in->valueString); +} + +static inline void convert_VkPerformanceValueDataINTEL_host_to_win32(const VkPerformanceValueDataINTEL *in, VkPerformanceValueDataINTEL32 *out, VkFlags selector) +{ + if (!in) return; + + if (selector == VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL) + out->value32 = in->value32; + if (selector == VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL) + out->value64 = in->value64; + if (selector == VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL) + out->valueFloat = in->valueFloat; + if (selector == VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL) + out->valueBool = in->valueBool; }

static inline void convert_VkPerformanceValueINTEL_host_to_win32(const VkPerformanceValueINTEL *in, VkPerformanceValueINTEL32 *out) @@ -16801,7 +17018,7 @@ static inline void convert_VkPerformanceValueINTEL_host_to_win32(const VkPerform if (!in) return;

out->type = in->type; - out->data = in->data; + convert_VkPerformanceValueDataINTEL_host_to_win32(&in->data, &out->data, in->type); }

static inline void convert_VkCooperativeMatrixPropertiesNV_win32_to_host(const VkCooperativeMatrixPropertiesNV32 *in, VkCooperativeMatrixPropertiesNV *out) @@ -22992,6 +23209,20 @@ static inline void convert_VkPipelineExecutablePropertiesKHR_array_host_to_win32 } }

+static inline void convert_VkPipelineExecutableStatisticValueKHR_host_to_win32(const VkPipelineExecutableStatisticValueKHR *in, VkPipelineExecutableStatisticValueKHR32 *out, VkFlags selector) +{ + if (!in) return; + + if (selector == VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR) + out->b32 = in->b32; + if (selector == VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR) + out->i64 = in->i64; + if (selector == VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR) + out->u64 = in->u64; + if (selector == VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR) + out->f64 = in->f64; +} + static inline void convert_VkPipelineExecutableStatisticKHR_win32_to_host(const VkPipelineExecutableStatisticKHR32 *in, VkPipelineExecutableStatisticKHR *out) { if (!in) return; @@ -23009,7 +23240,7 @@ static inline void convert_VkPipelineExecutableStatisticKHR_host_to_win32(const memcpy(out->name, in->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char)); memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char)); out->format = in->format; - out->value = in->value; + convert_VkPipelineExecutableStatisticValueKHR_host_to_win32(&in->value, &out->value, in->format); }

static inline VkPipelineExecutableStatisticKHR *convert_VkPipelineExecutableStatisticKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineExecutableStatisticKHR32 *in, uint32_t count) @@ -36057,7 +36288,6 @@ static NTSTATUS thunk32_vkGetPerformanceParameterINTEL(void *args)

TRACE("%#x, %#x, %#x\n", params->device, params->parameter, params->pValue);

- convert_VkPerformanceValueINTEL_win32_to_host((VkPerformanceValueINTEL32 *)UlongToPtr(params->pValue), &pValue_host); params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetPerformanceParameterINTEL(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->parameter, &pValue_host); convert_VkPerformanceValueINTEL_host_to_win32(&pValue_host, (VkPerformanceValueINTEL32 *)UlongToPtr(params->pValue)); return STATUS_SUCCESS;

-- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/1508

Georg Lehmann

5:23 p.m.

New subject: [PATCH 2/2] winevulkan: Update to VK spec version 1.3.235.

From: Georg Lehmann dadschoorse@gmail.com

--- dlls/winevulkan/loader_thunks.c | 144 ++++++ dlls/winevulkan/loader_thunks.h | 100 ++++ dlls/winevulkan/make_vulkan | 5 +- dlls/winevulkan/vulkan_thunks.c | 873 +++++++++++++++++++++++++++++++- dlls/winevulkan/vulkan_thunks.h | 22 + dlls/winevulkan/winevulkan.json | 2 +- include/wine/vulkan.h | 196 ++++++- 7 files changed, 1336 insertions(+), 6 deletions(-)

diff --git a/dlls/winevulkan/loader_thunks.c b/dlls/winevulkan/loader_thunks.c index 5a8f8e87bb3..73d63ccd01a 100644 --- a/dlls/winevulkan/loader_thunks.c +++ b/dlls/winevulkan/loader_thunks.c @@ -337,6 +337,29 @@ void WINAPI vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32 assert(!status); }

+void WINAPI vkCmdBindDescriptorBufferEmbeddedSamplersEXT(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set) +{ + struct vkCmdBindDescriptorBufferEmbeddedSamplersEXT_params params; + NTSTATUS status; + params.commandBuffer = commandBuffer; + params.pipelineBindPoint = pipelineBindPoint; + params.layout = layout; + params.set = set; + status = p_vk_direct_unix_call(unix_handle, unix_vkCmdBindDescriptorBufferEmbeddedSamplersEXT, &params); + assert(!status); +} + +void WINAPI vkCmdBindDescriptorBuffersEXT(VkCommandBuffer commandBuffer, uint32_t bufferCount, const VkDescriptorBufferBindingInfoEXT *pBindingInfos) +{ + struct vkCmdBindDescriptorBuffersEXT_params params; + NTSTATUS status; + params.commandBuffer = commandBuffer; + params.bufferCount = bufferCount; + params.pBindingInfos = pBindingInfos; + status = p_vk_direct_unix_call(unix_handle, unix_vkCmdBindDescriptorBuffersEXT, &params); + assert(!status); +} + void WINAPI vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t *pDynamicOffsets) { struct vkCmdBindDescriptorSets_params params; @@ -1943,6 +1966,21 @@ void WINAPI vkCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer, VkBool32 assert(!status); }

+void WINAPI vkCmdSetDescriptorBufferOffsetsEXT(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const uint32_t *pBufferIndices, const VkDeviceSize *pOffsets) +{ + struct vkCmdSetDescriptorBufferOffsetsEXT_params params; + NTSTATUS status; + params.commandBuffer = commandBuffer; + params.pipelineBindPoint = pipelineBindPoint; + params.layout = layout; + params.firstSet = firstSet; + params.setCount = setCount; + params.pBufferIndices = pBufferIndices; + params.pOffsets = pOffsets; + status = p_vk_direct_unix_call(unix_handle, unix_vkCmdSetDescriptorBufferOffsetsEXT, &params); + assert(!status); +} + void WINAPI vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask) { struct vkCmdSetDeviceMask_params params; @@ -4036,6 +4074,18 @@ void WINAPI vkGetAccelerationStructureMemoryRequirementsNV(VkDevice device, cons assert(!status); }

+VkResult WINAPI vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT *pInfo, void *pData) +{ + struct vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_params params; + NTSTATUS status; + params.device = device; + params.pInfo = pInfo; + params.pData = pData; + status = vk_unix_call(unix_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT, &params); + assert(!status); + return params.result; +} + VkDeviceAddress WINAPI vkGetBufferDeviceAddress(VkDevice device, const VkBufferDeviceAddressInfo *pInfo) { struct vkGetBufferDeviceAddress_params params; @@ -4124,6 +4174,18 @@ uint64_t WINAPI vkGetBufferOpaqueCaptureAddressKHR(VkDevice device, const VkBuff return params.result; }

+VkResult WINAPI vkGetBufferOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT *pInfo, void *pData) +{ + struct vkGetBufferOpaqueCaptureDescriptorDataEXT_params params; + NTSTATUS status; + params.device = device; + params.pInfo = pInfo; + params.pData = pData; + status = vk_unix_call(unix_vkGetBufferOpaqueCaptureDescriptorDataEXT, &params); + assert(!status); + return params.result; +} + VkResult WINAPI vkGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT *pTimestampInfos, uint64_t *pTimestamps, uint64_t *pMaxDeviation) { struct vkGetCalibratedTimestampsEXT_params params; @@ -4160,6 +4222,18 @@ VkResult WINAPI vkGetDeferredOperationResultKHR(VkDevice device, VkDeferredOpera return params.result; }

+void WINAPI vkGetDescriptorEXT(VkDevice device, const VkDescriptorGetInfoEXT *pDescriptorInfo, size_t dataSize, void *pDescriptor) +{ + struct vkGetDescriptorEXT_params params; + NTSTATUS status; + params.device = device; + params.pDescriptorInfo = pDescriptorInfo; + params.dataSize = dataSize; + params.pDescriptor = pDescriptor; + status = vk_unix_call(unix_vkGetDescriptorEXT, &params); + assert(!status); +} + void WINAPI vkGetDescriptorSetHostMappingVALVE(VkDevice device, VkDescriptorSet descriptorSet, void **ppData) { struct vkGetDescriptorSetHostMappingVALVE_params params; @@ -4171,6 +4245,18 @@ void WINAPI vkGetDescriptorSetHostMappingVALVE(VkDevice device, VkDescriptorSet assert(!status); }

+void WINAPI vkGetDescriptorSetLayoutBindingOffsetEXT(VkDevice device, VkDescriptorSetLayout layout, uint32_t binding, VkDeviceSize *pOffset) +{ + struct vkGetDescriptorSetLayoutBindingOffsetEXT_params params; + NTSTATUS status; + params.device = device; + params.layout = layout; + params.binding = binding; + params.pOffset = pOffset; + status = vk_unix_call(unix_vkGetDescriptorSetLayoutBindingOffsetEXT, &params); + assert(!status); +} + void WINAPI vkGetDescriptorSetLayoutHostMappingInfoVALVE(VkDevice device, const VkDescriptorSetBindingReferenceVALVE *pBindingReference, VkDescriptorSetLayoutHostMappingInfoVALVE *pHostMapping) { struct vkGetDescriptorSetLayoutHostMappingInfoVALVE_params params; @@ -4182,6 +4268,17 @@ void WINAPI vkGetDescriptorSetLayoutHostMappingInfoVALVE(VkDevice device, const assert(!status); }

+void WINAPI vkGetDescriptorSetLayoutSizeEXT(VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize *pLayoutSizeInBytes) +{ + struct vkGetDescriptorSetLayoutSizeEXT_params params; + NTSTATUS status; + params.device = device; + params.layout = layout; + params.pLayoutSizeInBytes = pLayoutSizeInBytes; + status = vk_unix_call(unix_vkGetDescriptorSetLayoutSizeEXT, &params); + assert(!status); +} + void WINAPI vkGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport) { struct vkGetDescriptorSetLayoutSupport_params params; @@ -4514,6 +4611,18 @@ void WINAPI vkGetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemor assert(!status); }

+VkResult WINAPI vkGetImageOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkImageCaptureDescriptorDataInfoEXT *pInfo, void *pData) +{ + struct vkGetImageOpaqueCaptureDescriptorDataEXT_params params; + NTSTATUS status; + params.device = device; + params.pInfo = pInfo; + params.pData = pData; + status = vk_unix_call(unix_vkGetImageOpaqueCaptureDescriptorDataEXT, &params); + assert(!status); + return params.result; +} + void WINAPI vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements *pSparseMemoryRequirements) { struct vkGetImageSparseMemoryRequirements_params params; @@ -4597,6 +4706,18 @@ uint32_t WINAPI vkGetImageViewHandleNVX(VkDevice device, const VkImageViewHandle return params.result; }

+VkResult WINAPI vkGetImageViewOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT *pInfo, void *pData) +{ + struct vkGetImageViewOpaqueCaptureDescriptorDataEXT_params params; + NTSTATUS status; + params.device = device; + params.pInfo = pInfo; + params.pData = pData; + status = vk_unix_call(unix_vkGetImageViewOpaqueCaptureDescriptorDataEXT, &params); + assert(!status); + return params.result; +} + VkResult WINAPI vkGetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void *pHostPointer, VkMemoryHostPointerPropertiesEXT *pMemoryHostPointerProperties) { struct vkGetMemoryHostPointerPropertiesEXT_params params; @@ -5321,6 +5442,18 @@ void WINAPI vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, assert(!status); }

+VkResult WINAPI vkGetSamplerOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkSamplerCaptureDescriptorDataInfoEXT *pInfo, void *pData) +{ + struct vkGetSamplerOpaqueCaptureDescriptorDataEXT_params params; + NTSTATUS status; + params.device = device; + params.pInfo = pInfo; + params.pData = pData; + status = vk_unix_call(unix_vkGetSamplerOpaqueCaptureDescriptorDataEXT, &params); + assert(!status); + return params.result; +} + VkResult WINAPI vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t *pValue) { struct vkGetSemaphoreCounterValue_params params; @@ -5984,6 +6117,8 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkCmdBeginRendering", vkCmdBeginRendering}, {"vkCmdBeginRenderingKHR", vkCmdBeginRenderingKHR}, {"vkCmdBeginTransformFeedbackEXT", vkCmdBeginTransformFeedbackEXT}, + {"vkCmdBindDescriptorBufferEmbeddedSamplersEXT", vkCmdBindDescriptorBufferEmbeddedSamplersEXT}, + {"vkCmdBindDescriptorBuffersEXT", vkCmdBindDescriptorBuffersEXT}, {"vkCmdBindDescriptorSets", vkCmdBindDescriptorSets}, {"vkCmdBindIndexBuffer", vkCmdBindIndexBuffer}, {"vkCmdBindInvocationMaskHUAWEI", vkCmdBindInvocationMaskHUAWEI}, @@ -6121,6 +6256,7 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkCmdSetDepthTestEnableEXT", vkCmdSetDepthTestEnableEXT}, {"vkCmdSetDepthWriteEnable", vkCmdSetDepthWriteEnable}, {"vkCmdSetDepthWriteEnableEXT", vkCmdSetDepthWriteEnableEXT}, + {"vkCmdSetDescriptorBufferOffsetsEXT", vkCmdSetDescriptorBufferOffsetsEXT}, {"vkCmdSetDeviceMask", vkCmdSetDeviceMask}, {"vkCmdSetDeviceMaskKHR", vkCmdSetDeviceMaskKHR}, {"vkCmdSetDiscardRectangleEXT", vkCmdSetDiscardRectangleEXT}, @@ -6289,6 +6425,7 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkGetAccelerationStructureDeviceAddressKHR", vkGetAccelerationStructureDeviceAddressKHR}, {"vkGetAccelerationStructureHandleNV", vkGetAccelerationStructureHandleNV}, {"vkGetAccelerationStructureMemoryRequirementsNV", vkGetAccelerationStructureMemoryRequirementsNV}, + {"vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT", vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT}, {"vkGetBufferDeviceAddress", vkGetBufferDeviceAddress}, {"vkGetBufferDeviceAddressEXT", vkGetBufferDeviceAddressEXT}, {"vkGetBufferDeviceAddressKHR", vkGetBufferDeviceAddressKHR}, @@ -6297,11 +6434,15 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkGetBufferMemoryRequirements2KHR", vkGetBufferMemoryRequirements2KHR}, {"vkGetBufferOpaqueCaptureAddress", vkGetBufferOpaqueCaptureAddress}, {"vkGetBufferOpaqueCaptureAddressKHR", vkGetBufferOpaqueCaptureAddressKHR}, + {"vkGetBufferOpaqueCaptureDescriptorDataEXT", vkGetBufferOpaqueCaptureDescriptorDataEXT}, {"vkGetCalibratedTimestampsEXT", vkGetCalibratedTimestampsEXT}, {"vkGetDeferredOperationMaxConcurrencyKHR", vkGetDeferredOperationMaxConcurrencyKHR}, {"vkGetDeferredOperationResultKHR", vkGetDeferredOperationResultKHR}, + {"vkGetDescriptorEXT", vkGetDescriptorEXT}, {"vkGetDescriptorSetHostMappingVALVE", vkGetDescriptorSetHostMappingVALVE}, + {"vkGetDescriptorSetLayoutBindingOffsetEXT", vkGetDescriptorSetLayoutBindingOffsetEXT}, {"vkGetDescriptorSetLayoutHostMappingInfoVALVE", vkGetDescriptorSetLayoutHostMappingInfoVALVE}, + {"vkGetDescriptorSetLayoutSizeEXT", vkGetDescriptorSetLayoutSizeEXT}, {"vkGetDescriptorSetLayoutSupport", vkGetDescriptorSetLayoutSupport}, {"vkGetDescriptorSetLayoutSupportKHR", vkGetDescriptorSetLayoutSupportKHR}, {"vkGetDeviceAccelerationStructureCompatibilityKHR", vkGetDeviceAccelerationStructureCompatibilityKHR}, @@ -6332,6 +6473,7 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkGetImageMemoryRequirements", vkGetImageMemoryRequirements}, {"vkGetImageMemoryRequirements2", vkGetImageMemoryRequirements2}, {"vkGetImageMemoryRequirements2KHR", vkGetImageMemoryRequirements2KHR}, + {"vkGetImageOpaqueCaptureDescriptorDataEXT", vkGetImageOpaqueCaptureDescriptorDataEXT}, {"vkGetImageSparseMemoryRequirements", vkGetImageSparseMemoryRequirements}, {"vkGetImageSparseMemoryRequirements2", vkGetImageSparseMemoryRequirements2}, {"vkGetImageSparseMemoryRequirements2KHR", vkGetImageSparseMemoryRequirements2KHR}, @@ -6339,6 +6481,7 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkGetImageSubresourceLayout2EXT", vkGetImageSubresourceLayout2EXT}, {"vkGetImageViewAddressNVX", vkGetImageViewAddressNVX}, {"vkGetImageViewHandleNVX", vkGetImageViewHandleNVX}, + {"vkGetImageViewOpaqueCaptureDescriptorDataEXT", vkGetImageViewOpaqueCaptureDescriptorDataEXT}, {"vkGetMemoryHostPointerPropertiesEXT", vkGetMemoryHostPointerPropertiesEXT}, {"vkGetMicromapBuildSizesEXT", vkGetMicromapBuildSizesEXT}, {"vkGetPerformanceParameterINTEL", vkGetPerformanceParameterINTEL}, @@ -6357,6 +6500,7 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkGetRayTracingShaderGroupHandlesNV", vkGetRayTracingShaderGroupHandlesNV}, {"vkGetRayTracingShaderGroupStackSizeKHR", vkGetRayTracingShaderGroupStackSizeKHR}, {"vkGetRenderAreaGranularity", vkGetRenderAreaGranularity}, + {"vkGetSamplerOpaqueCaptureDescriptorDataEXT", vkGetSamplerOpaqueCaptureDescriptorDataEXT}, {"vkGetSemaphoreCounterValue", vkGetSemaphoreCounterValue}, {"vkGetSemaphoreCounterValueKHR", vkGetSemaphoreCounterValueKHR}, {"vkGetShaderInfoAMD", vkGetShaderInfoAMD}, diff --git a/dlls/winevulkan/loader_thunks.h b/dlls/winevulkan/loader_thunks.h index a35ced6f2f8..f2a9a6f18ff 100644 --- a/dlls/winevulkan/loader_thunks.h +++ b/dlls/winevulkan/loader_thunks.h @@ -45,6 +45,8 @@ enum unix_call unix_vkCmdBeginRendering, unix_vkCmdBeginRenderingKHR, unix_vkCmdBeginTransformFeedbackEXT, + unix_vkCmdBindDescriptorBufferEmbeddedSamplersEXT, + unix_vkCmdBindDescriptorBuffersEXT, unix_vkCmdBindDescriptorSets, unix_vkCmdBindIndexBuffer, unix_vkCmdBindInvocationMaskHUAWEI, @@ -182,6 +184,7 @@ enum unix_call unix_vkCmdSetDepthTestEnableEXT, unix_vkCmdSetDepthWriteEnable, unix_vkCmdSetDepthWriteEnableEXT, + unix_vkCmdSetDescriptorBufferOffsetsEXT, unix_vkCmdSetDeviceMask, unix_vkCmdSetDeviceMaskKHR, unix_vkCmdSetDiscardRectangleEXT, @@ -368,6 +371,7 @@ enum unix_call unix_vkGetAccelerationStructureDeviceAddressKHR, unix_vkGetAccelerationStructureHandleNV, unix_vkGetAccelerationStructureMemoryRequirementsNV, + unix_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT, unix_vkGetBufferDeviceAddress, unix_vkGetBufferDeviceAddressEXT, unix_vkGetBufferDeviceAddressKHR, @@ -376,11 +380,15 @@ enum unix_call unix_vkGetBufferMemoryRequirements2KHR, unix_vkGetBufferOpaqueCaptureAddress, unix_vkGetBufferOpaqueCaptureAddressKHR, + unix_vkGetBufferOpaqueCaptureDescriptorDataEXT, unix_vkGetCalibratedTimestampsEXT, unix_vkGetDeferredOperationMaxConcurrencyKHR, unix_vkGetDeferredOperationResultKHR, + unix_vkGetDescriptorEXT, unix_vkGetDescriptorSetHostMappingVALVE, + unix_vkGetDescriptorSetLayoutBindingOffsetEXT, unix_vkGetDescriptorSetLayoutHostMappingInfoVALVE, + unix_vkGetDescriptorSetLayoutSizeEXT, unix_vkGetDescriptorSetLayoutSupport, unix_vkGetDescriptorSetLayoutSupportKHR, unix_vkGetDeviceAccelerationStructureCompatibilityKHR, @@ -410,6 +418,7 @@ enum unix_call unix_vkGetImageMemoryRequirements, unix_vkGetImageMemoryRequirements2, unix_vkGetImageMemoryRequirements2KHR, + unix_vkGetImageOpaqueCaptureDescriptorDataEXT, unix_vkGetImageSparseMemoryRequirements, unix_vkGetImageSparseMemoryRequirements2, unix_vkGetImageSparseMemoryRequirements2KHR, @@ -417,6 +426,7 @@ enum unix_call unix_vkGetImageSubresourceLayout2EXT, unix_vkGetImageViewAddressNVX, unix_vkGetImageViewHandleNVX, + unix_vkGetImageViewOpaqueCaptureDescriptorDataEXT, unix_vkGetMemoryHostPointerPropertiesEXT, unix_vkGetMicromapBuildSizesEXT, unix_vkGetPerformanceParameterINTEL, @@ -479,6 +489,7 @@ enum unix_call unix_vkGetRayTracingShaderGroupHandlesNV, unix_vkGetRayTracingShaderGroupStackSizeKHR, unix_vkGetRenderAreaGranularity, + unix_vkGetSamplerOpaqueCaptureDescriptorDataEXT, unix_vkGetSemaphoreCounterValue, unix_vkGetSemaphoreCounterValueKHR, unix_vkGetShaderInfoAMD, @@ -759,6 +770,21 @@ struct vkCmdBeginTransformFeedbackEXT_params const VkDeviceSize *pCounterBufferOffsets; };

+struct vkCmdBindDescriptorBufferEmbeddedSamplersEXT_params +{ + VkCommandBuffer commandBuffer; + VkPipelineBindPoint pipelineBindPoint; + VkPipelineLayout DECLSPEC_ALIGN(8) layout; + uint32_t set; +}; + +struct vkCmdBindDescriptorBuffersEXT_params +{ + VkCommandBuffer commandBuffer; + uint32_t bufferCount; + const VkDescriptorBufferBindingInfoEXT *pBindingInfos; +}; + struct vkCmdBindDescriptorSets_params { VkCommandBuffer commandBuffer; @@ -1817,6 +1843,17 @@ struct vkCmdSetDepthWriteEnableEXT_params VkBool32 depthWriteEnable; };

+struct vkCmdSetDescriptorBufferOffsetsEXT_params +{ + VkCommandBuffer commandBuffer; + VkPipelineBindPoint pipelineBindPoint; + VkPipelineLayout DECLSPEC_ALIGN(8) layout; + uint32_t firstSet; + uint32_t setCount; + const uint32_t *pBufferIndices; + const VkDeviceSize *pOffsets; +}; + struct vkCmdSetDeviceMask_params { VkCommandBuffer commandBuffer; @@ -3272,6 +3309,14 @@ struct vkGetAccelerationStructureMemoryRequirementsNV_params VkMemoryRequirements2KHR *pMemoryRequirements; };

+struct vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_params +{ + VkDevice device; + const VkAccelerationStructureCaptureDescriptorDataInfoEXT *pInfo; + void *pData; + VkResult result; +}; + struct vkGetBufferDeviceAddress_params { VkDevice device; @@ -3328,6 +3373,14 @@ struct vkGetBufferOpaqueCaptureAddressKHR_params uint64_t result; };

+struct vkGetBufferOpaqueCaptureDescriptorDataEXT_params +{ + VkDevice device; + const VkBufferCaptureDescriptorDataInfoEXT *pInfo; + void *pData; + VkResult result; +}; + struct vkGetCalibratedTimestampsEXT_params { VkDevice device; @@ -3352,6 +3405,14 @@ struct vkGetDeferredOperationResultKHR_params VkResult result; };

+struct vkGetDescriptorEXT_params +{ + VkDevice device; + const VkDescriptorGetInfoEXT *pDescriptorInfo; + size_t dataSize; + void *pDescriptor; +}; + struct vkGetDescriptorSetHostMappingVALVE_params { VkDevice device; @@ -3359,6 +3420,14 @@ struct vkGetDescriptorSetHostMappingVALVE_params void **ppData; };

+struct vkGetDescriptorSetLayoutBindingOffsetEXT_params +{ + VkDevice device; + VkDescriptorSetLayout DECLSPEC_ALIGN(8) layout; + uint32_t binding; + VkDeviceSize *pOffset; +}; + struct vkGetDescriptorSetLayoutHostMappingInfoVALVE_params { VkDevice device; @@ -3366,6 +3435,13 @@ struct vkGetDescriptorSetLayoutHostMappingInfoVALVE_params VkDescriptorSetLayoutHostMappingInfoVALVE *pHostMapping; };

+struct vkGetDescriptorSetLayoutSizeEXT_params +{ + VkDevice device; + VkDescriptorSetLayout DECLSPEC_ALIGN(8) layout; + VkDeviceSize *pLayoutSizeInBytes; +}; + struct vkGetDescriptorSetLayoutSupport_params { VkDevice device; @@ -3582,6 +3658,14 @@ struct vkGetImageMemoryRequirements2KHR_params VkMemoryRequirements2 *pMemoryRequirements; };

+struct vkGetImageOpaqueCaptureDescriptorDataEXT_params +{ + VkDevice device; + const VkImageCaptureDescriptorDataInfoEXT *pInfo; + void *pData; + VkResult result; +}; + struct vkGetImageSparseMemoryRequirements_params { VkDevice device; @@ -3637,6 +3721,14 @@ struct vkGetImageViewHandleNVX_params uint32_t result; };

+struct vkGetImageViewOpaqueCaptureDescriptorDataEXT_params +{ + VkDevice device; + const VkImageViewCaptureDescriptorDataInfoEXT *pInfo; + void *pData; + VkResult result; +}; + struct vkGetMemoryHostPointerPropertiesEXT_params { VkDevice device; @@ -4133,6 +4225,14 @@ struct vkGetRenderAreaGranularity_params VkExtent2D *pGranularity; };

+struct vkGetSamplerOpaqueCaptureDescriptorDataEXT_params +{ + VkDevice device; + const VkSamplerCaptureDescriptorDataInfoEXT *pInfo; + void *pData; + VkResult result; +}; + struct vkGetSemaphoreCounterValue_params { VkDevice device; diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan index 95354f8fa0d..6d07423a5ed 100755 --- a/dlls/winevulkan/make_vulkan +++ b/dlls/winevulkan/make_vulkan @@ -65,7 +65,7 @@ from enum import Enum LOGGER = logging.Logger("vulkan") LOGGER.addHandler(logging.StreamHandler())

-VK_XML_VERSION = "1.3.233" +VK_XML_VERSION = "1.3.235" WINE_VK_VERSION = (1, 3)

# Filenames to create. @@ -2042,7 +2042,8 @@ class VkStruct(Sequence): return False is_const = self.members[self.members.index("pNext")].is_const() # VkOpticalFlowSessionCreateInfoNV is missing const in its pNext pointer - if self.name == "VkOpticalFlowSessionCreateInfoNV": + if self.name in ["VkOpticalFlowSessionCreateInfoNV", + "VkDescriptorBufferBindingInfoEXT"]: is_const = True needs_output_copy = False

diff --git a/dlls/winevulkan/vulkan_thunks.c b/dlls/winevulkan/vulkan_thunks.c index 9e5ab4d8c3b..2181daf678a 100644 --- a/dlls/winevulkan/vulkan_thunks.c +++ b/dlls/winevulkan/vulkan_thunks.c @@ -567,6 +567,21 @@ typedef struct VkRenderingInfo32 } VkRenderingInfo32; typedef VkRenderingInfo32 VkRenderingInfoKHR32;

+typedef struct VkDescriptorBufferBindingPushDescriptorBufferHandleEXT32 +{ + VkStructureType sType; + PTR32 pNext; + VkBuffer DECLSPEC_ALIGN(8) buffer; +} VkDescriptorBufferBindingPushDescriptorBufferHandleEXT32; + +typedef struct VkDescriptorBufferBindingInfoEXT32 +{ + VkStructureType sType; + PTR32 pNext; + VkDeviceAddress DECLSPEC_ALIGN(8) address; + VkBufferUsageFlags usage; +} VkDescriptorBufferBindingInfoEXT32; + typedef struct VkCopyCommandTransformInfoQCOM32 { VkStructureType sType; @@ -1125,6 +1140,13 @@ typedef struct VkStridedDeviceAddressRegionKHR32 VkDeviceSize DECLSPEC_ALIGN(8) size; } VkStridedDeviceAddressRegionKHR32;

+typedef struct VkOpaqueCaptureDescriptorDataCreateInfoEXT32 +{ + VkStructureType sType; + PTR32 pNext; + PTR32 opaqueCaptureDescriptorData; +} VkOpaqueCaptureDescriptorDataCreateInfoEXT32; + typedef struct VkAccelerationStructureMotionInfoNV32 { VkStructureType sType; @@ -2523,6 +2545,16 @@ typedef struct VkPhysicalDeviceProvokingVertexFeaturesEXT32 VkBool32 transformFeedbackPreservesProvokingVertex; } VkPhysicalDeviceProvokingVertexFeaturesEXT32;

+typedef struct VkPhysicalDeviceDescriptorBufferFeaturesEXT32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 descriptorBuffer; + VkBool32 descriptorBufferCaptureReplay; + VkBool32 descriptorBufferImageLayoutIgnored; + VkBool32 descriptorBufferPushDescriptors; +} VkPhysicalDeviceDescriptorBufferFeaturesEXT32; + typedef struct VkPhysicalDeviceShaderIntegerDotProductFeatures32 { VkStructureType sType; @@ -3951,6 +3983,14 @@ typedef struct VkMemoryRequirements32 } VkMemoryRequirements32;

+typedef struct VkAccelerationStructureCaptureDescriptorDataInfoEXT32 +{ + VkStructureType sType; + PTR32 pNext; + VkAccelerationStructureKHR DECLSPEC_ALIGN(8) accelerationStructure; + VkAccelerationStructureNV DECLSPEC_ALIGN(8) accelerationStructureNV; +} VkAccelerationStructureCaptureDescriptorDataInfoEXT32; + typedef struct VkBufferDeviceAddressInfo32 { VkStructureType sType; @@ -3985,6 +4025,13 @@ typedef struct VkMemoryRequirements232 } VkMemoryRequirements232; typedef VkMemoryRequirements232 VkMemoryRequirements2KHR32;

+typedef struct VkBufferCaptureDescriptorDataInfoEXT32 +{ + VkStructureType sType; + PTR32 pNext; + VkBuffer DECLSPEC_ALIGN(8) buffer; +} VkBufferCaptureDescriptorDataInfoEXT32; + typedef struct VkCalibratedTimestampInfoEXT32 { VkStructureType sType; @@ -3992,6 +4039,37 @@ typedef struct VkCalibratedTimestampInfoEXT32 VkTimeDomainEXT timeDomain; } VkCalibratedTimestampInfoEXT32;

+typedef struct VkDescriptorAddressInfoEXT32 +{ + VkStructureType sType; + PTR32 pNext; + VkDeviceAddress DECLSPEC_ALIGN(8) address; + VkDeviceSize DECLSPEC_ALIGN(8) range; + VkFormat format; +} VkDescriptorAddressInfoEXT32; + +typedef union VkDescriptorDataEXT32 +{ + PTR32 pSampler; + PTR32 pCombinedImageSampler; + PTR32 pInputAttachmentImage; + PTR32 pSampledImage; + PTR32 pStorageImage; + PTR32 pUniformTexelBuffer; + PTR32 pStorageTexelBuffer; + PTR32 pUniformBuffer; + PTR32 pStorageBuffer; + VkDeviceAddress DECLSPEC_ALIGN(8) accelerationStructure; +} VkDescriptorDataEXT32; + +typedef struct VkDescriptorGetInfoEXT32 +{ + VkStructureType sType; + PTR32 pNext; + VkDescriptorType type; + VkDescriptorDataEXT32 DECLSPEC_ALIGN(8) data; +} VkDescriptorGetInfoEXT32; + typedef struct VkDescriptorSetBindingReferenceVALVE32 { VkStructureType sType; @@ -4165,6 +4243,13 @@ typedef struct VkImageMemoryRequirementsInfo232 } VkImageMemoryRequirementsInfo232; typedef VkImageMemoryRequirementsInfo232 VkImageMemoryRequirementsInfo2KHR32;

+typedef struct VkImageCaptureDescriptorDataInfoEXT32 +{ + VkStructureType sType; + PTR32 pNext; + VkImage DECLSPEC_ALIGN(8) image; +} VkImageCaptureDescriptorDataInfoEXT32; + typedef struct VkImageSparseMemoryRequirementsInfo232 { VkStructureType sType; @@ -4221,6 +4306,13 @@ typedef struct VkImageViewHandleInfoNVX32 VkSampler DECLSPEC_ALIGN(8) sampler; } VkImageViewHandleInfoNVX32;

+typedef struct VkImageViewCaptureDescriptorDataInfoEXT32 +{ + VkStructureType sType; + PTR32 pNext; + VkImageView DECLSPEC_ALIGN(8) imageView; +} VkImageViewCaptureDescriptorDataInfoEXT32; + typedef struct VkMemoryHostPointerPropertiesEXT32 { VkStructureType sType; @@ -5298,6 +5390,52 @@ typedef struct VkPhysicalDeviceProvokingVertexPropertiesEXT32 VkBool32 transformFeedbackPreservesTriangleFanProvokingVertex; } VkPhysicalDeviceProvokingVertexPropertiesEXT32;

+typedef struct VkPhysicalDeviceDescriptorBufferPropertiesEXT32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 combinedImageSamplerDescriptorSingleArray; + VkBool32 bufferlessPushDescriptors; + VkBool32 allowSamplerImageViewPostSubmitCreation; + VkDeviceSize DECLSPEC_ALIGN(8) descriptorBufferOffsetAlignment; + uint32_t maxDescriptorBufferBindings; + uint32_t maxResourceDescriptorBufferBindings; + uint32_t maxSamplerDescriptorBufferBindings; + uint32_t maxEmbeddedImmutableSamplerBindings; + uint32_t maxEmbeddedImmutableSamplers; + PTR32 bufferCaptureReplayDescriptorDataSize; + PTR32 imageCaptureReplayDescriptorDataSize; + PTR32 imageViewCaptureReplayDescriptorDataSize; + PTR32 samplerCaptureReplayDescriptorDataSize; + PTR32 accelerationStructureCaptureReplayDescriptorDataSize; + PTR32 samplerDescriptorSize; + PTR32 combinedImageSamplerDescriptorSize; + PTR32 sampledImageDescriptorSize; + PTR32 storageImageDescriptorSize; + PTR32 uniformTexelBufferDescriptorSize; + PTR32 robustUniformTexelBufferDescriptorSize; + PTR32 storageTexelBufferDescriptorSize; + PTR32 robustStorageTexelBufferDescriptorSize; + PTR32 uniformBufferDescriptorSize; + PTR32 robustUniformBufferDescriptorSize; + PTR32 storageBufferDescriptorSize; + PTR32 robustStorageBufferDescriptorSize; + PTR32 inputAttachmentDescriptorSize; + PTR32 accelerationStructureDescriptorSize; + VkDeviceSize DECLSPEC_ALIGN(8) maxSamplerDescriptorBufferRange; + VkDeviceSize DECLSPEC_ALIGN(8) maxResourceDescriptorBufferRange; + VkDeviceSize DECLSPEC_ALIGN(8) samplerDescriptorBufferAddressSpaceSize; + VkDeviceSize DECLSPEC_ALIGN(8) resourceDescriptorBufferAddressSpaceSize; + VkDeviceSize DECLSPEC_ALIGN(8) descriptorBufferAddressSpaceSize; +} VkPhysicalDeviceDescriptorBufferPropertiesEXT32; + +typedef struct VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT32 +{ + VkStructureType sType; + PTR32 pNext; + PTR32 combinedImageSamplerDensityMapDescriptorSize; +} VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT32; + typedef struct VkPhysicalDeviceShaderIntegerDotProductProperties32 { VkStructureType sType; @@ -5599,6 +5737,13 @@ typedef struct VkCheckpointDataNV32 PTR32 pCheckpointMarker; } VkCheckpointDataNV32;

+typedef struct VkSamplerCaptureDescriptorDataInfoEXT32 +{ + VkStructureType sType; + PTR32 pNext; + VkSampler DECLSPEC_ALIGN(8) sampler; +} VkSamplerCaptureDescriptorDataInfoEXT32; + typedef struct VkShaderModuleIdentifierEXT32 { VkStructureType sType; @@ -6999,6 +7144,56 @@ static inline void convert_VkRenderingInfo_win32_to_host(struct conversion_conte } }

+static inline void convert_VkDescriptorBufferBindingInfoEXT_win32_to_host(struct conversion_context *ctx, const VkDescriptorBufferBindingInfoEXT32 *in, VkDescriptorBufferBindingInfoEXT *out) +{ + const VkBaseInStructure32 *in_header; + VkBaseOutStructure *out_header = (void *)out; + + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->address = in->address; + out->usage = in->usage; + + for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext)) + { + switch (in_header->sType) + { + case VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT: + { + VkDescriptorBufferBindingPushDescriptorBufferHandleEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT32 *in_ext = (const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT; + out_ext->pNext = NULL; + out_ext->buffer = in_ext->buffer; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + default: + FIXME("Unhandled sType %u.", in_header->sType); + break; + } + } +} + +static inline const VkDescriptorBufferBindingInfoEXT *convert_VkDescriptorBufferBindingInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorBufferBindingInfoEXT32 *in, uint32_t count) +{ + VkDescriptorBufferBindingInfoEXT *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkDescriptorBufferBindingInfoEXT_win32_to_host(ctx, &in[i], &out[i]); + } + + return out; +} + static inline void convert_VkImageBlit2_win32_to_host(struct conversion_context *ctx, const VkImageBlit232 *in, VkImageBlit2 *out) { const VkBaseInStructure32 *in_header; @@ -8279,6 +8474,17 @@ static inline void convert_VkAccelerationStructureCreateInfoKHR_win32_to_host(st { switch (in_header->sType) { + case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: + { + VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT; + out_ext->pNext = NULL; + out_ext->opaqueCaptureDescriptorData = (const void *)UlongToPtr(in_ext->opaqueCaptureDescriptorData); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV: { VkAccelerationStructureMotionInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -8300,14 +8506,36 @@ static inline void convert_VkAccelerationStructureCreateInfoKHR_win32_to_host(st

static inline void convert_VkAccelerationStructureCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureCreateInfoNV32 *in, VkAccelerationStructureCreateInfoNV *out) { + const VkBaseInStructure32 *in_header; + VkBaseOutStructure *out_header = (void *)out; + if (!in) return;

out->sType = in->sType; out->pNext = NULL; out->compactedSize = in->compactedSize; convert_VkAccelerationStructureInfoNV_win32_to_host(ctx, &in->info, &out->info); - if (in->pNext) - FIXME("Unexpected pNext\n"); + + for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext)) + { + switch (in_header->sType) + { + case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: + { + VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT; + out_ext->pNext = NULL; + out_ext->opaqueCaptureDescriptorData = (const void *)UlongToPtr(in_ext->opaqueCaptureDescriptorData); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + default: + FIXME("Unhandled sType %u.", in_header->sType); + break; + } + } }

static inline void convert_VkBufferCreateInfo_win32_to_host(struct conversion_context *ctx, const VkBufferCreateInfo32 *in, VkBufferCreateInfo *out) @@ -8374,6 +8602,17 @@ static inline void convert_VkBufferCreateInfo_win32_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: + { + VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT; + out_ext->pNext = NULL; + out_ext->opaqueCaptureDescriptorData = (const void *)UlongToPtr(in_ext->opaqueCaptureDescriptorData); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.", in_header->sType); break; @@ -10694,6 +10933,20 @@ static inline void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: + { + VkPhysicalDeviceDescriptorBufferFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDescriptorBufferFeaturesEXT *in_ext = (const VkPhysicalDeviceDescriptorBufferFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT; + out_ext->pNext = NULL; + out_ext->descriptorBuffer = in_ext->descriptorBuffer; + out_ext->descriptorBufferCaptureReplay = in_ext->descriptorBufferCaptureReplay; + out_ext->descriptorBufferImageLayoutIgnored = in_ext->descriptorBufferImageLayoutIgnored; + out_ext->descriptorBufferPushDescriptors = in_ext->descriptorBufferPushDescriptors; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: { VkPhysicalDeviceShaderIntegerDotProductFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -12508,6 +12761,20 @@ static inline void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: + { + VkPhysicalDeviceDescriptorBufferFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDescriptorBufferFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDescriptorBufferFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT; + out_ext->pNext = NULL; + out_ext->descriptorBuffer = in_ext->descriptorBuffer; + out_ext->descriptorBufferCaptureReplay = in_ext->descriptorBufferCaptureReplay; + out_ext->descriptorBufferImageLayoutIgnored = in_ext->descriptorBufferImageLayoutIgnored; + out_ext->descriptorBufferPushDescriptors = in_ext->descriptorBufferPushDescriptors; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: { VkPhysicalDeviceShaderIntegerDotProductFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -14209,6 +14476,17 @@ static inline void convert_VkImageCreateInfo_win32_to_host(struct conversion_con out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: + { + VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT; + out_ext->pNext = NULL; + out_ext->opaqueCaptureDescriptorData = (const void *)UlongToPtr(in_ext->opaqueCaptureDescriptorData); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT: { VkImageCompressionControlEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -14293,6 +14571,17 @@ static inline void convert_VkImageViewCreateInfo_win32_to_host(struct conversion out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: + { + VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT; + out_ext->pNext = NULL; + out_ext->opaqueCaptureDescriptorData = (const void *)UlongToPtr(in_ext->opaqueCaptureDescriptorData); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT: { VkImageViewMinLodCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -15649,6 +15938,17 @@ static inline void convert_VkSamplerCreateInfo_win32_to_host(struct conversion_c out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: + { + VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT; + out_ext->pNext = NULL; + out_ext->opaqueCaptureDescriptorData = (const void *)UlongToPtr(in_ext->opaqueCaptureDescriptorData); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.", in_header->sType); break; @@ -16201,6 +16501,18 @@ static inline void convert_VkMemoryRequirements2KHR_host_to_win32(const VkMemory convert_VkMemoryRequirements_host_to_win32(&in->memoryRequirements, &out->memoryRequirements); }

+static inline void convert_VkAccelerationStructureCaptureDescriptorDataInfoEXT_win32_to_host(const VkAccelerationStructureCaptureDescriptorDataInfoEXT32 *in, VkAccelerationStructureCaptureDescriptorDataInfoEXT *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->accelerationStructure = in->accelerationStructure; + out->accelerationStructureNV = in->accelerationStructureNV; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + static inline void convert_VkBufferDeviceAddressInfo_win32_to_host(const VkBufferDeviceAddressInfo32 *in, VkBufferDeviceAddressInfo *out) { if (!in) return; @@ -16282,6 +16594,17 @@ static inline void convert_VkMemoryRequirements2_host_to_win32(const VkMemoryReq } }

+static inline void convert_VkBufferCaptureDescriptorDataInfoEXT_win32_to_host(const VkBufferCaptureDescriptorDataInfoEXT32 *in, VkBufferCaptureDescriptorDataInfoEXT *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->buffer = in->buffer; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + static inline void convert_VkCalibratedTimestampInfoEXT_win32_to_host(const VkCalibratedTimestampInfoEXT32 *in, VkCalibratedTimestampInfoEXT *out) { if (!in) return; @@ -16309,6 +16632,73 @@ static inline const VkCalibratedTimestampInfoEXT *convert_VkCalibratedTimestampI return out; }

+static inline void convert_VkDescriptorAddressInfoEXT_win32_to_host(const VkDescriptorAddressInfoEXT32 *in, VkDescriptorAddressInfoEXT *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->address = in->address; + out->range = in->range; + out->format = in->format; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static inline const VkDescriptorAddressInfoEXT *convert_VkDescriptorAddressInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorAddressInfoEXT32 *in, uint32_t count) +{ + VkDescriptorAddressInfoEXT *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkDescriptorAddressInfoEXT_win32_to_host(&in[i], &out[i]); + } + + return out; +} + +static inline void convert_VkDescriptorDataEXT_win32_to_host(struct conversion_context *ctx, const VkDescriptorDataEXT32 *in, VkDescriptorDataEXT *out, VkFlags selector) +{ + if (!in) return; + + if (selector == VK_DESCRIPTOR_TYPE_SAMPLER) + out->pSampler = (const VkSampler *)UlongToPtr(in->pSampler); + if (selector == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER) + out->pCombinedImageSampler = convert_VkDescriptorImageInfo_array_win32_to_host(ctx, (const VkDescriptorImageInfo32 *)UlongToPtr(in->pCombinedImageSampler), 1); + if (selector == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT) + out->pInputAttachmentImage = convert_VkDescriptorImageInfo_array_win32_to_host(ctx, (const VkDescriptorImageInfo32 *)UlongToPtr(in->pInputAttachmentImage), 1); + if (selector == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE) + out->pSampledImage = convert_VkDescriptorImageInfo_array_win32_to_host(ctx, (const VkDescriptorImageInfo32 *)UlongToPtr(in->pSampledImage), 1); + if (selector == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE) + out->pStorageImage = convert_VkDescriptorImageInfo_array_win32_to_host(ctx, (const VkDescriptorImageInfo32 *)UlongToPtr(in->pStorageImage), 1); + if (selector == VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER) + out->pUniformTexelBuffer = convert_VkDescriptorAddressInfoEXT_array_win32_to_host(ctx, (const VkDescriptorAddressInfoEXT32 *)UlongToPtr(in->pUniformTexelBuffer), 1); + if (selector == VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER) + out->pStorageTexelBuffer = convert_VkDescriptorAddressInfoEXT_array_win32_to_host(ctx, (const VkDescriptorAddressInfoEXT32 *)UlongToPtr(in->pStorageTexelBuffer), 1); + if (selector == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER) + out->pUniformBuffer = convert_VkDescriptorAddressInfoEXT_array_win32_to_host(ctx, (const VkDescriptorAddressInfoEXT32 *)UlongToPtr(in->pUniformBuffer), 1); + if (selector == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER) + out->pStorageBuffer = convert_VkDescriptorAddressInfoEXT_array_win32_to_host(ctx, (const VkDescriptorAddressInfoEXT32 *)UlongToPtr(in->pStorageBuffer), 1); + if (selector == VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR || selector == VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV) + out->accelerationStructure = in->accelerationStructure; +} + +static inline void convert_VkDescriptorGetInfoEXT_win32_to_host(struct conversion_context *ctx, const VkDescriptorGetInfoEXT32 *in, VkDescriptorGetInfoEXT *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->type = in->type; + convert_VkDescriptorDataEXT_win32_to_host(ctx, &in->data, &out->data, in->type); + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + static inline void convert_VkDescriptorSetBindingReferenceVALVE_win32_to_host(const VkDescriptorSetBindingReferenceVALVE32 *in, VkDescriptorSetBindingReferenceVALVE *out) { if (!in) return; @@ -16809,6 +17199,17 @@ static inline void convert_VkImageMemoryRequirementsInfo2_win32_to_host(struct c } }

+static inline void convert_VkImageCaptureDescriptorDataInfoEXT_win32_to_host(const VkImageCaptureDescriptorDataInfoEXT32 *in, VkImageCaptureDescriptorDataInfoEXT *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->image = in->image; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + static inline void convert_VkSparseImageMemoryRequirements_array_host_to_win32(const VkSparseImageMemoryRequirements *in, VkSparseImageMemoryRequirements32 *out, uint32_t count) { unsigned int i; @@ -16944,6 +17345,17 @@ static inline void convert_VkImageViewHandleInfoNVX_win32_to_host(const VkImageV FIXME("Unexpected pNext\n"); }

+static inline void convert_VkImageViewCaptureDescriptorDataInfoEXT_win32_to_host(const VkImageViewCaptureDescriptorDataInfoEXT32 *in, VkImageViewCaptureDescriptorDataInfoEXT *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->imageView = in->imageView; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + static inline void convert_VkMemoryHostPointerPropertiesEXT_win32_to_host(const VkMemoryHostPointerPropertiesEXT32 *in, VkMemoryHostPointerPropertiesEXT *out) { if (!in) return; @@ -18611,6 +19023,20 @@ static inline void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conver out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: + { + VkPhysicalDeviceDescriptorBufferFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDescriptorBufferFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDescriptorBufferFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT; + out_ext->pNext = NULL; + out_ext->descriptorBuffer = in_ext->descriptorBuffer; + out_ext->descriptorBufferCaptureReplay = in_ext->descriptorBufferCaptureReplay; + out_ext->descriptorBufferImageLayoutIgnored = in_ext->descriptorBufferImageLayoutIgnored; + out_ext->descriptorBufferPushDescriptors = in_ext->descriptorBufferPushDescriptors; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: { VkPhysicalDeviceShaderIntegerDotProductFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -20139,6 +20565,18 @@ static inline void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysi out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: + { + VkPhysicalDeviceDescriptorBufferFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT); + const VkPhysicalDeviceDescriptorBufferFeaturesEXT *in_ext = (const VkPhysicalDeviceDescriptorBufferFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT; + out_ext->descriptorBuffer = in_ext->descriptorBuffer; + out_ext->descriptorBufferCaptureReplay = in_ext->descriptorBufferCaptureReplay; + out_ext->descriptorBufferImageLayoutIgnored = in_ext->descriptorBufferImageLayoutIgnored; + out_ext->descriptorBufferPushDescriptors = in_ext->descriptorBufferPushDescriptors; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: { VkPhysicalDeviceShaderIntegerDotProductFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES); @@ -21560,6 +21998,24 @@ static inline void convert_VkPhysicalDeviceProperties2_win32_to_host(struct conv out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT: + { + VkPhysicalDeviceDescriptorBufferPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT: + { + VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: { VkPhysicalDeviceShaderIntegerDotProductProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -22470,6 +22926,56 @@ static inline void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhy out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT: + { + VkPhysicalDeviceDescriptorBufferPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT); + const VkPhysicalDeviceDescriptorBufferPropertiesEXT *in_ext = (const VkPhysicalDeviceDescriptorBufferPropertiesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT; + out_ext->combinedImageSamplerDescriptorSingleArray = in_ext->combinedImageSamplerDescriptorSingleArray; + out_ext->bufferlessPushDescriptors = in_ext->bufferlessPushDescriptors; + out_ext->allowSamplerImageViewPostSubmitCreation = in_ext->allowSamplerImageViewPostSubmitCreation; + out_ext->descriptorBufferOffsetAlignment = in_ext->descriptorBufferOffsetAlignment; + out_ext->maxDescriptorBufferBindings = in_ext->maxDescriptorBufferBindings; + out_ext->maxResourceDescriptorBufferBindings = in_ext->maxResourceDescriptorBufferBindings; + out_ext->maxSamplerDescriptorBufferBindings = in_ext->maxSamplerDescriptorBufferBindings; + out_ext->maxEmbeddedImmutableSamplerBindings = in_ext->maxEmbeddedImmutableSamplerBindings; + out_ext->maxEmbeddedImmutableSamplers = in_ext->maxEmbeddedImmutableSamplers; + out_ext->bufferCaptureReplayDescriptorDataSize = in_ext->bufferCaptureReplayDescriptorDataSize; + out_ext->imageCaptureReplayDescriptorDataSize = in_ext->imageCaptureReplayDescriptorDataSize; + out_ext->imageViewCaptureReplayDescriptorDataSize = in_ext->imageViewCaptureReplayDescriptorDataSize; + out_ext->samplerCaptureReplayDescriptorDataSize = in_ext->samplerCaptureReplayDescriptorDataSize; + out_ext->accelerationStructureCaptureReplayDescriptorDataSize = in_ext->accelerationStructureCaptureReplayDescriptorDataSize; + out_ext->samplerDescriptorSize = in_ext->samplerDescriptorSize; + out_ext->combinedImageSamplerDescriptorSize = in_ext->combinedImageSamplerDescriptorSize; + out_ext->sampledImageDescriptorSize = in_ext->sampledImageDescriptorSize; + out_ext->storageImageDescriptorSize = in_ext->storageImageDescriptorSize; + out_ext->uniformTexelBufferDescriptorSize = in_ext->uniformTexelBufferDescriptorSize; + out_ext->robustUniformTexelBufferDescriptorSize = in_ext->robustUniformTexelBufferDescriptorSize; + out_ext->storageTexelBufferDescriptorSize = in_ext->storageTexelBufferDescriptorSize; + out_ext->robustStorageTexelBufferDescriptorSize = in_ext->robustStorageTexelBufferDescriptorSize; + out_ext->uniformBufferDescriptorSize = in_ext->uniformBufferDescriptorSize; + out_ext->robustUniformBufferDescriptorSize = in_ext->robustUniformBufferDescriptorSize; + out_ext->storageBufferDescriptorSize = in_ext->storageBufferDescriptorSize; + out_ext->robustStorageBufferDescriptorSize = in_ext->robustStorageBufferDescriptorSize; + out_ext->inputAttachmentDescriptorSize = in_ext->inputAttachmentDescriptorSize; + out_ext->accelerationStructureDescriptorSize = in_ext->accelerationStructureDescriptorSize; + out_ext->maxSamplerDescriptorBufferRange = in_ext->maxSamplerDescriptorBufferRange; + out_ext->maxResourceDescriptorBufferRange = in_ext->maxResourceDescriptorBufferRange; + out_ext->samplerDescriptorBufferAddressSpaceSize = in_ext->samplerDescriptorBufferAddressSpaceSize; + out_ext->resourceDescriptorBufferAddressSpaceSize = in_ext->resourceDescriptorBufferAddressSpaceSize; + out_ext->descriptorBufferAddressSpaceSize = in_ext->descriptorBufferAddressSpaceSize; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT: + { + VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT); + const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT *in_ext = (const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT; + out_ext->combinedImageSamplerDensityMapDescriptorSize = in_ext->combinedImageSamplerDensityMapDescriptorSize; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: { VkPhysicalDeviceShaderIntegerDotProductProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES); @@ -23374,6 +23880,17 @@ static inline void convert_VkCheckpointDataNV_array_host_to_win32(const VkCheckp } }

+static inline void convert_VkSamplerCaptureDescriptorDataInfoEXT_win32_to_host(const VkSamplerCaptureDescriptorDataInfoEXT32 *in, VkSamplerCaptureDescriptorDataInfoEXT *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->sampler = in->sampler; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + static inline void convert_VkShaderModuleIdentifierEXT_win32_to_host(const VkShaderModuleIdentifierEXT32 *in, VkShaderModuleIdentifierEXT *out) { if (!in) return; @@ -25113,6 +25630,66 @@ static NTSTATUS thunk32_vkCmdBeginTransformFeedbackEXT(void *args) return STATUS_SUCCESS; }

+#ifdef _WIN64 +static NTSTATUS thunk64_vkCmdBindDescriptorBufferEmbeddedSamplersEXT(void *args) +{ + struct vkCmdBindDescriptorBufferEmbeddedSamplersEXT_params *params = args; + + TRACE("%p, %#x, 0x%s, %u\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->layout), params->set); + + wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindDescriptorBufferEmbeddedSamplersEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineBindPoint, params->layout, params->set); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkCmdBindDescriptorBufferEmbeddedSamplersEXT(void *args) +{ + struct + { + PTR32 commandBuffer; + VkPipelineBindPoint pipelineBindPoint; + VkPipelineLayout DECLSPEC_ALIGN(8) layout; + uint32_t set; + } *params = args; + + TRACE("%#x, %#x, 0x%s, %u\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->layout), params->set); + + wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBindDescriptorBufferEmbeddedSamplersEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->pipelineBindPoint, params->layout, params->set); + return STATUS_SUCCESS; +} + +#ifdef _WIN64 +static NTSTATUS thunk64_vkCmdBindDescriptorBuffersEXT(void *args) +{ + struct vkCmdBindDescriptorBuffersEXT_params *params = args; + + TRACE("%p, %u, %p\n", params->commandBuffer, params->bufferCount, params->pBindingInfos); + + wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindDescriptorBuffersEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->bufferCount, params->pBindingInfos); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkCmdBindDescriptorBuffersEXT(void *args) +{ + struct + { + PTR32 commandBuffer; + uint32_t bufferCount; + PTR32 pBindingInfos; + } *params = args; + const VkDescriptorBufferBindingInfoEXT *pBindingInfos_host; + struct conversion_context ctx; + + TRACE("%#x, %u, %#x\n", params->commandBuffer, params->bufferCount, params->pBindingInfos); + + init_conversion_context(&ctx); + pBindingInfos_host = convert_VkDescriptorBufferBindingInfoEXT_array_win32_to_host(&ctx, (const VkDescriptorBufferBindingInfoEXT32 *)UlongToPtr(params->pBindingInfos), params->bufferCount); + wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBindDescriptorBuffersEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->bufferCount, pBindingInfos_host); + free_conversion_context(&ctx); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkCmdBindDescriptorSets(void *args) { @@ -29106,6 +29683,37 @@ static NTSTATUS thunk32_vkCmdSetDepthWriteEnableEXT(void *args) return STATUS_SUCCESS; }

+#ifdef _WIN64 +static NTSTATUS thunk64_vkCmdSetDescriptorBufferOffsetsEXT(void *args) +{ + struct vkCmdSetDescriptorBufferOffsetsEXT_params *params = args; + + TRACE("%p, %#x, 0x%s, %u, %u, %p, %p\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->layout), params->firstSet, params->setCount, params->pBufferIndices, params->pOffsets); + + wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDescriptorBufferOffsetsEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineBindPoint, params->layout, params->firstSet, params->setCount, params->pBufferIndices, params->pOffsets); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkCmdSetDescriptorBufferOffsetsEXT(void *args) +{ + struct + { + PTR32 commandBuffer; + VkPipelineBindPoint pipelineBindPoint; + VkPipelineLayout DECLSPEC_ALIGN(8) layout; + uint32_t firstSet; + uint32_t setCount; + PTR32 pBufferIndices; + PTR32 pOffsets; + } *params = args; + + TRACE("%#x, %#x, 0x%s, %u, %u, %#x, %#x\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->layout), params->firstSet, params->setCount, params->pBufferIndices, params->pOffsets); + + wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDescriptorBufferOffsetsEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->pipelineBindPoint, params->layout, params->firstSet, params->setCount, (const uint32_t *)UlongToPtr(params->pBufferIndices), (const VkDeviceSize *)UlongToPtr(params->pOffsets)); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkCmdSetDeviceMask(void *args) { @@ -34639,6 +35247,36 @@ static NTSTATUS thunk32_vkGetAccelerationStructureMemoryRequirementsNV(void *arg return STATUS_SUCCESS; }

+#ifdef _WIN64 +static NTSTATUS thunk64_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(void *args) +{ + struct vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_params *params = args; + + TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pData); + + params->result = wine_device_from_handle(params->device)->funcs.p_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(wine_device_from_handle(params->device)->device, params->pInfo, params->pData); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(void *args) +{ + struct + { + PTR32 device; + PTR32 pInfo; + PTR32 pData; + VkResult result; + } *params = args; + VkAccelerationStructureCaptureDescriptorDataInfoEXT pInfo_host; + + TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pData); + + convert_VkAccelerationStructureCaptureDescriptorDataInfoEXT_win32_to_host((const VkAccelerationStructureCaptureDescriptorDataInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host); + params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, (void *)UlongToPtr(params->pData)); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkGetBufferDeviceAddress(void *args) { @@ -34883,6 +35521,36 @@ static NTSTATUS thunk32_vkGetBufferOpaqueCaptureAddressKHR(void *args) return STATUS_SUCCESS; }

+#ifdef _WIN64 +static NTSTATUS thunk64_vkGetBufferOpaqueCaptureDescriptorDataEXT(void *args) +{ + struct vkGetBufferOpaqueCaptureDescriptorDataEXT_params *params = args; + + TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pData); + + params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferOpaqueCaptureDescriptorDataEXT(wine_device_from_handle(params->device)->device, params->pInfo, params->pData); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkGetBufferOpaqueCaptureDescriptorDataEXT(void *args) +{ + struct + { + PTR32 device; + PTR32 pInfo; + PTR32 pData; + VkResult result; + } *params = args; + VkBufferCaptureDescriptorDataInfoEXT pInfo_host; + + TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pData); + + convert_VkBufferCaptureDescriptorDataInfoEXT_win32_to_host((const VkBufferCaptureDescriptorDataInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host); + params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetBufferOpaqueCaptureDescriptorDataEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, (void *)UlongToPtr(params->pData)); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkGetCalibratedTimestampsEXT(void *args) { @@ -34972,6 +35640,39 @@ static NTSTATUS thunk32_vkGetDeferredOperationResultKHR(void *args) return STATUS_SUCCESS; }

+#ifdef _WIN64 +static NTSTATUS thunk64_vkGetDescriptorEXT(void *args) +{ + struct vkGetDescriptorEXT_params *params = args; + + TRACE("%p, %p, 0x%s, %p\n", params->device, params->pDescriptorInfo, wine_dbgstr_longlong(params->dataSize), params->pDescriptor); + + wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorEXT(wine_device_from_handle(params->device)->device, params->pDescriptorInfo, params->dataSize, params->pDescriptor); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkGetDescriptorEXT(void *args) +{ + struct + { + PTR32 device; + PTR32 pDescriptorInfo; + PTR32 dataSize; + PTR32 pDescriptor; + } *params = args; + VkDescriptorGetInfoEXT pDescriptorInfo_host; + struct conversion_context ctx; + + TRACE("%#x, %#x, 0x%s, %#x\n", params->device, params->pDescriptorInfo, wine_dbgstr_longlong(params->dataSize), params->pDescriptor); + + init_conversion_context(&ctx); + convert_VkDescriptorGetInfoEXT_win32_to_host(&ctx, (const VkDescriptorGetInfoEXT32 *)UlongToPtr(params->pDescriptorInfo), &pDescriptorInfo_host); + wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDescriptorEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pDescriptorInfo_host, params->dataSize, (void *)UlongToPtr(params->pDescriptor)); + free_conversion_context(&ctx); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkGetDescriptorSetHostMappingVALVE(void *args) { @@ -34999,6 +35700,34 @@ static NTSTATUS thunk32_vkGetDescriptorSetHostMappingVALVE(void *args) return STATUS_SUCCESS; }

+#ifdef _WIN64 +static NTSTATUS thunk64_vkGetDescriptorSetLayoutBindingOffsetEXT(void *args) +{ + struct vkGetDescriptorSetLayoutBindingOffsetEXT_params *params = args; + + TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->layout), params->binding, params->pOffset); + + wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorSetLayoutBindingOffsetEXT(wine_device_from_handle(params->device)->device, params->layout, params->binding, params->pOffset); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkGetDescriptorSetLayoutBindingOffsetEXT(void *args) +{ + struct + { + PTR32 device; + VkDescriptorSetLayout DECLSPEC_ALIGN(8) layout; + uint32_t binding; + PTR32 pOffset; + } *params = args; + + TRACE("%#x, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->layout), params->binding, params->pOffset); + + wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDescriptorSetLayoutBindingOffsetEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->layout, params->binding, (VkDeviceSize *)UlongToPtr(params->pOffset)); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkGetDescriptorSetLayoutHostMappingInfoVALVE(void *args) { @@ -35031,6 +35760,33 @@ static NTSTATUS thunk32_vkGetDescriptorSetLayoutHostMappingInfoVALVE(void *args) return STATUS_SUCCESS; }

+#ifdef _WIN64 +static NTSTATUS thunk64_vkGetDescriptorSetLayoutSizeEXT(void *args) +{ + struct vkGetDescriptorSetLayoutSizeEXT_params *params = args; + + TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->layout), params->pLayoutSizeInBytes); + + wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorSetLayoutSizeEXT(wine_device_from_handle(params->device)->device, params->layout, params->pLayoutSizeInBytes); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkGetDescriptorSetLayoutSizeEXT(void *args) +{ + struct + { + PTR32 device; + VkDescriptorSetLayout DECLSPEC_ALIGN(8) layout; + PTR32 pLayoutSizeInBytes; + } *params = args; + + TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->layout), params->pLayoutSizeInBytes); + + wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDescriptorSetLayoutSizeEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->layout, (VkDeviceSize *)UlongToPtr(params->pLayoutSizeInBytes)); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkGetDescriptorSetLayoutSupport(void *args) { @@ -35963,6 +36719,36 @@ static NTSTATUS thunk32_vkGetImageMemoryRequirements2KHR(void *args) return STATUS_SUCCESS; }

+#ifdef _WIN64 +static NTSTATUS thunk64_vkGetImageOpaqueCaptureDescriptorDataEXT(void *args) +{ + struct vkGetImageOpaqueCaptureDescriptorDataEXT_params *params = args; + + TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pData); + + params->result = wine_device_from_handle(params->device)->funcs.p_vkGetImageOpaqueCaptureDescriptorDataEXT(wine_device_from_handle(params->device)->device, params->pInfo, params->pData); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkGetImageOpaqueCaptureDescriptorDataEXT(void *args) +{ + struct + { + PTR32 device; + PTR32 pInfo; + PTR32 pData; + VkResult result; + } *params = args; + VkImageCaptureDescriptorDataInfoEXT pInfo_host; + + TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pData); + + convert_VkImageCaptureDescriptorDataInfoEXT_win32_to_host((const VkImageCaptureDescriptorDataInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host); + params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetImageOpaqueCaptureDescriptorDataEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, (void *)UlongToPtr(params->pData)); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkGetImageSparseMemoryRequirements(void *args) { @@ -36195,6 +36981,36 @@ static NTSTATUS thunk32_vkGetImageViewHandleNVX(void *args) return STATUS_SUCCESS; }

+#ifdef _WIN64 +static NTSTATUS thunk64_vkGetImageViewOpaqueCaptureDescriptorDataEXT(void *args) +{ + struct vkGetImageViewOpaqueCaptureDescriptorDataEXT_params *params = args; + + TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pData); + + params->result = wine_device_from_handle(params->device)->funcs.p_vkGetImageViewOpaqueCaptureDescriptorDataEXT(wine_device_from_handle(params->device)->device, params->pInfo, params->pData); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkGetImageViewOpaqueCaptureDescriptorDataEXT(void *args) +{ + struct + { + PTR32 device; + PTR32 pInfo; + PTR32 pData; + VkResult result; + } *params = args; + VkImageViewCaptureDescriptorDataInfoEXT pInfo_host; + + TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pData); + + convert_VkImageViewCaptureDescriptorDataInfoEXT_win32_to_host((const VkImageViewCaptureDescriptorDataInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host); + params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetImageViewOpaqueCaptureDescriptorDataEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, (void *)UlongToPtr(params->pData)); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkGetMemoryHostPointerPropertiesEXT(void *args) { @@ -38180,6 +38996,36 @@ static NTSTATUS thunk32_vkGetRenderAreaGranularity(void *args) return STATUS_SUCCESS; }

+#ifdef _WIN64 +static NTSTATUS thunk64_vkGetSamplerOpaqueCaptureDescriptorDataEXT(void *args) +{ + struct vkGetSamplerOpaqueCaptureDescriptorDataEXT_params *params = args; + + TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pData); + + params->result = wine_device_from_handle(params->device)->funcs.p_vkGetSamplerOpaqueCaptureDescriptorDataEXT(wine_device_from_handle(params->device)->device, params->pInfo, params->pData); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkGetSamplerOpaqueCaptureDescriptorDataEXT(void *args) +{ + struct + { + PTR32 device; + PTR32 pInfo; + PTR32 pData; + VkResult result; + } *params = args; + VkSamplerCaptureDescriptorDataInfoEXT pInfo_host; + + TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pData); + + convert_VkSamplerCaptureDescriptorDataInfoEXT_win32_to_host((const VkSamplerCaptureDescriptorDataInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host); + params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetSamplerOpaqueCaptureDescriptorDataEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, (void *)UlongToPtr(params->pData)); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkGetSemaphoreCounterValue(void *args) { @@ -39803,6 +40649,7 @@ static const char * const vk_device_extensions[] = "VK_EXT_depth_clip_control", "VK_EXT_depth_clip_enable", "VK_EXT_depth_range_unrestricted", + "VK_EXT_descriptor_buffer", "VK_EXT_descriptor_indexing", "VK_EXT_device_address_binding_report", "VK_EXT_device_fault", @@ -40089,6 +40936,8 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkCmdBeginRendering, thunk64_vkCmdBeginRenderingKHR, thunk64_vkCmdBeginTransformFeedbackEXT, + thunk64_vkCmdBindDescriptorBufferEmbeddedSamplersEXT, + thunk64_vkCmdBindDescriptorBuffersEXT, thunk64_vkCmdBindDescriptorSets, thunk64_vkCmdBindIndexBuffer, thunk64_vkCmdBindInvocationMaskHUAWEI, @@ -40226,6 +41075,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkCmdSetDepthTestEnableEXT, thunk64_vkCmdSetDepthWriteEnable, thunk64_vkCmdSetDepthWriteEnableEXT, + thunk64_vkCmdSetDescriptorBufferOffsetsEXT, thunk64_vkCmdSetDeviceMask, thunk64_vkCmdSetDeviceMaskKHR, thunk64_vkCmdSetDiscardRectangleEXT, @@ -40412,6 +41262,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkGetAccelerationStructureDeviceAddressKHR, thunk64_vkGetAccelerationStructureHandleNV, thunk64_vkGetAccelerationStructureMemoryRequirementsNV, + thunk64_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT, thunk64_vkGetBufferDeviceAddress, thunk64_vkGetBufferDeviceAddressEXT, thunk64_vkGetBufferDeviceAddressKHR, @@ -40420,11 +41271,15 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkGetBufferMemoryRequirements2KHR, thunk64_vkGetBufferOpaqueCaptureAddress, thunk64_vkGetBufferOpaqueCaptureAddressKHR, + thunk64_vkGetBufferOpaqueCaptureDescriptorDataEXT, thunk64_vkGetCalibratedTimestampsEXT, thunk64_vkGetDeferredOperationMaxConcurrencyKHR, thunk64_vkGetDeferredOperationResultKHR, + thunk64_vkGetDescriptorEXT, thunk64_vkGetDescriptorSetHostMappingVALVE, + thunk64_vkGetDescriptorSetLayoutBindingOffsetEXT, thunk64_vkGetDescriptorSetLayoutHostMappingInfoVALVE, + thunk64_vkGetDescriptorSetLayoutSizeEXT, thunk64_vkGetDescriptorSetLayoutSupport, thunk64_vkGetDescriptorSetLayoutSupportKHR, thunk64_vkGetDeviceAccelerationStructureCompatibilityKHR, @@ -40454,6 +41309,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkGetImageMemoryRequirements, thunk64_vkGetImageMemoryRequirements2, thunk64_vkGetImageMemoryRequirements2KHR, + thunk64_vkGetImageOpaqueCaptureDescriptorDataEXT, thunk64_vkGetImageSparseMemoryRequirements, thunk64_vkGetImageSparseMemoryRequirements2, thunk64_vkGetImageSparseMemoryRequirements2KHR, @@ -40461,6 +41317,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkGetImageSubresourceLayout2EXT, thunk64_vkGetImageViewAddressNVX, thunk64_vkGetImageViewHandleNVX, + thunk64_vkGetImageViewOpaqueCaptureDescriptorDataEXT, thunk64_vkGetMemoryHostPointerPropertiesEXT, thunk64_vkGetMicromapBuildSizesEXT, thunk64_vkGetPerformanceParameterINTEL, @@ -40523,6 +41380,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkGetRayTracingShaderGroupHandlesNV, thunk64_vkGetRayTracingShaderGroupStackSizeKHR, thunk64_vkGetRenderAreaGranularity, + thunk64_vkGetSamplerOpaqueCaptureDescriptorDataEXT, thunk64_vkGetSemaphoreCounterValue, thunk64_vkGetSemaphoreCounterValueKHR, thunk64_vkGetShaderInfoAMD, @@ -40618,6 +41476,8 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkCmdBeginRendering, thunk32_vkCmdBeginRenderingKHR, thunk32_vkCmdBeginTransformFeedbackEXT, + thunk32_vkCmdBindDescriptorBufferEmbeddedSamplersEXT, + thunk32_vkCmdBindDescriptorBuffersEXT, thunk32_vkCmdBindDescriptorSets, thunk32_vkCmdBindIndexBuffer, thunk32_vkCmdBindInvocationMaskHUAWEI, @@ -40755,6 +41615,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkCmdSetDepthTestEnableEXT, thunk32_vkCmdSetDepthWriteEnable, thunk32_vkCmdSetDepthWriteEnableEXT, + thunk32_vkCmdSetDescriptorBufferOffsetsEXT, thunk32_vkCmdSetDeviceMask, thunk32_vkCmdSetDeviceMaskKHR, thunk32_vkCmdSetDiscardRectangleEXT, @@ -40941,6 +41802,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkGetAccelerationStructureDeviceAddressKHR, thunk32_vkGetAccelerationStructureHandleNV, thunk32_vkGetAccelerationStructureMemoryRequirementsNV, + thunk32_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT, thunk32_vkGetBufferDeviceAddress, thunk32_vkGetBufferDeviceAddressEXT, thunk32_vkGetBufferDeviceAddressKHR, @@ -40949,11 +41811,15 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkGetBufferMemoryRequirements2KHR, thunk32_vkGetBufferOpaqueCaptureAddress, thunk32_vkGetBufferOpaqueCaptureAddressKHR, + thunk32_vkGetBufferOpaqueCaptureDescriptorDataEXT, thunk32_vkGetCalibratedTimestampsEXT, thunk32_vkGetDeferredOperationMaxConcurrencyKHR, thunk32_vkGetDeferredOperationResultKHR, + thunk32_vkGetDescriptorEXT, thunk32_vkGetDescriptorSetHostMappingVALVE, + thunk32_vkGetDescriptorSetLayoutBindingOffsetEXT, thunk32_vkGetDescriptorSetLayoutHostMappingInfoVALVE, + thunk32_vkGetDescriptorSetLayoutSizeEXT, thunk32_vkGetDescriptorSetLayoutSupport, thunk32_vkGetDescriptorSetLayoutSupportKHR, thunk32_vkGetDeviceAccelerationStructureCompatibilityKHR, @@ -40983,6 +41849,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkGetImageMemoryRequirements, thunk32_vkGetImageMemoryRequirements2, thunk32_vkGetImageMemoryRequirements2KHR, + thunk32_vkGetImageOpaqueCaptureDescriptorDataEXT, thunk32_vkGetImageSparseMemoryRequirements, thunk32_vkGetImageSparseMemoryRequirements2, thunk32_vkGetImageSparseMemoryRequirements2KHR, @@ -40990,6 +41857,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkGetImageSubresourceLayout2EXT, thunk32_vkGetImageViewAddressNVX, thunk32_vkGetImageViewHandleNVX, + thunk32_vkGetImageViewOpaqueCaptureDescriptorDataEXT, thunk32_vkGetMemoryHostPointerPropertiesEXT, thunk32_vkGetMicromapBuildSizesEXT, thunk32_vkGetPerformanceParameterINTEL, @@ -41052,6 +41920,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkGetRayTracingShaderGroupHandlesNV, thunk32_vkGetRayTracingShaderGroupStackSizeKHR, thunk32_vkGetRenderAreaGranularity, + thunk32_vkGetSamplerOpaqueCaptureDescriptorDataEXT, thunk32_vkGetSemaphoreCounterValue, thunk32_vkGetSemaphoreCounterValueKHR, thunk32_vkGetShaderInfoAMD, diff --git a/dlls/winevulkan/vulkan_thunks.h b/dlls/winevulkan/vulkan_thunks.h index 62e92c8a59f..89f741ad062 100644 --- a/dlls/winevulkan/vulkan_thunks.h +++ b/dlls/winevulkan/vulkan_thunks.h @@ -83,6 +83,8 @@ struct vulkan_device_funcs void (*p_vkCmdBeginRendering)(VkCommandBuffer, const VkRenderingInfo *); void (*p_vkCmdBeginRenderingKHR)(VkCommandBuffer, const VkRenderingInfo *); void (*p_vkCmdBeginTransformFeedbackEXT)(VkCommandBuffer, uint32_t, uint32_t, const VkBuffer *, const VkDeviceSize *); + void (*p_vkCmdBindDescriptorBufferEmbeddedSamplersEXT)(VkCommandBuffer, VkPipelineBindPoint, VkPipelineLayout, uint32_t); + void (*p_vkCmdBindDescriptorBuffersEXT)(VkCommandBuffer, uint32_t, const VkDescriptorBufferBindingInfoEXT *); void (*p_vkCmdBindDescriptorSets)(VkCommandBuffer, VkPipelineBindPoint, VkPipelineLayout, uint32_t, uint32_t, const VkDescriptorSet *, uint32_t, const uint32_t *); void (*p_vkCmdBindIndexBuffer)(VkCommandBuffer, VkBuffer, VkDeviceSize, VkIndexType); void (*p_vkCmdBindInvocationMaskHUAWEI)(VkCommandBuffer, VkImageView, VkImageLayout); @@ -220,6 +222,7 @@ struct vulkan_device_funcs void (*p_vkCmdSetDepthTestEnableEXT)(VkCommandBuffer, VkBool32); void (*p_vkCmdSetDepthWriteEnable)(VkCommandBuffer, VkBool32); void (*p_vkCmdSetDepthWriteEnableEXT)(VkCommandBuffer, VkBool32); + void (*p_vkCmdSetDescriptorBufferOffsetsEXT)(VkCommandBuffer, VkPipelineBindPoint, VkPipelineLayout, uint32_t, uint32_t, const uint32_t *, const VkDeviceSize *); void (*p_vkCmdSetDeviceMask)(VkCommandBuffer, uint32_t); void (*p_vkCmdSetDeviceMaskKHR)(VkCommandBuffer, uint32_t); void (*p_vkCmdSetDiscardRectangleEXT)(VkCommandBuffer, uint32_t, uint32_t, const VkRect2D *); @@ -388,6 +391,7 @@ struct vulkan_device_funcs VkDeviceAddress (*p_vkGetAccelerationStructureDeviceAddressKHR)(VkDevice, const VkAccelerationStructureDeviceAddressInfoKHR *); VkResult (*p_vkGetAccelerationStructureHandleNV)(VkDevice, VkAccelerationStructureNV, size_t, void *); void (*p_vkGetAccelerationStructureMemoryRequirementsNV)(VkDevice, const VkAccelerationStructureMemoryRequirementsInfoNV *, VkMemoryRequirements2KHR *); + VkResult (*p_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT)(VkDevice, const VkAccelerationStructureCaptureDescriptorDataInfoEXT *, void *); VkDeviceAddress (*p_vkGetBufferDeviceAddress)(VkDevice, const VkBufferDeviceAddressInfo *); VkDeviceAddress (*p_vkGetBufferDeviceAddressEXT)(VkDevice, const VkBufferDeviceAddressInfo *); VkDeviceAddress (*p_vkGetBufferDeviceAddressKHR)(VkDevice, const VkBufferDeviceAddressInfo *); @@ -396,11 +400,15 @@ struct vulkan_device_funcs void (*p_vkGetBufferMemoryRequirements2KHR)(VkDevice, const VkBufferMemoryRequirementsInfo2 *, VkMemoryRequirements2 *); uint64_t (*p_vkGetBufferOpaqueCaptureAddress)(VkDevice, const VkBufferDeviceAddressInfo *); uint64_t (*p_vkGetBufferOpaqueCaptureAddressKHR)(VkDevice, const VkBufferDeviceAddressInfo *); + VkResult (*p_vkGetBufferOpaqueCaptureDescriptorDataEXT)(VkDevice, const VkBufferCaptureDescriptorDataInfoEXT *, void *); VkResult (*p_vkGetCalibratedTimestampsEXT)(VkDevice, uint32_t, const VkCalibratedTimestampInfoEXT *, uint64_t *, uint64_t *); uint32_t (*p_vkGetDeferredOperationMaxConcurrencyKHR)(VkDevice, VkDeferredOperationKHR); VkResult (*p_vkGetDeferredOperationResultKHR)(VkDevice, VkDeferredOperationKHR); + void (*p_vkGetDescriptorEXT)(VkDevice, const VkDescriptorGetInfoEXT *, size_t, void *); void (*p_vkGetDescriptorSetHostMappingVALVE)(VkDevice, VkDescriptorSet, void **); + void (*p_vkGetDescriptorSetLayoutBindingOffsetEXT)(VkDevice, VkDescriptorSetLayout, uint32_t, VkDeviceSize *); void (*p_vkGetDescriptorSetLayoutHostMappingInfoVALVE)(VkDevice, const VkDescriptorSetBindingReferenceVALVE *, VkDescriptorSetLayoutHostMappingInfoVALVE *); + void (*p_vkGetDescriptorSetLayoutSizeEXT)(VkDevice, VkDescriptorSetLayout, VkDeviceSize *); void (*p_vkGetDescriptorSetLayoutSupport)(VkDevice, const VkDescriptorSetLayoutCreateInfo *, VkDescriptorSetLayoutSupport *); void (*p_vkGetDescriptorSetLayoutSupportKHR)(VkDevice, const VkDescriptorSetLayoutCreateInfo *, VkDescriptorSetLayoutSupport *); void (*p_vkGetDeviceAccelerationStructureCompatibilityKHR)(VkDevice, const VkAccelerationStructureVersionInfoKHR *, VkAccelerationStructureCompatibilityKHR *); @@ -430,6 +438,7 @@ struct vulkan_device_funcs void (*p_vkGetImageMemoryRequirements)(VkDevice, VkImage, VkMemoryRequirements *); void (*p_vkGetImageMemoryRequirements2)(VkDevice, const VkImageMemoryRequirementsInfo2 *, VkMemoryRequirements2 *); void (*p_vkGetImageMemoryRequirements2KHR)(VkDevice, const VkImageMemoryRequirementsInfo2 *, VkMemoryRequirements2 *); + VkResult (*p_vkGetImageOpaqueCaptureDescriptorDataEXT)(VkDevice, const VkImageCaptureDescriptorDataInfoEXT *, void *); void (*p_vkGetImageSparseMemoryRequirements)(VkDevice, VkImage, uint32_t *, VkSparseImageMemoryRequirements *); void (*p_vkGetImageSparseMemoryRequirements2)(VkDevice, const VkImageSparseMemoryRequirementsInfo2 *, uint32_t *, VkSparseImageMemoryRequirements2 *); void (*p_vkGetImageSparseMemoryRequirements2KHR)(VkDevice, const VkImageSparseMemoryRequirementsInfo2 *, uint32_t *, VkSparseImageMemoryRequirements2 *); @@ -437,6 +446,7 @@ struct vulkan_device_funcs void (*p_vkGetImageSubresourceLayout2EXT)(VkDevice, VkImage, const VkImageSubresource2EXT *, VkSubresourceLayout2EXT *); VkResult (*p_vkGetImageViewAddressNVX)(VkDevice, VkImageView, VkImageViewAddressPropertiesNVX *); uint32_t (*p_vkGetImageViewHandleNVX)(VkDevice, const VkImageViewHandleInfoNVX *); + VkResult (*p_vkGetImageViewOpaqueCaptureDescriptorDataEXT)(VkDevice, const VkImageViewCaptureDescriptorDataInfoEXT *, void *); VkResult (*p_vkGetMemoryHostPointerPropertiesEXT)(VkDevice, VkExternalMemoryHandleTypeFlagBits, const void *, VkMemoryHostPointerPropertiesEXT *); void (*p_vkGetMicromapBuildSizesEXT)(VkDevice, VkAccelerationStructureBuildTypeKHR, const VkMicromapBuildInfoEXT *, VkMicromapBuildSizesInfoEXT *); VkResult (*p_vkGetPerformanceParameterINTEL)(VkDevice, VkPerformanceParameterTypeINTEL, VkPerformanceValueINTEL *); @@ -455,6 +465,7 @@ struct vulkan_device_funcs VkResult (*p_vkGetRayTracingShaderGroupHandlesNV)(VkDevice, VkPipeline, uint32_t, uint32_t, size_t, void *); VkDeviceSize (*p_vkGetRayTracingShaderGroupStackSizeKHR)(VkDevice, VkPipeline, uint32_t, VkShaderGroupShaderKHR); void (*p_vkGetRenderAreaGranularity)(VkDevice, VkRenderPass, VkExtent2D *); + VkResult (*p_vkGetSamplerOpaqueCaptureDescriptorDataEXT)(VkDevice, const VkSamplerCaptureDescriptorDataInfoEXT *, void *); VkResult (*p_vkGetSemaphoreCounterValue)(VkDevice, VkSemaphore, uint64_t *); VkResult (*p_vkGetSemaphoreCounterValueKHR)(VkDevice, VkSemaphore, uint64_t *); VkResult (*p_vkGetShaderInfoAMD)(VkDevice, VkPipeline, VkShaderStageFlagBits, VkShaderInfoTypeAMD, size_t *, void *); @@ -596,6 +607,8 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkCmdBeginRendering) \ USE_VK_FUNC(vkCmdBeginRenderingKHR) \ USE_VK_FUNC(vkCmdBeginTransformFeedbackEXT) \ + USE_VK_FUNC(vkCmdBindDescriptorBufferEmbeddedSamplersEXT) \ + USE_VK_FUNC(vkCmdBindDescriptorBuffersEXT) \ USE_VK_FUNC(vkCmdBindDescriptorSets) \ USE_VK_FUNC(vkCmdBindIndexBuffer) \ USE_VK_FUNC(vkCmdBindInvocationMaskHUAWEI) \ @@ -733,6 +746,7 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkCmdSetDepthTestEnableEXT) \ USE_VK_FUNC(vkCmdSetDepthWriteEnable) \ USE_VK_FUNC(vkCmdSetDepthWriteEnableEXT) \ + USE_VK_FUNC(vkCmdSetDescriptorBufferOffsetsEXT) \ USE_VK_FUNC(vkCmdSetDeviceMask) \ USE_VK_FUNC(vkCmdSetDeviceMaskKHR) \ USE_VK_FUNC(vkCmdSetDiscardRectangleEXT) \ @@ -901,6 +915,7 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkGetAccelerationStructureDeviceAddressKHR) \ USE_VK_FUNC(vkGetAccelerationStructureHandleNV) \ USE_VK_FUNC(vkGetAccelerationStructureMemoryRequirementsNV) \ + USE_VK_FUNC(vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT) \ USE_VK_FUNC(vkGetBufferDeviceAddress) \ USE_VK_FUNC(vkGetBufferDeviceAddressEXT) \ USE_VK_FUNC(vkGetBufferDeviceAddressKHR) \ @@ -909,11 +924,15 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkGetBufferMemoryRequirements2KHR) \ USE_VK_FUNC(vkGetBufferOpaqueCaptureAddress) \ USE_VK_FUNC(vkGetBufferOpaqueCaptureAddressKHR) \ + USE_VK_FUNC(vkGetBufferOpaqueCaptureDescriptorDataEXT) \ USE_VK_FUNC(vkGetCalibratedTimestampsEXT) \ USE_VK_FUNC(vkGetDeferredOperationMaxConcurrencyKHR) \ USE_VK_FUNC(vkGetDeferredOperationResultKHR) \ + USE_VK_FUNC(vkGetDescriptorEXT) \ USE_VK_FUNC(vkGetDescriptorSetHostMappingVALVE) \ + USE_VK_FUNC(vkGetDescriptorSetLayoutBindingOffsetEXT) \ USE_VK_FUNC(vkGetDescriptorSetLayoutHostMappingInfoVALVE) \ + USE_VK_FUNC(vkGetDescriptorSetLayoutSizeEXT) \ USE_VK_FUNC(vkGetDescriptorSetLayoutSupport) \ USE_VK_FUNC(vkGetDescriptorSetLayoutSupportKHR) \ USE_VK_FUNC(vkGetDeviceAccelerationStructureCompatibilityKHR) \ @@ -943,6 +962,7 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkGetImageMemoryRequirements) \ USE_VK_FUNC(vkGetImageMemoryRequirements2) \ USE_VK_FUNC(vkGetImageMemoryRequirements2KHR) \ + USE_VK_FUNC(vkGetImageOpaqueCaptureDescriptorDataEXT) \ USE_VK_FUNC(vkGetImageSparseMemoryRequirements) \ USE_VK_FUNC(vkGetImageSparseMemoryRequirements2) \ USE_VK_FUNC(vkGetImageSparseMemoryRequirements2KHR) \ @@ -950,6 +970,7 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkGetImageSubresourceLayout2EXT) \ USE_VK_FUNC(vkGetImageViewAddressNVX) \ USE_VK_FUNC(vkGetImageViewHandleNVX) \ + USE_VK_FUNC(vkGetImageViewOpaqueCaptureDescriptorDataEXT) \ USE_VK_FUNC(vkGetMemoryHostPointerPropertiesEXT) \ USE_VK_FUNC(vkGetMicromapBuildSizesEXT) \ USE_VK_FUNC(vkGetPerformanceParameterINTEL) \ @@ -968,6 +989,7 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkGetRayTracingShaderGroupHandlesNV) \ USE_VK_FUNC(vkGetRayTracingShaderGroupStackSizeKHR) \ USE_VK_FUNC(vkGetRenderAreaGranularity) \ + USE_VK_FUNC(vkGetSamplerOpaqueCaptureDescriptorDataEXT) \ USE_VK_FUNC(vkGetSemaphoreCounterValue) \ USE_VK_FUNC(vkGetSemaphoreCounterValueKHR) \ USE_VK_FUNC(vkGetShaderInfoAMD) \ diff --git a/dlls/winevulkan/winevulkan.json b/dlls/winevulkan/winevulkan.json index e5b7cd50955..0f898546db0 100644 --- a/dlls/winevulkan/winevulkan.json +++ b/dlls/winevulkan/winevulkan.json @@ -2,6 +2,6 @@ "file_format_version": "1.0.0", "ICD": { "library_path": ".\winevulkan.dll", - "api_version": "1.3.233" + "api_version": "1.3.235" } } diff --git a/include/wine/vulkan.h b/include/wine/vulkan.h index 945e36f715b..fd24fe0fad3 100644 --- a/include/wine/vulkan.h +++ b/include/wine/vulkan.h @@ -438,6 +438,8 @@ #define VK_QCOM_RENDER_PASS_STORE_OPS_EXTENSION_NAME "VK_QCOM_render_pass_store_ops" #define VK_KHR_SYNCHRONIZATION_2_SPEC_VERSION 1 #define VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME "VK_KHR_synchronization2" +#define VK_EXT_DESCRIPTOR_BUFFER_SPEC_VERSION 1 +#define VK_EXT_DESCRIPTOR_BUFFER_EXTENSION_NAME "VK_EXT_descriptor_buffer" #define VK_EXT_GRAPHICS_PIPELINE_LIBRARY_SPEC_VERSION 1 #define VK_EXT_GRAPHICS_PIPELINE_LIBRARY_EXTENSION_NAME "VK_EXT_graphics_pipeline_library" #define VK_AMD_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_SPEC_VERSION 1 @@ -588,7 +590,7 @@ #define VK_API_VERSION_1_1 VK_MAKE_API_VERSION(0, 1, 1, 0) #define VK_API_VERSION_1_2 VK_MAKE_API_VERSION(0, 1, 2, 0) #define VK_API_VERSION_1_3 VK_MAKE_API_VERSION(0, 1, 3, 0) -#define VK_HEADER_VERSION 233 +#define VK_HEADER_VERSION 235 #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 3, VK_HEADER_VERSION) #define VK_DEFINE_HANDLE(object) typedef struct object##_T* object; #define VK_USE_64_BIT_PTR_DEFINES 0 @@ -901,6 +903,7 @@ typedef enum VkAccelerationStructureCreateFlagBitsKHR { VK_ACCELERATION_STRUCTURE_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = 0x00000001, VK_ACCELERATION_STRUCTURE_CREATE_MOTION_BIT_NV = 0x00000004, + VK_ACCELERATION_STRUCTURE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00000008, VK_ACCELERATION_STRUCTURE_CREATE_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff, } VkAccelerationStructureCreateFlagBitsKHR;

@@ -1029,6 +1032,7 @@ static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT = 0x40000000 static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR = 0x400000000ull; static const VkAccessFlagBits2 VK_ACCESS_2_INVOCATION_MASK_READ_BIT_HUAWEI = 0x8000000000ull; static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_BINDING_TABLE_READ_BIT_KHR = 0x10000000000ull; +static const VkAccessFlagBits2 VK_ACCESS_2_DESCRIPTOR_BUFFER_READ_BIT_EXT = 0x20000000000ull; static const VkAccessFlagBits2 VK_ACCESS_2_OPTICAL_FLOW_READ_BIT_NV = 0x40000000000ull; static const VkAccessFlagBits2 VK_ACCESS_2_OPTICAL_FLOW_WRITE_BIT_NV = 0x80000000000ull; static const VkAccessFlagBits2 VK_ACCESS_2_MICROMAP_READ_BIT_EXT = 0x100000000000ull; @@ -1174,6 +1178,7 @@ typedef enum VkBufferCreateFlagBits VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004, VK_BUFFER_CREATE_PROTECTED_BIT = 0x00000008, VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 0x00000010, + VK_BUFFER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00000020, VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT, VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT, VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7fffffff, @@ -1197,8 +1202,11 @@ typedef enum VkBufferUsageFlagBits VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT = 0x00020000, VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR = 0x00080000, VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR = 0x00100000, + VK_BUFFER_USAGE_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT = 0x00200000, + VK_BUFFER_USAGE_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT = 0x00400000, VK_BUFFER_USAGE_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT = 0x00800000, VK_BUFFER_USAGE_MICROMAP_STORAGE_BIT_EXT = 0x01000000, + VK_BUFFER_USAGE_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT = 0x04000000, VK_BUFFER_USAGE_RAY_TRACING_BIT_NV = VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR, VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT, VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT, @@ -1556,6 +1564,8 @@ typedef enum VkDescriptorSetLayoutCreateFlagBits VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR = 0x00000001, VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT = 0x00000002, VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT = 0x00000004, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT = 0x00000010, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_EMBEDDED_IMMUTABLE_SAMPLERS_BIT_EXT = 0x00000020, VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT, VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE = VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT, VK_DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7fffffff, @@ -2488,6 +2498,7 @@ typedef enum VkImageCreateFlagBits VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV = 0x00002000, VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT = 0x00004000, VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM = 0x00008000, + VK_IMAGE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00010000, VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT = 0x00020000, VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT = 0x00040000, VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT, @@ -2573,6 +2584,7 @@ typedef enum VkImageViewCreateFlagBits { VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT = 0x00000001, VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT = 0x00000002, + VK_IMAGE_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00000004, VK_IMAGE_VIEW_CREATE_FLAG_BITS_MAX_ENUM = 0x7fffffff, } VkImageViewCreateFlagBits;

@@ -3018,6 +3030,7 @@ typedef enum VkPipelineCreateFlagBits VK_PIPELINE_CREATE_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x02000000, VK_PIPELINE_CREATE_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x04000000, VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT_EXT = 0x08000000, + VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT = 0x20000000, VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT_EXT = 0x40000000, VK_PIPELINE_CREATE_DISPATCH_BASE = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT, VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, @@ -3478,6 +3491,7 @@ typedef enum VkSamplerCreateFlagBits VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT = 0x00000001, VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT = 0x00000002, VK_SAMPLER_CREATE_NON_SEAMLESS_CUBE_MAP_BIT_EXT = 0x00000004, + VK_SAMPLER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00000008, VK_SAMPLER_CREATE_IMAGE_PROCESSING_BIT_QCOM = 0x00000010, VK_SAMPLER_CREATE_FLAG_BITS_MAX_ENUM = 0x7fffffff, } VkSamplerCreateFlagBits; @@ -4105,6 +4119,19 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES = 1000314007, VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV = 1000314008, VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV = 1000314009, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT = 1000316000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT = 1000316001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT = 1000316002, + VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT = 1000316003, + VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT = 1000316004, + VK_STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316005, + VK_STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316006, + VK_STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316007, + VK_STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316008, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316009, + VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT = 1000316010, + VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT = 1000316011, + VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT = 1000316012, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT = 1000320000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT = 1000320001, VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT = 1000320002, @@ -4686,6 +4713,14 @@ typedef struct VkAccelerationStructureBuildSizesInfoKHR VkDeviceSize WINE_VK_ALIGN(8) buildScratchSize; } VkAccelerationStructureBuildSizesInfoKHR;

+typedef struct VkAccelerationStructureCaptureDescriptorDataInfoEXT +{ + VkStructureType sType; + const void *pNext; + VkAccelerationStructureKHR WINE_VK_ALIGN(8) accelerationStructure; + VkAccelerationStructureNV WINE_VK_ALIGN(8) accelerationStructureNV; +} VkAccelerationStructureCaptureDescriptorDataInfoEXT; + typedef struct VkAccelerationStructureCreateInfoKHR { VkStructureType sType; @@ -4927,6 +4962,13 @@ typedef struct VkBindVertexBufferIndirectCommandNV uint32_t stride; } VkBindVertexBufferIndirectCommandNV;

+typedef struct VkBufferCaptureDescriptorDataInfoEXT +{ + VkStructureType sType; + const void *pNext; + VkBuffer WINE_VK_ALIGN(8) buffer; +} VkBufferCaptureDescriptorDataInfoEXT; + typedef struct VkBufferCopy { VkDeviceSize WINE_VK_ALIGN(8) srcOffset; @@ -5400,6 +5442,30 @@ typedef struct VkDedicatedAllocationMemoryAllocateInfoNV VkBuffer WINE_VK_ALIGN(8) buffer; } VkDedicatedAllocationMemoryAllocateInfoNV;

+typedef struct VkDescriptorAddressInfoEXT +{ + VkStructureType sType; + void *pNext; + VkDeviceAddress WINE_VK_ALIGN(8) address; + VkDeviceSize WINE_VK_ALIGN(8) range; + VkFormat format; +} VkDescriptorAddressInfoEXT; + +typedef struct VkDescriptorBufferBindingInfoEXT +{ + VkStructureType sType; + void *pNext; + VkDeviceAddress WINE_VK_ALIGN(8) address; + VkBufferUsageFlags usage; +} VkDescriptorBufferBindingInfoEXT; + +typedef struct VkDescriptorBufferBindingPushDescriptorBufferHandleEXT +{ + VkStructureType sType; + void *pNext; + VkBuffer WINE_VK_ALIGN(8) buffer; +} VkDescriptorBufferBindingPushDescriptorBufferHandleEXT; + typedef struct VkDescriptorBufferInfo { VkBuffer WINE_VK_ALIGN(8) buffer; @@ -5980,6 +6046,13 @@ typedef struct VkGraphicsPipelineLibraryCreateInfoEXT VkGraphicsPipelineLibraryFlagsEXT flags; } VkGraphicsPipelineLibraryCreateInfoEXT;

+typedef struct VkImageCaptureDescriptorDataInfoEXT +{ + VkStructureType sType; + const void *pNext; + VkImage WINE_VK_ALIGN(8) image; +} VkImageCaptureDescriptorDataInfoEXT; + typedef struct VkImageCompressionControlEXT { VkStructureType sType; @@ -6127,6 +6200,13 @@ typedef struct VkImageViewAddressPropertiesNVX VkDeviceSize WINE_VK_ALIGN(8) size; } VkImageViewAddressPropertiesNVX;

+typedef struct VkImageViewCaptureDescriptorDataInfoEXT +{ + VkStructureType sType; + const void *pNext; + VkImageView WINE_VK_ALIGN(8) imageView; +} VkImageViewCaptureDescriptorDataInfoEXT; + typedef struct VkImageViewCreateInfo { VkStructureType sType; @@ -6466,6 +6546,13 @@ typedef struct VkOffset3D int32_t z; } VkOffset3D;

+typedef struct VkOpaqueCaptureDescriptorDataCreateInfoEXT +{ + VkStructureType sType; + const void *pNext; + const void *opaqueCaptureDescriptorData; +} VkOpaqueCaptureDescriptorDataCreateInfoEXT; + typedef struct VkOpticalFlowImageFormatInfoNV { VkStructureType sType; @@ -6850,6 +6937,62 @@ typedef struct VkPhysicalDeviceDepthStencilResolveProperties } VkPhysicalDeviceDepthStencilResolveProperties; typedef VkPhysicalDeviceDepthStencilResolveProperties VkPhysicalDeviceDepthStencilResolvePropertiesKHR;

+typedef struct VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT +{ + VkStructureType sType; + void *pNext; + size_t combinedImageSamplerDensityMapDescriptorSize; +} VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT; + +typedef struct VkPhysicalDeviceDescriptorBufferFeaturesEXT +{ + VkStructureType sType; + void *pNext; + VkBool32 descriptorBuffer; + VkBool32 descriptorBufferCaptureReplay; + VkBool32 descriptorBufferImageLayoutIgnored; + VkBool32 descriptorBufferPushDescriptors; +} VkPhysicalDeviceDescriptorBufferFeaturesEXT; + +typedef struct VkPhysicalDeviceDescriptorBufferPropertiesEXT +{ + VkStructureType sType; + void *pNext; + VkBool32 combinedImageSamplerDescriptorSingleArray; + VkBool32 bufferlessPushDescriptors; + VkBool32 allowSamplerImageViewPostSubmitCreation; + VkDeviceSize WINE_VK_ALIGN(8) descriptorBufferOffsetAlignment; + uint32_t maxDescriptorBufferBindings; + uint32_t maxResourceDescriptorBufferBindings; + uint32_t maxSamplerDescriptorBufferBindings; + uint32_t maxEmbeddedImmutableSamplerBindings; + uint32_t maxEmbeddedImmutableSamplers; + size_t bufferCaptureReplayDescriptorDataSize; + size_t imageCaptureReplayDescriptorDataSize; + size_t imageViewCaptureReplayDescriptorDataSize; + size_t samplerCaptureReplayDescriptorDataSize; + size_t accelerationStructureCaptureReplayDescriptorDataSize; + size_t samplerDescriptorSize; + size_t combinedImageSamplerDescriptorSize; + size_t sampledImageDescriptorSize; + size_t storageImageDescriptorSize; + size_t uniformTexelBufferDescriptorSize; + size_t robustUniformTexelBufferDescriptorSize; + size_t storageTexelBufferDescriptorSize; + size_t robustStorageTexelBufferDescriptorSize; + size_t uniformBufferDescriptorSize; + size_t robustUniformBufferDescriptorSize; + size_t storageBufferDescriptorSize; + size_t robustStorageBufferDescriptorSize; + size_t inputAttachmentDescriptorSize; + size_t accelerationStructureDescriptorSize; + VkDeviceSize WINE_VK_ALIGN(8) maxSamplerDescriptorBufferRange; + VkDeviceSize WINE_VK_ALIGN(8) maxResourceDescriptorBufferRange; + VkDeviceSize WINE_VK_ALIGN(8) samplerDescriptorBufferAddressSpaceSize; + VkDeviceSize WINE_VK_ALIGN(8) resourceDescriptorBufferAddressSpaceSize; + VkDeviceSize WINE_VK_ALIGN(8) descriptorBufferAddressSpaceSize; +} VkPhysicalDeviceDescriptorBufferPropertiesEXT; + typedef struct VkPhysicalDeviceDescriptorIndexingFeatures { VkStructureType sType; @@ -9621,6 +9764,13 @@ typedef struct VkSamplerBorderColorComponentMappingCreateInfoEXT VkBool32 srgb; } VkSamplerBorderColorComponentMappingCreateInfoEXT;

+typedef struct VkSamplerCaptureDescriptorDataInfoEXT +{ + VkStructureType sType; + const void *pNext; + VkSampler WINE_VK_ALIGN(8) sampler; +} VkSamplerCaptureDescriptorDataInfoEXT; + typedef struct VkSamplerCreateInfo { VkStructureType sType; @@ -10532,6 +10682,28 @@ typedef struct VkDebugUtilsMessengerCallbackDataEXT const VkDebugUtilsObjectNameInfoEXT *pObjects; } VkDebugUtilsMessengerCallbackDataEXT;

+typedef union VkDescriptorDataEXT +{ + const VkSampler *pSampler; + const VkDescriptorImageInfo *pCombinedImageSampler; + const VkDescriptorImageInfo *pInputAttachmentImage; + const VkDescriptorImageInfo *pSampledImage; + const VkDescriptorImageInfo *pStorageImage; + const VkDescriptorAddressInfoEXT *pUniformTexelBuffer; + const VkDescriptorAddressInfoEXT *pStorageTexelBuffer; + const VkDescriptorAddressInfoEXT *pUniformBuffer; + const VkDescriptorAddressInfoEXT *pStorageBuffer; + VkDeviceAddress WINE_VK_ALIGN(8) accelerationStructure; +} VkDescriptorDataEXT; + +typedef struct VkDescriptorGetInfoEXT +{ + VkStructureType sType; + const void *pNext; + VkDescriptorType type; + VkDescriptorDataEXT WINE_VK_ALIGN(8) data; +} VkDescriptorGetInfoEXT; + typedef struct VkDescriptorPoolCreateInfo { VkStructureType sType; @@ -11302,6 +11474,8 @@ typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass2KHR)(VkCommandBuffer, const Vk typedef void (VKAPI_PTR *PFN_vkCmdBeginRendering)(VkCommandBuffer, const VkRenderingInfo *); typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderingKHR)(VkCommandBuffer, const VkRenderingInfo *); typedef void (VKAPI_PTR *PFN_vkCmdBeginTransformFeedbackEXT)(VkCommandBuffer, uint32_t, uint32_t, const VkBuffer *, const VkDeviceSize *); +typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT)(VkCommandBuffer, VkPipelineBindPoint, VkPipelineLayout, uint32_t); +typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorBuffersEXT)(VkCommandBuffer, uint32_t, const VkDescriptorBufferBindingInfoEXT *); typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorSets)(VkCommandBuffer, VkPipelineBindPoint, VkPipelineLayout, uint32_t, uint32_t, const VkDescriptorSet *, uint32_t, const uint32_t *); typedef void (VKAPI_PTR *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer, VkBuffer, VkDeviceSize, VkIndexType); typedef void (VKAPI_PTR *PFN_vkCmdBindInvocationMaskHUAWEI)(VkCommandBuffer, VkImageView, VkImageLayout); @@ -11439,6 +11613,7 @@ typedef void (VKAPI_PTR *PFN_vkCmdSetDepthTestEnable)(VkCommandBuffer, VkBool32) typedef void (VKAPI_PTR *PFN_vkCmdSetDepthTestEnableEXT)(VkCommandBuffer, VkBool32); typedef void (VKAPI_PTR *PFN_vkCmdSetDepthWriteEnable)(VkCommandBuffer, VkBool32); typedef void (VKAPI_PTR *PFN_vkCmdSetDepthWriteEnableEXT)(VkCommandBuffer, VkBool32); +typedef void (VKAPI_PTR *PFN_vkCmdSetDescriptorBufferOffsetsEXT)(VkCommandBuffer, VkPipelineBindPoint, VkPipelineLayout, uint32_t, uint32_t, const uint32_t *, const VkDeviceSize *); typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMask)(VkCommandBuffer, uint32_t); typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMaskKHR)(VkCommandBuffer, uint32_t); typedef void (VKAPI_PTR *PFN_vkCmdSetDiscardRectangleEXT)(VkCommandBuffer, uint32_t, uint32_t, const VkRect2D *); @@ -11626,6 +11801,7 @@ typedef void (VKAPI_PTR *PFN_vkGetAccelerationStructureBuildSizesKHR)(VkDevice, typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetAccelerationStructureDeviceAddressKHR)(VkDevice, const VkAccelerationStructureDeviceAddressInfoKHR *); typedef VkResult (VKAPI_PTR *PFN_vkGetAccelerationStructureHandleNV)(VkDevice, VkAccelerationStructureNV, size_t, void *); typedef void (VKAPI_PTR *PFN_vkGetAccelerationStructureMemoryRequirementsNV)(VkDevice, const VkAccelerationStructureMemoryRequirementsInfoNV *, VkMemoryRequirements2KHR *); +typedef VkResult (VKAPI_PTR *PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT)(VkDevice, const VkAccelerationStructureCaptureDescriptorDataInfoEXT *, void *); typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddress)(VkDevice, const VkBufferDeviceAddressInfo *); typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddressEXT)(VkDevice, const VkBufferDeviceAddressInfo *); typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddressKHR)(VkDevice, const VkBufferDeviceAddressInfo *); @@ -11634,11 +11810,15 @@ typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2)(VkDevice, const VkB typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2KHR)(VkDevice, const VkBufferMemoryRequirementsInfo2 *, VkMemoryRequirements2 *); typedef uint64_t (VKAPI_PTR *PFN_vkGetBufferOpaqueCaptureAddress)(VkDevice, const VkBufferDeviceAddressInfo *); typedef uint64_t (VKAPI_PTR *PFN_vkGetBufferOpaqueCaptureAddressKHR)(VkDevice, const VkBufferDeviceAddressInfo *); +typedef VkResult (VKAPI_PTR *PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT)(VkDevice, const VkBufferCaptureDescriptorDataInfoEXT *, void *); typedef VkResult (VKAPI_PTR *PFN_vkGetCalibratedTimestampsEXT)(VkDevice, uint32_t, const VkCalibratedTimestampInfoEXT *, uint64_t *, uint64_t *); typedef uint32_t (VKAPI_PTR *PFN_vkGetDeferredOperationMaxConcurrencyKHR)(VkDevice, VkDeferredOperationKHR); typedef VkResult (VKAPI_PTR *PFN_vkGetDeferredOperationResultKHR)(VkDevice, VkDeferredOperationKHR); +typedef void (VKAPI_PTR *PFN_vkGetDescriptorEXT)(VkDevice, const VkDescriptorGetInfoEXT *, size_t, void *); typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetHostMappingVALVE)(VkDevice, VkDescriptorSet, void **); +typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutBindingOffsetEXT)(VkDevice, VkDescriptorSetLayout, uint32_t, VkDeviceSize *); typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE)(VkDevice, const VkDescriptorSetBindingReferenceVALVE *, VkDescriptorSetLayoutHostMappingInfoVALVE *); +typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutSizeEXT)(VkDevice, VkDescriptorSetLayout, VkDeviceSize *); typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutSupport)(VkDevice, const VkDescriptorSetLayoutCreateInfo *, VkDescriptorSetLayoutSupport *); typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutSupportKHR)(VkDevice, const VkDescriptorSetLayoutCreateInfo *, VkDescriptorSetLayoutSupport *); typedef void (VKAPI_PTR *PFN_vkGetDeviceAccelerationStructureCompatibilityKHR)(VkDevice, const VkAccelerationStructureVersionInfoKHR *, VkAccelerationStructureCompatibilityKHR *); @@ -11669,6 +11849,7 @@ typedef void (VKAPI_PTR *PFN_vkGetGeneratedCommandsMemoryRequirementsNV)(VkDevic typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements)(VkDevice, VkImage, VkMemoryRequirements *); typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2)(VkDevice, const VkImageMemoryRequirementsInfo2 *, VkMemoryRequirements2 *); typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2KHR)(VkDevice, const VkImageMemoryRequirementsInfo2 *, VkMemoryRequirements2 *); +typedef VkResult (VKAPI_PTR *PFN_vkGetImageOpaqueCaptureDescriptorDataEXT)(VkDevice, const VkImageCaptureDescriptorDataInfoEXT *, void *); typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements)(VkDevice, VkImage, uint32_t *, VkSparseImageMemoryRequirements *); typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements2)(VkDevice, const VkImageSparseMemoryRequirementsInfo2 *, uint32_t *, VkSparseImageMemoryRequirements2 *); typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements2KHR)(VkDevice, const VkImageSparseMemoryRequirementsInfo2 *, uint32_t *, VkSparseImageMemoryRequirements2 *); @@ -11676,6 +11857,7 @@ typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout)(VkDevice, VkImage, con typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout2EXT)(VkDevice, VkImage, const VkImageSubresource2EXT *, VkSubresourceLayout2EXT *); typedef VkResult (VKAPI_PTR *PFN_vkGetImageViewAddressNVX)(VkDevice, VkImageView, VkImageViewAddressPropertiesNVX *); typedef uint32_t (VKAPI_PTR *PFN_vkGetImageViewHandleNVX)(VkDevice, const VkImageViewHandleInfoNVX *); +typedef VkResult (VKAPI_PTR *PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT)(VkDevice, const VkImageViewCaptureDescriptorDataInfoEXT *, void *); typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetInstanceProcAddr)(VkInstance, const char *); typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryHostPointerPropertiesEXT)(VkDevice, VkExternalMemoryHandleTypeFlagBits, const void *, VkMemoryHostPointerPropertiesEXT *); typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleKHR)(VkDevice, const VkMemoryGetWin32HandleInfoKHR *, HANDLE *); @@ -11741,6 +11923,7 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetRayTracingShaderGroupHandlesKHR)(VkDevice, typedef VkResult (VKAPI_PTR *PFN_vkGetRayTracingShaderGroupHandlesNV)(VkDevice, VkPipeline, uint32_t, uint32_t, size_t, void *); typedef VkDeviceSize (VKAPI_PTR *PFN_vkGetRayTracingShaderGroupStackSizeKHR)(VkDevice, VkPipeline, uint32_t, VkShaderGroupShaderKHR); typedef void (VKAPI_PTR *PFN_vkGetRenderAreaGranularity)(VkDevice, VkRenderPass, VkExtent2D *); +typedef VkResult (VKAPI_PTR *PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT)(VkDevice, const VkSamplerCaptureDescriptorDataInfoEXT *, void *); typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreCounterValue)(VkDevice, VkSemaphore, uint64_t *); typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreCounterValueKHR)(VkDevice, VkSemaphore, uint64_t *); typedef VkResult (VKAPI_PTR *PFN_vkGetShaderInfoAMD)(VkDevice, VkPipeline, VkShaderStageFlagBits, VkShaderInfoTypeAMD, size_t *, void *); @@ -11824,6 +12007,8 @@ void VKAPI_CALL vkCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, const Vk void VKAPI_CALL vkCmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfo *pRenderingInfo); void VKAPI_CALL vkCmdBeginRenderingKHR(VkCommandBuffer commandBuffer, const VkRenderingInfo *pRenderingInfo); void VKAPI_CALL vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets); +void VKAPI_CALL vkCmdBindDescriptorBufferEmbeddedSamplersEXT(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set); +void VKAPI_CALL vkCmdBindDescriptorBuffersEXT(VkCommandBuffer commandBuffer, uint32_t bufferCount, const VkDescriptorBufferBindingInfoEXT *pBindingInfos); void VKAPI_CALL vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t *pDynamicOffsets); void VKAPI_CALL vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType); void VKAPI_CALL vkCmdBindInvocationMaskHUAWEI(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout); @@ -11961,6 +12146,7 @@ void VKAPI_CALL vkCmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 void VKAPI_CALL vkCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable); void VKAPI_CALL vkCmdSetDepthWriteEnable(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable); void VKAPI_CALL vkCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable); +void VKAPI_CALL vkCmdSetDescriptorBufferOffsetsEXT(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const uint32_t *pBufferIndices, const VkDeviceSize *pOffsets); void VKAPI_CALL vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask); void VKAPI_CALL vkCmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask); void VKAPI_CALL vkCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D *pDiscardRectangles); @@ -12148,6 +12334,7 @@ void VKAPI_CALL vkGetAccelerationStructureBuildSizesKHR(VkDevice device, VkAccel VkDeviceAddress VKAPI_CALL vkGetAccelerationStructureDeviceAddressKHR(VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR *pInfo); VkResult VKAPI_CALL vkGetAccelerationStructureHandleNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void *pData); void VKAPI_CALL vkGetAccelerationStructureMemoryRequirementsNV(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2KHR *pMemoryRequirements); +VkResult VKAPI_CALL vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT *pInfo, void *pData); VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddress(VkDevice device, const VkBufferDeviceAddressInfo *pInfo); VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressEXT(VkDevice device, const VkBufferDeviceAddressInfo *pInfo); VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo *pInfo); @@ -12156,11 +12343,15 @@ void VKAPI_CALL vkGetBufferMemoryRequirements2(VkDevice device, const VkBufferMe void VKAPI_CALL vkGetBufferMemoryRequirements2KHR(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements); uint64_t VKAPI_CALL vkGetBufferOpaqueCaptureAddress(VkDevice device, const VkBufferDeviceAddressInfo *pInfo); uint64_t VKAPI_CALL vkGetBufferOpaqueCaptureAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo *pInfo); +VkResult VKAPI_CALL vkGetBufferOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT *pInfo, void *pData); VkResult VKAPI_CALL vkGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT *pTimestampInfos, uint64_t *pTimestamps, uint64_t *pMaxDeviation); uint32_t VKAPI_CALL vkGetDeferredOperationMaxConcurrencyKHR(VkDevice device, VkDeferredOperationKHR operation); VkResult VKAPI_CALL vkGetDeferredOperationResultKHR(VkDevice device, VkDeferredOperationKHR operation); +void VKAPI_CALL vkGetDescriptorEXT(VkDevice device, const VkDescriptorGetInfoEXT *pDescriptorInfo, size_t dataSize, void *pDescriptor); void VKAPI_CALL vkGetDescriptorSetHostMappingVALVE(VkDevice device, VkDescriptorSet descriptorSet, void **ppData); +void VKAPI_CALL vkGetDescriptorSetLayoutBindingOffsetEXT(VkDevice device, VkDescriptorSetLayout layout, uint32_t binding, VkDeviceSize *pOffset); void VKAPI_CALL vkGetDescriptorSetLayoutHostMappingInfoVALVE(VkDevice device, const VkDescriptorSetBindingReferenceVALVE *pBindingReference, VkDescriptorSetLayoutHostMappingInfoVALVE *pHostMapping); +void VKAPI_CALL vkGetDescriptorSetLayoutSizeEXT(VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize *pLayoutSizeInBytes); void VKAPI_CALL vkGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport); void VKAPI_CALL vkGetDescriptorSetLayoutSupportKHR(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport); void VKAPI_CALL vkGetDeviceAccelerationStructureCompatibilityKHR(VkDevice device, const VkAccelerationStructureVersionInfoKHR *pVersionInfo, VkAccelerationStructureCompatibilityKHR *pCompatibility); @@ -12191,6 +12382,7 @@ void VKAPI_CALL vkGetGeneratedCommandsMemoryRequirementsNV(VkDevice device, cons void VKAPI_CALL vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements); void VKAPI_CALL vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements); void VKAPI_CALL vkGetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements); +VkResult VKAPI_CALL vkGetImageOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkImageCaptureDescriptorDataInfoEXT *pInfo, void *pData); void VKAPI_CALL vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements *pSparseMemoryRequirements); void VKAPI_CALL vkGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements); void VKAPI_CALL vkGetImageSparseMemoryRequirements2KHR(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements); @@ -12198,6 +12390,7 @@ void VKAPI_CALL vkGetImageSubresourceLayout(VkDevice device, VkImage image, cons void VKAPI_CALL vkGetImageSubresourceLayout2EXT(VkDevice device, VkImage image, const VkImageSubresource2EXT *pSubresource, VkSubresourceLayout2EXT *pLayout); VkResult VKAPI_CALL vkGetImageViewAddressNVX(VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX *pProperties); uint32_t VKAPI_CALL vkGetImageViewHandleNVX(VkDevice device, const VkImageViewHandleInfoNVX *pInfo); +VkResult VKAPI_CALL vkGetImageViewOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT *pInfo, void *pData); PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(VkInstance instance, const char *pName); VkResult VKAPI_CALL vkGetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void *pHostPointer, VkMemoryHostPointerPropertiesEXT *pMemoryHostPointerProperties); VkResult VKAPI_CALL vkGetMemoryWin32HandleKHR(VkDevice device, const VkMemoryGetWin32HandleInfoKHR *pGetWin32HandleInfo, HANDLE *pHandle); @@ -12263,6 +12456,7 @@ VkResult VKAPI_CALL vkGetRayTracingShaderGroupHandlesKHR(VkDevice device, VkPipe VkResult VKAPI_CALL vkGetRayTracingShaderGroupHandlesNV(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData); VkDeviceSize VKAPI_CALL vkGetRayTracingShaderGroupStackSizeKHR(VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader); void VKAPI_CALL vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D *pGranularity); +VkResult VKAPI_CALL vkGetSamplerOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkSamplerCaptureDescriptorDataInfoEXT *pInfo, void *pData); VkResult VKAPI_CALL vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t *pValue); VkResult VKAPI_CALL vkGetSemaphoreCounterValueKHR(VkDevice device, VkSemaphore semaphore, uint64_t *pValue); VkResult VKAPI_CALL vkGetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t *pInfoSize, void *pInfo);

-- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/1508

808

Age (days ago)

808

Last active (days ago)

wine-gitlab@winehq.org

2 comments

2 participants

tags (0)

participants (2)

Georg Lehmann
Georg Lehmann (＠DadSchoorse)