July 2018 - Wine-devel - list.winehq.org

[PATCH v3 2/2] winspool: Add performance counters service stubs.
by Huw Davies 12 Jul '18

12 Jul '18

From: Dmitry Timoshkov <dmitry(a)baikal.ru> Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> Signed-off-by: Huw Davies <huw(a)codeweavers.com> --- dlls/winspool.drv/info.c | 29 +++++++++++++++++++++++++++++ dlls/winspool.drv/winspool.drv.spec | 6 +++--- loader/wine.inf.in | 7 +++++++ 3 files changed, 39 insertions(+), 3 deletions(-) diff --git a/dlls/winspool.drv/info.c b/dlls/winspool.drv/info.c index 9c24256b51..f63f3f687b 100644 --- a/dlls/winspool.drv/info.c +++ b/dlls/winspool.drv/info.c @@ -8681,3 +8681,32 @@ HRESULT WINAPI UploadPrinterDriverPackageW( LPCWSTR server, LPCWSTR path, LPCWST flags, hwnd, dst, dstlen); return E_NOTIMPL; } + +/***************************************************************************** + * PerfOpen [WINSPOOL.@] + */ +DWORD WINAPI PerfOpen(LPWSTR context) +{ + FIXME("%s: stub\n", debugstr_w(context)); + return ERROR_SUCCESS; +} + +/***************************************************************************** + * PerfClose [WINSPOOL.@] + */ +DWORD WINAPI PerfClose(void) +{ + FIXME("stub\n"); + return ERROR_SUCCESS; +} + +/***************************************************************************** + * PerfCollect [WINSPOOL.@] + */ +DWORD WINAPI PerfCollect(LPWSTR query, LPVOID *data, LPDWORD size, LPDWORD obj_count) +{ + FIXME("%s, %p, %p, %p: stub\n", debugstr_w(query), data, size, obj_count); + *size = 0; + *obj_count = 0; + return ERROR_SUCCESS; +} diff --git a/dlls/winspool.drv/winspool.drv.spec b/dlls/winspool.drv/winspool.drv.spec index f7319cbe20..5d8a62d469 100644 --- a/dlls/winspool.drv/winspool.drv.spec +++ b/dlls/winspool.drv/winspool.drv.spec @@ -148,9 +148,9 @@ @ stdcall IsValidDevmodeW(ptr long) @ stdcall OpenPrinterA(str ptr ptr) @ stdcall OpenPrinterW(wstr ptr ptr) -@ stub PerfClose -@ stub PerfCollect -@ stub PerfOpen +@ stdcall PerfClose() +@ stdcall PerfCollect(wstr ptr ptr ptr) +@ stdcall PerfOpen(wstr) @ stub PlayGdiScriptOnPrinterIC @ stub PrinterMessageBoxA @ stub PrinterMessageBoxW diff --git a/loader/wine.inf.in b/loader/wine.inf.in index 735d965366..9a76509983 100644 --- a/loader/wine.inf.in +++ b/loader/wine.inf.in @@ -3309,6 +3309,7 @@ StartType=3 ErrorControl=1 [SpoolerService] +AddReg=SpoolerServiceKeys Description="Loads files to memory for later printing" DisplayName="Print Spooler" ServiceBinary="%11%\spoolsv.exe" @@ -3317,6 +3318,12 @@ StartType=3 ErrorControl=1 LoadOrderGroup="SpoolerGroup" +[SpoolerServiceKeys] +HKLM,"System\CurrentControlSet\Services\Spooler\Performance","Library",,"winspool.drv" +HKLM,"System\CurrentControlSet\Services\Spooler\Performance","Open",,"PerfOpen" +HKLM,"System\CurrentControlSet\Services\Spooler\Performance","Close",,"PerfClose" +HKLM,"System\CurrentControlSet\Services\Spooler\Performance","Collect",,"PerfCollect" + [TerminalServices] Description="Remote desktop access" DisplayName="Terminal Services" -- 2.16.2

1 0

[PATCH v3 1/2] winspool: Remove ordinals from the performance functions.
by Huw Davies 12 Jul '18

12 Jul '18

Signed-off-by: Huw Davies <huw(a)codeweavers.com> --- dlls/winspool.drv/winspool.drv.spec | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/dlls/winspool.drv/winspool.drv.spec b/dlls/winspool.drv/winspool.drv.spec index 58dc60bcc9..f7319cbe20 100644 --- a/dlls/winspool.drv/winspool.drv.spec +++ b/dlls/winspool.drv/winspool.drv.spec @@ -2,9 +2,6 @@ 101 stub -noname ClusterSplOpen 102 stub -noname ClusterSplClose 103 stub -noname ClusterSplIsAlive -104 stub PerfClose -105 stub PerfCollect -106 stub PerfOpen 201 stdcall GetDefaultPrinterA(ptr ptr) 202 stdcall SetDefaultPrinterA(str) 203 stdcall GetDefaultPrinterW(ptr ptr) @@ -151,6 +148,9 @@ @ stdcall IsValidDevmodeW(ptr long) @ stdcall OpenPrinterA(str ptr ptr) @ stdcall OpenPrinterW(wstr ptr ptr) +@ stub PerfClose +@ stub PerfCollect +@ stub PerfOpen @ stub PlayGdiScriptOnPrinterIC @ stub PrinterMessageBoxA @ stub PrinterMessageBoxW -- 2.16.2

1 0

[PATCH 8/8] winevulkan: Add TRACE() for created devices.
by Józef Kucia 12 Jul '18

12 Jul '18

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/winevulkan/vulkan.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/dlls/winevulkan/vulkan.c b/dlls/winevulkan/vulkan.c index 987332e62225..cb84c4dd53ad 100644 --- a/dlls/winevulkan/vulkan.c +++ b/dlls/winevulkan/vulkan.c @@ -650,6 +650,7 @@ VkResult WINAPI wine_vkCreateDevice(VkPhysicalDevice phys_dev, object->quirks = phys_dev->instance->quirks; *device = object; + TRACE("Created device %p (native device %p).\n", object, object->device); return VK_SUCCESS; } @@ -713,7 +714,7 @@ VkResult WINAPI wine_vkCreateInstance(const VkInstanceCreateInfo *create_info, } *instance = object; - TRACE("Done, instance=%p native_instance=%p\n", object, object->instance); + TRACE("Created instance %p (native instance %p).\n", object, object->instance); return VK_SUCCESS; } -- 2.16.4

1 0

[PATCH 7/8] vulkan-1/tests: Add test for VK_KHR_device_group_creation.
by Józef Kucia 12 Jul '18

12 Jul '18

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/vulkan-1/tests/vulkan.c | 143 +++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 139 insertions(+), 4 deletions(-) diff --git a/dlls/vulkan-1/tests/vulkan.c b/dlls/vulkan-1/tests/vulkan.c index 25e5c01343f6..087ee16b05df 100644 --- a/dlls/vulkan-1/tests/vulkan.c +++ b/dlls/vulkan-1/tests/vulkan.c @@ -25,6 +25,7 @@ static VkResult create_instance(uint32_t extension_count, const char * const *enabled_extensions, VkInstance *vk_instance) { VkInstanceCreateInfo create_info; + VkResult vr; create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; create_info.pNext = NULL; @@ -35,7 +36,82 @@ static VkResult create_instance(uint32_t extension_count, create_info.enabledExtensionCount = extension_count; create_info.ppEnabledExtensionNames = enabled_extensions; - return vkCreateInstance(&create_info, NULL, vk_instance); + if ((vr = vkCreateInstance(&create_info, NULL, vk_instance)) >= 0) + return vr; + + switch (vr) + { + case VK_ERROR_EXTENSION_NOT_PRESENT: + if (extension_count == 1) + skip("Instance extension '%s' not supported.\n", enabled_extensions[0]); + else + skip("Instance extensions not supported.\n"); + break; + + default: + skip("Failed to create Vulkan instance, vr %d.\n", vr); + break; + } + return vr; +} + +static VkBool32 find_queue_family(VkPhysicalDevice vk_physical_device, + VkQueueFlags flags, uint32_t *family_index) +{ + VkQueueFamilyProperties *properties; + VkBool32 ret = VK_FALSE; + uint32_t i, count; + + vkGetPhysicalDeviceQueueFamilyProperties(vk_physical_device, &count, NULL); + properties = heap_calloc(count, sizeof(*properties)); + ok(!!properties, "Failed to allocate memory.\n"); + vkGetPhysicalDeviceQueueFamilyProperties(vk_physical_device, &count, properties); + + for (i = 0; i < count; ++i) + { + if ((properties[i].queueFlags & flags) == flags) + { + ret = VK_TRUE; + *family_index = i; + break; + } + } + + heap_free(properties); + return ret; +} + +static VkResult create_device(VkPhysicalDevice vk_physical_device, + uint32_t extension_count, const char * const *enabled_extensions, + const void *next, VkDevice *vk_device) +{ + VkDeviceQueueCreateInfo queue_info; + VkDeviceCreateInfo create_info; + float priority = 0.0f; + + queue_info.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO; + queue_info.pNext = NULL; + queue_info.flags = 0; + if (!find_queue_family(vk_physical_device, VK_QUEUE_GRAPHICS_BIT, &queue_info.queueFamilyIndex)) + { + trace("Failed to find queue family.\n"); + return VK_ERROR_INITIALIZATION_FAILED; + } + queue_info.queueCount = 1; + queue_info.pQueuePriorities = &priority; + + create_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO; + create_info.pNext = next; + create_info.flags = 0; + create_info.queueCreateInfoCount = 1; + create_info.pQueueCreateInfos = &queue_info; + create_info.enabledLayerCount = 0; + create_info.ppEnabledLayerNames = NULL; + create_info.enabledExtensionCount = extension_count; + create_info.ppEnabledExtensionNames = enabled_extensions; + create_info.pEnabledFeatures = NULL; + + return vkCreateDevice(vk_physical_device, &create_info, NULL, vk_device); } static void enumerate_physical_device(VkPhysicalDevice vk_physical_device) @@ -52,6 +128,67 @@ static void enumerate_physical_device(VkPhysicalDevice vk_physical_device) VK_VERSION_PATCH(properties.apiVersion)); } +static void test_physical_device_groups(void) +{ + PFN_vkEnumeratePhysicalDeviceGroupsKHR vkEnumeratePhysicalDeviceGroupsKHR; + VkPhysicalDeviceGroupProperties *properties; + VkDeviceGroupDeviceCreateInfo group_info; + VkInstance vk_instance; + uint32_t i, j, count; + VkDevice vk_device; + VkResult vr; + + static const char *extensions[] = + { + VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME, + }; + + if ((vr = create_instance(ARRAY_SIZE(extensions), extensions, &vk_instance)) < 0) + return; + ok(vr == VK_SUCCESS, "Got unexpected VkResult %d.\n", vr); + + vkEnumeratePhysicalDeviceGroupsKHR + = (void *)vkGetInstanceProcAddr(vk_instance, "vkEnumeratePhysicalDeviceGroupsKHR"); + ok(!!vkEnumeratePhysicalDeviceGroupsKHR, "Failed to get proc addr.\n"); + + vr = vkEnumeratePhysicalDeviceGroupsKHR(vk_instance, &count, NULL); + ok(vr == VK_SUCCESS, "Got unexpected VkResult %d.\n", vr); + ok(count > 0, "Unexpected device group count %u.\n", count); + + properties = heap_calloc(count, sizeof(*properties)); + ok(!!properties, "Failed to allocate memory.\n"); + vr = vkEnumeratePhysicalDeviceGroupsKHR(vk_instance, &count, properties); + ok(vr == VK_SUCCESS, "Got unexpected VkResult %d.\n", vr); + + for (i = 0; i < count; ++i) + { + trace("Group[%u] count %u, subset allocation %#x\n", + i, properties[i].physicalDeviceCount, properties[i].subsetAllocation); + for (j = 0; j < properties[i].physicalDeviceCount; ++j) + enumerate_physical_device(properties[i].physicalDevices[j]); + } + + if ((vr = create_device(properties->physicalDevices[0], 0, NULL, NULL, &vk_device)) < 0) + { + skip("Failed to create device, vr %d.\n", vr); + return; + } + ok(vr == VK_SUCCESS, "Got unexpected VkResult %d.\n", vr); + vkDestroyDevice(vk_device, NULL); + + group_info.sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO; + group_info.pNext = NULL; + group_info.physicalDeviceCount = properties->physicalDeviceCount; + group_info.pPhysicalDevices = properties->physicalDevices; + vr = create_device(group_info.pPhysicalDevices[0], 0, NULL, &group_info, &vk_device); + ok(vr == VK_SUCCESS, "Failed to create device, VkResult %d.\n", vr); + vkDestroyDevice(vk_device, NULL); + + heap_free(properties); + + vkDestroyInstance(vk_instance, NULL); +} + static void for_each_device(void (*test_func)(VkPhysicalDevice)) { VkPhysicalDevice *vk_physical_devices; @@ -61,10 +198,7 @@ static void for_each_device(void (*test_func)(VkPhysicalDevice)) VkResult vr; if ((vr = create_instance(0, NULL, &vk_instance)) < 0) - { - skip("Failed to create Vulkan instance, vr %d.\n", vr); return; - } ok(vr == VK_SUCCESS, "Got unexpected VkResult %d.\n", vr); vr = vkEnumeratePhysicalDevices(vk_instance, &count, NULL); @@ -92,4 +226,5 @@ static void for_each_device(void (*test_func)(VkPhysicalDevice)) START_TEST(vulkan) { for_each_device(enumerate_physical_device); + test_physical_device_groups(); } -- 2.16.4

1 0

[PATCH 6/8] vulkan-1/tests: Introduce for_each_device() helper.
by Józef Kucia 12 Jul '18

12 Jul '18

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/vulkan-1/tests/vulkan.c | 31 +++++++++++++++++-------------- 1 file changed, 17 insertions(+), 14 deletions(-) diff --git a/dlls/vulkan-1/tests/vulkan.c b/dlls/vulkan-1/tests/vulkan.c index 67da880fe470..25e5c01343f6 100644 --- a/dlls/vulkan-1/tests/vulkan.c +++ b/dlls/vulkan-1/tests/vulkan.c @@ -38,10 +38,23 @@ static VkResult create_instance(uint32_t extension_count, return vkCreateInstance(&create_info, NULL, vk_instance); } -static void test_enumerate_physical_devices(void) +static void enumerate_physical_device(VkPhysicalDevice vk_physical_device) { - VkPhysicalDevice *vk_physical_devices; VkPhysicalDeviceProperties properties; + + vkGetPhysicalDeviceProperties(vk_physical_device, &properties); + + trace("Device '%s', %#x:%#x, driver version %u.%u.%u (%#x), api version %u.%u.%u.\n", + properties.deviceName, properties.vendorID, properties.deviceID, + VK_VERSION_MAJOR(properties.driverVersion), VK_VERSION_MINOR(properties.driverVersion), + VK_VERSION_PATCH(properties.driverVersion), properties.driverVersion, + VK_VERSION_MAJOR(properties.apiVersion), VK_VERSION_MINOR(properties.apiVersion), + VK_VERSION_PATCH(properties.apiVersion)); +} + +static void for_each_device(void (*test_func)(VkPhysicalDevice)) +{ + VkPhysicalDevice *vk_physical_devices; VkInstance vk_instance; unsigned int i; uint32_t count; @@ -63,23 +76,13 @@ static void test_enumerate_physical_devices(void) return; } - trace("Got %u physical device(s).\n", count); vk_physical_devices = heap_calloc(count, sizeof(*vk_physical_devices)); ok(!!vk_physical_devices, "Failed to allocate memory.\n"); vr = vkEnumeratePhysicalDevices(vk_instance, &count, vk_physical_devices); ok(vr == VK_SUCCESS, "Got unexpected VkResult %d.\n", vr); for (i = 0; i < count; ++i) - { - vkGetPhysicalDeviceProperties(vk_physical_devices[i], &properties); - - trace("Device '%s', %#x:%#x, driver version %u.%u.%u (%#x), api version %u.%u.%u.\n", - properties.deviceName, properties.vendorID, properties.deviceID, - VK_VERSION_MAJOR(properties.driverVersion), VK_VERSION_MINOR(properties.driverVersion), - VK_VERSION_PATCH(properties.driverVersion), properties.driverVersion, - VK_VERSION_MAJOR(properties.apiVersion), VK_VERSION_MINOR(properties.apiVersion), - VK_VERSION_PATCH(properties.apiVersion)); - } + test_func(vk_physical_devices[i]); heap_free(vk_physical_devices); @@ -88,5 +91,5 @@ static void test_enumerate_physical_devices(void) START_TEST(vulkan) { - test_enumerate_physical_devices(); + for_each_device(enumerate_physical_device); } -- 2.16.4

1 0

[PATCH 5/8] winevulkan: Implement VK_KHR_device_group_creation.
by Józef Kucia 12 Jul '18

12 Jul '18

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/vulkan-1/vulkan-1.spec | 2 +- dlls/winevulkan/make_vulkan | 5 +++ dlls/winevulkan/vulkan.c | 91 +++++++++++++++++++++++++++++++--------- dlls/winevulkan/vulkan_private.h | 2 +- dlls/winevulkan/vulkan_thunks.c | 3 ++ dlls/winevulkan/vulkan_thunks.h | 6 +++ dlls/winevulkan/winevulkan.spec | 2 +- include/wine/vulkan.h | 6 +++ 8 files changed, 95 insertions(+), 22 deletions(-) diff --git a/dlls/vulkan-1/vulkan-1.spec b/dlls/vulkan-1/vulkan-1.spec index 79031395a099..8c32b011f251 100644 --- a/dlls/vulkan-1/vulkan-1.spec +++ b/dlls/vulkan-1/vulkan-1.spec @@ -149,7 +149,7 @@ @ stdcall vkEnumerateInstanceExtensionProperties(str ptr ptr) @ stdcall vkEnumerateInstanceLayerProperties(ptr ptr) @ stub vkEnumerateInstanceVersion -@ stub vkEnumeratePhysicalDeviceGroups +@ stdcall vkEnumeratePhysicalDeviceGroups(ptr ptr ptr) winevulkan.wine_vkEnumeratePhysicalDeviceGroups @ stdcall vkEnumeratePhysicalDevices(ptr ptr ptr) winevulkan.wine_vkEnumeratePhysicalDevices @ stdcall vkFlushMappedMemoryRanges(ptr long ptr) winevulkan.wine_vkFlushMappedMemoryRanges @ stdcall vkFreeCommandBuffers(ptr int64 long ptr) winevulkan.wine_vkFreeCommandBuffers diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan index d0a83c32e0cb..2672ad77e46c 100755 --- a/dlls/winevulkan/make_vulkan +++ b/dlls/winevulkan/make_vulkan @@ -86,6 +86,7 @@ EXT_BLOCK_SIZE = 1000 # and need custom wrappers due to e.g. win32 / X11 specific code. # List of supported instance extensions. SUPPORTED_INSTANCE_EXTENSIONS = [ + "VK_KHR_device_group_creation", "VK_KHR_get_physical_device_properties2", "VK_KHR_surface", "VK_KHR_win32_surface", @@ -150,6 +151,7 @@ FUNCTION_OVERRIDES = { "vkDestroyInstance" : {"dispatch" : False, "driver" : True, "thunk" : False }, "vkEnumerateDeviceExtensionProperties" : {"dispatch" : True, "driver" : False, "thunk" : False}, "vkEnumeratePhysicalDevices" : {"dispatch" : True, "driver" : False, "thunk" : False}, + "vkEnumeratePhysicalDeviceGroups" : {"dispatch" : True, "driver" : False, "thunk" : False}, # Device functions "vkAllocateCommandBuffers" : {"dispatch" : True, "driver" : False, "thunk" : False}, @@ -177,6 +179,9 @@ FUNCTION_OVERRIDES = { "vkDestroySwapchainKHR" : {"dispatch" : True, "driver" : True, "thunk" : True}, "vkGetSwapchainImagesKHR": {"dispatch" : True, "driver" : True, "thunk" : True}, "vkQueuePresentKHR": {"dispatch" : True, "driver" : True, "thunk" : True}, + + # VK_KHR_device_group_creation + "vkEnumeratePhysicalDeviceGroupsKHR" : {"dispatch" : True, "driver" : False, "thunk" : False}, } diff --git a/dlls/winevulkan/vulkan.c b/dlls/winevulkan/vulkan.c index 96b591ac944c..987332e62225 100644 --- a/dlls/winevulkan/vulkan.c +++ b/dlls/winevulkan/vulkan.c @@ -390,34 +390,31 @@ static void wine_vk_instance_convert_create_info(const VkInstanceCreateInfo *src /* Helper function which stores wrapped physical devices in the instance object. */ static VkResult wine_vk_instance_load_physical_devices(struct VkInstance_T *instance) { - VkResult res; - struct VkPhysicalDevice_T **tmp_phys_devs; - uint32_t num_phys_devs = 0; + VkPhysicalDevice *tmp_phys_devs; + uint32_t phys_dev_count; unsigned int i; + VkResult res; - res = instance->funcs.p_vkEnumeratePhysicalDevices(instance->instance, &num_phys_devs, NULL); + res = instance->funcs.p_vkEnumeratePhysicalDevices(instance->instance, &phys_dev_count, NULL); if (res != VK_SUCCESS) { ERR("Failed to enumerate physical devices, res=%d\n", res); return res; } + if (!phys_dev_count) + return res; - /* Don't bother with any of the rest if the system just lacks devices. */ - if (num_phys_devs == 0) - return VK_SUCCESS; - - tmp_phys_devs = heap_calloc(num_phys_devs, sizeof(*tmp_phys_devs)); - if (!tmp_phys_devs) + if (!(tmp_phys_devs = heap_calloc(phys_dev_count, sizeof(*tmp_phys_devs)))) return VK_ERROR_OUT_OF_HOST_MEMORY; - res = instance->funcs.p_vkEnumeratePhysicalDevices(instance->instance, &num_phys_devs, tmp_phys_devs); + res = instance->funcs.p_vkEnumeratePhysicalDevices(instance->instance, &phys_dev_count, tmp_phys_devs); if (res != VK_SUCCESS) { heap_free(tmp_phys_devs); return res; } - instance->phys_devs = heap_calloc(num_phys_devs, sizeof(*instance->phys_devs)); + instance->phys_devs = heap_calloc(phys_dev_count, sizeof(*instance->phys_devs)); if (!instance->phys_devs) { heap_free(tmp_phys_devs); @@ -425,7 +422,7 @@ static VkResult wine_vk_instance_load_physical_devices(struct VkInstance_T *inst } /* Wrap each native physical device handle into a dispatchable object for the ICD loader. */ - for (i = 0; i < num_phys_devs; i++) + for (i = 0; i < phys_dev_count; i++) { struct VkPhysicalDevice_T *phys_dev = wine_vk_physical_device_alloc(instance, tmp_phys_devs[i]); if (!phys_dev) @@ -436,14 +433,30 @@ static VkResult wine_vk_instance_load_physical_devices(struct VkInstance_T *inst } instance->phys_devs[i] = phys_dev; - instance->num_phys_devs = i + 1; + instance->phys_dev_count = i + 1; } - instance->num_phys_devs = num_phys_devs; + instance->phys_dev_count = phys_dev_count; heap_free(tmp_phys_devs); return VK_SUCCESS; } +static struct VkPhysicalDevice_T *wine_vk_instance_wrap_physical_device(struct VkInstance_T *instance, + VkPhysicalDevice physical_device) +{ + unsigned int i; + + for (i = 0; i < instance->phys_dev_count; ++i) + { + struct VkPhysicalDevice_T *current = instance->phys_devs[i]; + if (current->phys_dev == physical_device) + return current; + } + + ERR("Unrecognized physical device %p.\n", physical_device); + return NULL; +} + /* Helper function used for freeing an instance structure. This function supports full * and partial object cleanups and can thus be used for vkCreateInstance failures. */ @@ -456,7 +469,7 @@ static void wine_vk_instance_free(struct VkInstance_T *instance) { unsigned int i; - for (i = 0; i < instance->num_phys_devs; i++) + for (i = 0; i < instance->phys_dev_count; i++) { wine_vk_physical_device_free(instance->phys_devs[i]); } @@ -826,18 +839,18 @@ VkResult WINAPI wine_vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *c if (!devices) { - *count = instance->num_phys_devs; + *count = instance->phys_dev_count; return VK_SUCCESS; } - *count = min(*count, instance->num_phys_devs); + *count = min(*count, instance->phys_dev_count); for (i = 0; i < *count; i++) { devices[i] = instance->phys_devs[i]; } TRACE("Returning %u devices.\n", *count); - return *count < instance->num_phys_devs ? VK_INCOMPLETE : VK_SUCCESS; + return *count < instance->phys_dev_count ? VK_INCOMPLETE : VK_SUCCESS; } void WINAPI wine_vkFreeCommandBuffers(VkDevice device, VkCommandPool pool, uint32_t count, @@ -1016,6 +1029,46 @@ err: return res; } +static VkResult wine_vk_enumerate_physical_device_groups(struct VkInstance_T *instance, + VkResult (*p_vkEnumeratePhysicalDeviceGroups)(VkInstance, uint32_t *, VkPhysicalDeviceGroupProperties *), + uint32_t *count, VkPhysicalDeviceGroupProperties *properties) +{ + unsigned int i, j; + VkResult res; + + res = p_vkEnumeratePhysicalDeviceGroups(instance->instance, count, properties); + if (res < 0 || !properties) + return res; + + for (i = 0; i < *count; ++i) + { + VkPhysicalDeviceGroupProperties *current = &properties[i]; + for (j = 0; j < current->physicalDeviceCount; ++j) + { + VkPhysicalDevice dev = current->physicalDevices[j]; + if (!(current->physicalDevices[j] = wine_vk_instance_wrap_physical_device(instance, dev))) + return VK_ERROR_INITIALIZATION_FAILED; + } + } + + return res; +} + +VkResult WINAPI wine_vkEnumeratePhysicalDeviceGroups(VkInstance instance, + uint32_t *count, VkPhysicalDeviceGroupProperties *properties) +{ + TRACE("%p, %p, %p\n", instance, count, properties); + return wine_vk_enumerate_physical_device_groups(instance, + instance->funcs.p_vkEnumeratePhysicalDeviceGroups, count, properties); +} + +VkResult WINAPI wine_vkEnumeratePhysicalDeviceGroupsKHR(VkInstance instance, + uint32_t *count, VkPhysicalDeviceGroupProperties *properties) +{ + TRACE("%p, %p, %p\n", instance, count, properties); + return wine_vk_enumerate_physical_device_groups(instance, + instance->funcs.p_vkEnumeratePhysicalDeviceGroupsKHR, count, properties); +} BOOL WINAPI DllMain(HINSTANCE hinst, DWORD reason, void *reserved) { diff --git a/dlls/winevulkan/vulkan_private.h b/dlls/winevulkan/vulkan_private.h index 353f7af36c0d..37af92064028 100644 --- a/dlls/winevulkan/vulkan_private.h +++ b/dlls/winevulkan/vulkan_private.h @@ -86,7 +86,7 @@ struct VkInstance_T * dispatchable objects. */ struct VkPhysicalDevice_T **phys_devs; - uint32_t num_phys_devs; + uint32_t phys_dev_count; unsigned int quirks; }; diff --git a/dlls/winevulkan/vulkan_thunks.c b/dlls/winevulkan/vulkan_thunks.c index 31ea551d5314..2a6300341015 100644 --- a/dlls/winevulkan/vulkan_thunks.c +++ b/dlls/winevulkan/vulkan_thunks.c @@ -2919,6 +2919,8 @@ static const struct vulkan_func vk_instance_dispatch_table[] = {"vkDestroySurfaceKHR", &wine_vkDestroySurfaceKHR}, {"vkEnumerateDeviceExtensionProperties", &wine_vkEnumerateDeviceExtensionProperties}, {"vkEnumerateDeviceLayerProperties", &wine_vkEnumerateDeviceLayerProperties}, + {"vkEnumeratePhysicalDeviceGroups", &wine_vkEnumeratePhysicalDeviceGroups}, + {"vkEnumeratePhysicalDeviceGroupsKHR", &wine_vkEnumeratePhysicalDeviceGroupsKHR}, {"vkEnumeratePhysicalDevices", &wine_vkEnumeratePhysicalDevices}, {"vkGetPhysicalDeviceFeatures", &wine_vkGetPhysicalDeviceFeatures}, {"vkGetPhysicalDeviceFeatures2", &wine_vkGetPhysicalDeviceFeatures2}, @@ -3048,6 +3050,7 @@ static const char * const vk_device_extensions[] = static const char * const vk_instance_extensions[] = { + "VK_KHR_device_group_creation", "VK_KHR_get_physical_device_properties2", "VK_KHR_surface", "VK_KHR_win32_surface", diff --git a/dlls/winevulkan/vulkan_thunks.h b/dlls/winevulkan/vulkan_thunks.h index dd85e4270087..c9fe07898000 100644 --- a/dlls/winevulkan/vulkan_thunks.h +++ b/dlls/winevulkan/vulkan_thunks.h @@ -45,6 +45,8 @@ VkResult WINAPI wine_vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDev void WINAPI wine_vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator); void WINAPI wine_vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator); VkResult WINAPI wine_vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties); +VkResult WINAPI wine_vkEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties); +VkResult WINAPI wine_vkEnumeratePhysicalDeviceGroupsKHR(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties) DECLSPEC_HIDDEN; VkResult WINAPI wine_vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount, VkPhysicalDevice *pPhysicalDevices); void WINAPI wine_vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers); PFN_vkVoidFunction WINAPI wine_vkGetDeviceProcAddr(VkDevice device, const char *pName); @@ -942,6 +944,8 @@ struct vulkan_instance_funcs void (*p_vkDestroySurfaceKHR)(VkInstance, VkSurfaceKHR, const VkAllocationCallbacks *); VkResult (*p_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice, const char *, uint32_t *, VkExtensionProperties *); VkResult (*p_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice, uint32_t *, VkLayerProperties *); + VkResult (*p_vkEnumeratePhysicalDeviceGroups)(VkInstance, uint32_t *, VkPhysicalDeviceGroupProperties *); + VkResult (*p_vkEnumeratePhysicalDeviceGroupsKHR)(VkInstance, uint32_t *, VkPhysicalDeviceGroupProperties *); VkResult (*p_vkEnumeratePhysicalDevices)(VkInstance, uint32_t *, VkPhysicalDevice *); void (*p_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice, VkPhysicalDeviceFeatures *); void (*p_vkGetPhysicalDeviceFeatures2)(VkPhysicalDevice, VkPhysicalDeviceFeatures2 *); @@ -1180,6 +1184,8 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkDestroySurfaceKHR) \ USE_VK_FUNC(vkEnumerateDeviceExtensionProperties) \ USE_VK_FUNC(vkEnumerateDeviceLayerProperties) \ + USE_VK_FUNC(vkEnumeratePhysicalDeviceGroups) \ + USE_VK_FUNC(vkEnumeratePhysicalDeviceGroupsKHR) \ USE_VK_FUNC(vkEnumeratePhysicalDevices) \ USE_VK_FUNC(vkGetPhysicalDeviceFeatures) \ USE_VK_FUNC(vkGetPhysicalDeviceFeatures2) \ diff --git a/dlls/winevulkan/winevulkan.spec b/dlls/winevulkan/winevulkan.spec index dc43ef816b60..c196eb1324a4 100644 --- a/dlls/winevulkan/winevulkan.spec +++ b/dlls/winevulkan/winevulkan.spec @@ -150,7 +150,7 @@ @ stdcall wine_vkEnumerateDeviceLayerProperties(ptr ptr ptr) @ stdcall wine_vkEnumerateInstanceExtensionProperties(str ptr ptr) @ stub vkEnumerateInstanceVersion -@ stub vkEnumeratePhysicalDeviceGroups +@ stdcall wine_vkEnumeratePhysicalDeviceGroups(ptr ptr ptr) @ stdcall wine_vkEnumeratePhysicalDevices(ptr ptr ptr) @ stdcall wine_vkFlushMappedMemoryRanges(ptr long ptr) @ stdcall wine_vkFreeCommandBuffers(ptr int64 long ptr) diff --git a/include/wine/vulkan.h b/include/wine/vulkan.h index c6e4c59bcb7f..6eec0b8a7625 100644 --- a/include/wine/vulkan.h +++ b/include/wine/vulkan.h @@ -137,6 +137,8 @@ #define VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME "VK_EXT_shader_subgroup_vote" #define VK_KHR_MAINTENANCE1_SPEC_VERSION 2 #define VK_KHR_MAINTENANCE1_EXTENSION_NAME "VK_KHR_maintenance1" +#define VK_KHR_DEVICE_GROUP_CREATION_SPEC_VERSION 1 +#define VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME "VK_KHR_device_group_creation" #define VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION 2 #define VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME "VK_KHR_push_descriptor" #define VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR 1 @@ -4290,6 +4292,8 @@ typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysica typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice, uint32_t *, VkLayerProperties *); typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceExtensionProperties)(const char *, uint32_t *, VkExtensionProperties *); typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceLayerProperties)(uint32_t *, VkLayerProperties *); +typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceGroups)(VkInstance, uint32_t *, VkPhysicalDeviceGroupProperties *); +typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceGroupsKHR)(VkInstance, uint32_t *, VkPhysicalDeviceGroupProperties *); typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDevices)(VkInstance, uint32_t *, VkPhysicalDevice *); typedef VkResult (VKAPI_PTR *PFN_vkFlushMappedMemoryRanges)(VkDevice, uint32_t, const VkMappedMemoryRange *); typedef void (VKAPI_PTR *PFN_vkFreeCommandBuffers)(VkDevice, VkCommandPool, uint32_t, const VkCommandBuffer *); @@ -4495,6 +4499,8 @@ VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physic VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkLayerProperties *pProperties); VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties); VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(uint32_t *pPropertyCount, VkLayerProperties *pProperties); +VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties); +VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroupsKHR(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties); VkResult VKAPI_CALL vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount, VkPhysicalDevice *pPhysicalDevices); VkResult VKAPI_CALL vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges); void VKAPI_CALL vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers); -- 2.16.4

1 0

[PATCH 4/8] winevulkan: Convert VkDeviceGroupDeviceCreateInfo.
by Józef Kucia 12 Jul '18

12 Jul '18

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/winevulkan/vulkan.c | 88 ++++++++++++++++++++++++++++++++++++++++-------- 1 file changed, 74 insertions(+), 14 deletions(-) diff --git a/dlls/winevulkan/vulkan.c b/dlls/winevulkan/vulkan.c index 53d7a119ab0c..96b591ac944c 100644 --- a/dlls/winevulkan/vulkan.c +++ b/dlls/winevulkan/vulkan.c @@ -38,9 +38,23 @@ WINE_DEFAULT_DEBUG_CHANNEL(vulkan); struct wine_vk_structure_header { VkStructureType sType; - const void *pNext; + void *pNext; }; +#define wine_vk_find_struct(s, t) wine_vk_find_struct_((void *)s, VK_STRUCTURE_TYPE_##t) +static void *wine_vk_find_struct_(void *s, VkStructureType t) +{ + struct wine_vk_structure_header *header; + + for (header = s; header; header = header->pNext) + { + if (header->sType == t) + return header; + } + + return NULL; +} + static void *wine_vk_get_global_proc_addr(const char *name); static const struct vulkan_funcs *vk_funcs; @@ -182,8 +196,30 @@ static struct VkQueue_T *wine_vk_device_alloc_queues(struct VkDevice_T *device, return queues; } -/* Helper function to convert win32 VkDeviceCreateInfo to host compatible. */ -static void wine_vk_device_convert_create_info(const VkDeviceCreateInfo *src, +static VkDeviceGroupDeviceCreateInfo *convert_VkDeviceGroupDeviceCreateInfo(const void *src) +{ + const VkDeviceGroupDeviceCreateInfo *in = src; + VkDeviceGroupDeviceCreateInfo *out; + VkPhysicalDevice *physical_devices; + unsigned int i; + + if (!(out = heap_alloc(sizeof(*out)))) + return NULL; + + *out = *in; + if (!(physical_devices = heap_calloc(in->physicalDeviceCount, sizeof(*physical_devices)))) + { + heap_free(out); + return NULL; + } + for (i = 0; i < in->physicalDeviceCount; ++i) + physical_devices[i] = in->pPhysicalDevices[i]->phys_dev; + out->pPhysicalDevices = physical_devices; + + return out; +} + +static VkResult wine_vk_device_convert_create_info(const VkDeviceCreateInfo *src, VkDeviceCreateInfo *dst) { unsigned int i; @@ -192,13 +228,13 @@ static void wine_vk_device_convert_create_info(const VkDeviceCreateInfo *src, /* Application and loader can pass in a chain of extensions through pNext. * We can't blindly pass these through as often these contain callbacks or - * they can even be pass structures for loader / ICD internal use. For now - * we ignore everything in pNext chain, but we print FIXMEs. + * they can even be pass structures for loader / ICD internal use. */ if (src->pNext) { const struct wine_vk_structure_header *header; + dst->pNext = NULL; for (header = src->pNext; header; header = header->pNext) { switch (header->sType) @@ -209,23 +245,41 @@ static void wine_vk_device_convert_create_info(const VkDeviceCreateInfo *src, */ break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO: + if (!(dst->pNext = convert_VkDeviceGroupDeviceCreateInfo(header))) + return VK_ERROR_OUT_OF_HOST_MEMORY; + break; + default: FIXME("Application requested a linked structure of type %#x.\n", header->sType); } } } - /* For now don't support anything. */ - dst->pNext = NULL; /* Should be filtered out by loader as ICDs don't support layers. */ dst->enabledLayerCount = 0; dst->ppEnabledLayerNames = NULL; - TRACE("Enabled extensions: %u\n", dst->enabledExtensionCount); + TRACE("Enabled extensions: %u.\n", dst->enabledExtensionCount); for (i = 0; i < dst->enabledExtensionCount; i++) { - TRACE("Extension %u: %s\n", i, debugstr_a(dst->ppEnabledExtensionNames[i])); + TRACE("Extension %u: %s.\n", i, debugstr_a(dst->ppEnabledExtensionNames[i])); + } + + return VK_SUCCESS; +} + +static void wine_vk_device_free_create_info(VkDeviceCreateInfo *create_info) +{ + VkDeviceGroupDeviceCreateInfo *group_info; + + if ((group_info = wine_vk_find_struct(create_info, DEVICE_GROUP_DEVICE_CREATE_INFO))) + { + heap_free((void *)group_info->pPhysicalDevices); + heap_free(group_info); } + + create_info->pNext = NULL; } /* Helper function used for freeing a device structure. This function supports full @@ -507,24 +561,30 @@ VkResult WINAPI wine_vkCreateDevice(VkPhysicalDevice phys_dev, VkDeviceCreateInfo create_info_host; uint32_t max_queue_families; struct VkDevice_T *object; - VkResult res; unsigned int i; + VkResult res; - TRACE("%p %p %p %p\n", phys_dev, create_info, allocator, device); + TRACE("%p, %p, %p, %p\n", phys_dev, create_info, allocator, device); if (allocator) FIXME("Support for allocation callbacks not implemented yet\n"); - object = heap_alloc_zero(sizeof(*object)); - if (!object) + if (!(object = heap_alloc_zero(sizeof(*object)))) return VK_ERROR_OUT_OF_HOST_MEMORY; object->base.loader_magic = VULKAN_ICD_MAGIC_VALUE; - wine_vk_device_convert_create_info(create_info, &create_info_host); + res = wine_vk_device_convert_create_info(create_info, &create_info_host); + if (res != VK_SUCCESS) + { + ERR("Failed to convert VkDeviceCreateInfo, res=%d.\n", res); + wine_vk_device_free(object); + return res; + } res = phys_dev->instance->funcs.p_vkCreateDevice(phys_dev->phys_dev, &create_info_host, NULL /* allocator */, &object->device); + wine_vk_device_free_create_info(&create_info_host); if (res != VK_SUCCESS) { ERR("Failed to create device.\n"); -- 2.16.4

1 0

[PATCH 3/8] winevulkan: Pull in 1.1 structures and enums into Vulkan header.
by Józef Kucia 12 Jul '18

12 Jul '18

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/winevulkan/make_vulkan | 123 ++++----- include/wine/vulkan.h | 649 ++++++++++++++++++++++++++++++++++++++++---- 2 files changed, 651 insertions(+), 121 deletions(-) diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan index 70aa5ee0d8d9..d0a83c32e0cb 100755 --- a/dlls/winevulkan/make_vulkan +++ b/dlls/winevulkan/make_vulkan @@ -2439,6 +2439,36 @@ class VkRegistry(object): self.enums = OrderedDict(sorted(enums.items())) + def _process_require_enum(self, enum_elem, ext=None): + if "bitpos" in enum_elem.keys(): + # We need to add an extra value to an existing enum type. + # E.g. VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG to VkFormatFeatureFlagBits. + type_name = enum_elem.attrib["extends"] + enum = self.types[type_name]["data"] + enum.add(VkEnumValue(enum_elem.attrib["name"], 1 << int(enum_elem.attrib["bitpos"]), hex=True)) + + elif "offset" in enum_elem.keys(): + # Extensions promoted to Core, have the extension number as part + # of the enum value. Else retrieve from the extension tag. + if enum_elem.attrib.get("extnumber"): + ext_number = int(enum_elem.attrib.get("extnumber")) + else: + ext_number = int(ext.attrib["number"]) + offset = int(enum_elem.attrib["offset"]) + value = EXT_BASE + (ext_number - 1) * EXT_BLOCK_SIZE + offset + + # Deal with negative values. + direction = enum_elem.attrib.get("dir") + if direction is not None: + value = -value + + type_name = enum_elem.attrib["extends"] + enum = self.types[type_name]["data"] + enum.add(VkEnumValue(enum_elem.attrib["name"], value)) + + elif "value" in enum_elem.keys(): + self.consts.append(VkConstant(enum_elem.attrib.get("name"), enum_elem.attrib.get("value"))) + def _parse_extensions(self, root): """ Parse extensions section and pull in any types and commands for this extensioin. """ extensions = [] @@ -2489,43 +2519,9 @@ class VkRegistry(object): # different features (e.g. Vulkan 1.1). Parse each require section # separately, so we can skip sections we don't want. for require in ext.findall("require"): - feature = require.attrib.get("feature") - if feature == "VK_VERSION_1_1": - continue - # Extensions can add enum values to Core / extension enums, so add these. for enum_elem in require.findall("enum"): - if "bitpos" in enum_elem.keys(): - # We need to add an extra value to an existing enum type. - # E.g. VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG to VkFormatFeatureFlagBits. - type_name = enum_elem.attrib["extends"] - enum = self.types[type_name]["data"] - enum.add(VkEnumValue(enum_elem.attrib["name"], 1 << int(enum_elem.attrib["bitpos"]), hex=True)) - elif "offset" in enum_elem.keys(): - # Extensions promoted to Core, have the extension number as part - # of the enum value. Else retrieve from the extension tag. - if enum_elem.attrib.get("extnumber") is not None: - ext_number = int(enum_elem.attrib.get("extnumber")) - else: - ext_number = int(ext.attrib["number"]) - offset = int(enum_elem.attrib["offset"]) - value = EXT_BASE + (ext_number - 1) * EXT_BLOCK_SIZE + offset - - # Deal with negative values. - direction = enum_elem.attrib.get("dir") - if direction is not None: - value = -value - - type_name = enum_elem.attrib["extends"] - enum = self.types[type_name]["data"] - enum.add(VkEnumValue(enum_elem.attrib["name"], value)) - - elif "value" in enum_elem.keys(): - self.consts.append(VkConstant(enum_elem.attrib.get("name"), enum_elem.attrib.get("value"))) - continue - else: - # This seems to be used to pull in constants e.g. VK_MAX_DEVICE_GROUP_KHX - continue + self._process_require_enum(enum_elem, ext) for t in require.findall("type"): type_info = self.types[t.attrib["name"]]["data"] @@ -2533,6 +2529,10 @@ class VkRegistry(object): type_info = type_info.alias type_info.required = True + feature = require.attrib.get("feature") + if feature == "VK_VERSION_1_1": + continue + # Pull in any commands we need. We infer types to pull in from the command # as well. for command in require.findall("command"): @@ -2549,37 +2549,30 @@ class VkRegistry(object): def _parse_features(self, root): """ Parse the feature section, which describes Core commands and types needed. """ - # For now limit to 1.0 features as various 1.1 features need more work. - # In particular interop extensions promoted to Core. - requires = root.findall("./feature/[@name='VK_VERSION_1_0']/require") - - for require in requires: - LOGGER.info("Including features for {0}".format(require.attrib.get("comment"))) - for tag in require: - # Only deal with command. Other values which appear are enum and type for pulling in some - # constants and macros. Tricky to parse, so don't bother right now, we will generate them - # anyway for now. - if tag.tag == "comment": - continue - elif tag.tag == "command": - name = tag.attrib["name"] - self._mark_command_required(name) - elif tag.tag == "enum": - # We could pull in relevant constants here. Unfortunately - # this only gets half of them pulled in as others indirectly - # get pulled in through structures. Constants don't harm us, - # so don't bother. - pass - elif tag.tag == "type": - # Pull in types which may not have been pulled in through commands. - name = tag.attrib["name"] - - # Skip pull in for vk_platform.h for now. - if name == "vk_platform": + for feature in root.findall("./feature"): + feature_name = feature.attrib["name"] + for require in feature.findall("require"): + LOGGER.info("Including features for {0}".format(require.attrib.get("comment"))) + for tag in require: + if tag.tag == "comment": continue - - type_info = self.types[name] - type_info["data"].required = True + elif tag.tag == "command": + # For now limit to 1.0 features as various 1.1 features need more work. + if feature_name == "VK_VERSION_1_1": + continue + name = tag.attrib["name"] + self._mark_command_required(name) + elif tag.tag == "enum": + self._process_require_enum(tag) + elif tag.tag == "type": + name = tag.attrib["name"] + + # Skip pull in for vk_platform.h for now. + if name == "vk_platform": + continue + + type_info = self.types[name] + type_info["data"].required = True def _parse_types(self, root): """ Parse types section, which contains all data types e.g. structs, typedefs etcetera. """ diff --git a/include/wine/vulkan.h b/include/wine/vulkan.h index 1d07a077d322..c6e4c59bcb7f 100644 --- a/include/wine/vulkan.h +++ b/include/wine/vulkan.h @@ -139,6 +139,7 @@ #define VK_KHR_MAINTENANCE1_EXTENSION_NAME "VK_KHR_maintenance1" #define VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION 2 #define VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME "VK_KHR_push_descriptor" +#define VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR 1 #define VK_KHR_16BIT_STORAGE_SPEC_VERSION 1 #define VK_KHR_16BIT_STORAGE_EXTENSION_NAME "VK_KHR_16bit_storage" #define VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION 1 @@ -537,6 +538,7 @@ typedef enum VkBufferCreateFlagBits VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001, VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004, + VK_BUFFER_CREATE_PROTECTED_BIT = 0x00000008, VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7fffffff, } VkBufferCreateFlagBits; @@ -595,6 +597,7 @@ typedef enum VkCommandPoolCreateFlagBits { VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002, + VK_COMMAND_POOL_CREATE_PROTECTED_BIT = 0x00000004, VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7fffffff, } VkCommandPoolCreateFlagBits; @@ -661,6 +664,8 @@ typedef enum VkCullModeFlagBits typedef enum VkDependencyFlagBits { VK_DEPENDENCY_BY_REGION_BIT = 0x00000001, + VK_DEPENDENCY_VIEW_LOCAL_BIT = 0x00000002, + VK_DEPENDENCY_DEVICE_GROUP_BIT = 0x00000004, VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7fffffff, } VkDependencyFlagBits; @@ -700,8 +705,18 @@ typedef enum VkDescriptorUpdateTemplateType VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_MAX_ENUM = 0x7fffffff, } VkDescriptorUpdateTemplateType; +typedef enum VkDeviceGroupPresentModeFlagBitsKHR +{ + VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR = 0x00000001, + VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR = 0x00000002, + VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR = 0x00000004, + VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR = 0x00000008, + VK_DEVICE_GROUP_PRESENT_MODE_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff, +} VkDeviceGroupPresentModeFlagBitsKHR; + typedef enum VkDeviceQueueCreateFlagBits { + VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT = 0x00000001, VK_DEVICE_QUEUE_CREATE_FLAG_BITS_MAX_ENUM = 0x7fffffff, } VkDeviceQueueCreateFlagBits; @@ -729,12 +744,71 @@ typedef enum VkDynamicState VK_DYNAMIC_STATE_MAX_ENUM = 0x7fffffff, } VkDynamicState; +typedef enum VkExternalFenceFeatureFlagBits +{ + VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT = 0x00000001, + VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT = 0x00000002, + VK_EXTERNAL_FENCE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7fffffff, +} VkExternalFenceFeatureFlagBits; + +typedef enum VkExternalFenceHandleTypeFlagBits +{ + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001, + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002, + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004, + VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000008, + VK_EXTERNAL_FENCE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7fffffff, +} VkExternalFenceHandleTypeFlagBits; + +typedef enum VkExternalMemoryFeatureFlagBits +{ + VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT = 0x00000001, + VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT = 0x00000002, + VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT = 0x00000004, + VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7fffffff, +} VkExternalMemoryFeatureFlagBits; + +typedef enum VkExternalMemoryHandleTypeFlagBits +{ + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT = 0x00000008, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT = 0x00000010, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT = 0x00000020, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT = 0x00000040, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7fffffff, +} VkExternalMemoryHandleTypeFlagBits; + +typedef enum VkExternalSemaphoreFeatureFlagBits +{ + VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT = 0x00000001, + VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT = 0x00000002, + VK_EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7fffffff, +} VkExternalSemaphoreFeatureFlagBits; + +typedef enum VkExternalSemaphoreHandleTypeFlagBits +{ + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT = 0x00000008, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000010, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7fffffff, +} VkExternalSemaphoreHandleTypeFlagBits; + typedef enum VkFenceCreateFlagBits { VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001, VK_FENCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7fffffff, } VkFenceCreateFlagBits; +typedef enum VkFenceImportFlagBits +{ + VK_FENCE_IMPORT_TEMPORARY_BIT = 0x00000001, + VK_FENCE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7fffffff, +} VkFenceImportFlagBits; + typedef enum VkFilter { VK_FILTER_NEAREST = 0, @@ -938,6 +1012,40 @@ typedef enum VkFormat VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005, VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006, VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007, + VK_FORMAT_G8B8G8R8_422_UNORM = 1000156000, + VK_FORMAT_B8G8R8G8_422_UNORM = 1000156001, + VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM = 1000156002, + VK_FORMAT_G8_B8R8_2PLANE_420_UNORM = 1000156003, + VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM = 1000156004, + VK_FORMAT_G8_B8R8_2PLANE_422_UNORM = 1000156005, + VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM = 1000156006, + VK_FORMAT_R10X6_UNORM_PACK16 = 1000156007, + VK_FORMAT_R10X6G10X6_UNORM_2PACK16 = 1000156008, + VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 = 1000156009, + VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 = 1000156010, + VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 = 1000156011, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 = 1000156012, + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 = 1000156013, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 = 1000156014, + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 = 1000156015, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 = 1000156016, + VK_FORMAT_R12X4_UNORM_PACK16 = 1000156017, + VK_FORMAT_R12X4G12X4_UNORM_2PACK16 = 1000156018, + VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 = 1000156019, + VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 = 1000156020, + VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 = 1000156021, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 = 1000156022, + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 = 1000156023, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 = 1000156024, + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 = 1000156025, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 = 1000156026, + VK_FORMAT_G16B16G16R16_422_UNORM = 1000156027, + VK_FORMAT_B16G16R16G16_422_UNORM = 1000156028, + VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM = 1000156029, + VK_FORMAT_G16_B16R16_2PLANE_420_UNORM = 1000156030, + VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM = 1000156031, + VK_FORMAT_G16_B16R16_2PLANE_422_UNORM = 1000156032, + VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM = 1000156033, VK_FORMAT_MAX_ENUM = 0x7fffffff, } VkFormat; @@ -957,7 +1065,16 @@ typedef enum VkFormatFeatureFlagBits VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800, VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000, VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = 0x00002000, + VK_FORMAT_FEATURE_TRANSFER_SRC_BIT = 0x00004000, + VK_FORMAT_FEATURE_TRANSFER_DST_BIT = 0x00008000, VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT = 0x00010000, + VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT = 0x00020000, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT = 0x00040000, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT = 0x00080000, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT = 0x00100000, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT = 0x00200000, + VK_FORMAT_FEATURE_DISJOINT_BIT = 0x00400000, + VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT = 0x00800000, VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = 0x7fffffff, } VkFormatFeatureFlagBits; @@ -974,6 +1091,9 @@ typedef enum VkImageAspectFlagBits VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002, VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004, VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008, + VK_IMAGE_ASPECT_PLANE_0_BIT = 0x00000010, + VK_IMAGE_ASPECT_PLANE_1_BIT = 0x00000020, + VK_IMAGE_ASPECT_PLANE_2_BIT = 0x00000040, VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM = 0x7fffffff, } VkImageAspectFlagBits; @@ -984,6 +1104,13 @@ typedef enum VkImageCreateFlagBits VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004, VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008, VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010, + VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT = 0x00000020, + VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT = 0x00000040, + VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT = 0x00000080, + VK_IMAGE_CREATE_EXTENDED_USAGE_BIT = 0x00000100, + VK_IMAGE_CREATE_DISJOINT_BIT = 0x00000200, + VK_IMAGE_CREATE_ALIAS_BIT = 0x00000400, + VK_IMAGE_CREATE_PROTECTED_BIT = 0x00000800, VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT = 0x00001000, VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7fffffff, } VkImageCreateFlagBits; @@ -1000,6 +1127,8 @@ typedef enum VkImageLayout VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7, VK_IMAGE_LAYOUT_PREINITIALIZED = 8, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002, + VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL = 1000117000, + VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL = 1000117001, VK_IMAGE_LAYOUT_MAX_ENUM = 0x7fffffff, } VkImageLayout; @@ -1077,9 +1206,16 @@ typedef enum VkLogicOp VK_LOGIC_OP_MAX_ENUM = 0x7fffffff, } VkLogicOp; +typedef enum VkMemoryAllocateFlagBits +{ + VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT = 0x00000001, + VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM = 0x7fffffff, +} VkMemoryAllocateFlagBits; + typedef enum VkMemoryHeapFlagBits { VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001, + VK_MEMORY_HEAP_MULTI_INSTANCE_BIT = 0x00000002, VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 0x7fffffff, } VkMemoryHeapFlagBits; @@ -1090,6 +1226,7 @@ typedef enum VkMemoryPropertyFlagBits VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004, VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008, VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010, + VK_MEMORY_PROPERTY_PROTECTED_BIT = 0x00000020, VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = 0x7fffffff, } VkMemoryPropertyFlagBits; @@ -1123,10 +1260,21 @@ typedef enum VkObjectType VK_OBJECT_TYPE_COMMAND_POOL = 25, VK_OBJECT_TYPE_SURFACE_KHR = 1000000000, VK_OBJECT_TYPE_SWAPCHAIN_KHR = 1000001000, + VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE = 1000085000, + VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION = 1000156000, VK_OBJECT_TYPE_VALIDATION_CACHE_EXT = 1000160000, VK_OBJECT_TYPE_MAX_ENUM = 0x7fffffff, } VkObjectType; +typedef enum VkPeerMemoryFeatureFlagBits +{ + VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT = 0x00000001, + VK_PEER_MEMORY_FEATURE_COPY_DST_BIT = 0x00000002, + VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT = 0x00000004, + VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT = 0x00000008, + VK_PEER_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7fffffff, +} VkPeerMemoryFeatureFlagBits; + typedef enum VkPhysicalDeviceType { VK_PHYSICAL_DEVICE_TYPE_OTHER = 0, @@ -1155,6 +1303,8 @@ typedef enum VkPipelineCreateFlagBits VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001, VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002, VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004, + VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 0x00000008, + VK_PIPELINE_CREATE_DISPATCH_BASE = 0x00000010, VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7fffffff, } VkPipelineCreateFlagBits; @@ -1257,6 +1407,7 @@ typedef enum VkQueueFlagBits VK_QUEUE_COMPUTE_BIT = 0x00000002, VK_QUEUE_TRANSFER_BIT = 0x00000004, VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008, + VK_QUEUE_PROTECTED_BIT = 0x00000010, VK_QUEUE_FLAG_BITS_MAX_ENUM = 0x7fffffff, } VkQueueFlagBits; @@ -1280,6 +1431,8 @@ typedef enum VkResult { VK_ERROR_NOT_PERMITTED_EXT = -1000174001, VK_ERROR_FRAGMENTATION_EXT = -1000161000, + VK_ERROR_INVALID_EXTERNAL_HANDLE = -1000072003, + VK_ERROR_OUT_OF_POOL_MEMORY = -1000069000, VK_ERROR_INVALID_SHADER_NV = -1000012000, VK_ERROR_OUT_OF_DATE_KHR = -1000001004, VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001, @@ -1359,6 +1512,12 @@ typedef enum VkSamplerYcbcrRange VK_SAMPLER_YCBCR_RANGE_MAX_ENUM = 0x7fffffff, } VkSamplerYcbcrRange; +typedef enum VkSemaphoreImportFlagBits +{ + VK_SEMAPHORE_IMPORT_TEMPORARY_BIT = 0x00000001, + VK_SEMAPHORE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7fffffff, +} VkSemaphoreImportFlagBits; + typedef enum VkShaderInfoTypeAMD { VK_SHADER_INFO_TYPE_STATISTICS_AMD = 0, @@ -1473,16 +1632,68 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001, VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002, VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD = 1000041000, + VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO = 1000053000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES = 1000053001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES = 1000053002, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000, VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 = 1000059000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 = 1000059001, + VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 = 1000059002, + VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 = 1000059003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 = 1000059004, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 = 1000059005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 = 1000059006, + VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2 = 1000059007, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 = 1000059008, + VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO = 1000060000, + VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO = 1000060003, + VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO = 1000060004, + VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO = 1000060005, + VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO = 1000060006, + VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR = 1000060007, + VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR = 1000060008, + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR = 1000060009, + VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR = 1000060010, + VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR = 1000060011, + VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR = 1000060012, + VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO = 1000060013, + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO = 1000060014, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = 1000063000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES = 1000070000, + VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO = 1000070001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO = 1000071000, + VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES = 1000071001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO = 1000071002, + VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES = 1000071003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES = 1000071004, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO = 1000072000, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO = 1000072001, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO = 1000072002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO = 1000076000, + VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES = 1000076001, + VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO = 1000077000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = 1000080000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES = 1000083000, VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000, + VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO = 1000085000, VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV = 1000087000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES = 1000094000, VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV = 1000098000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT = 1000099000, VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT = 1000099001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT = 1000101000, VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT = 1000101001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO = 1000112000, + VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES = 1000112001, + VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO = 1000113000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES = 1000117000, + VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO = 1000117001, + VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO = 1000117002, + VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO = 1000117003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = 1000120000, + VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS = 1000127000, + VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO = 1000127001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT = 1000130000, VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT = 1000130001, VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT = 1000143000, @@ -1490,12 +1701,29 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT = 1000143002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT = 1000143003, VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT = 1000143004, + VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO = 1000145000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES = 1000145001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES = 1000145002, + VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 = 1000145003, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2 = 1000146000, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2 = 1000146001, + VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 = 1000146002, + VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2 = 1000146003, + VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 = 1000146004, VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR = 1000147000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT = 1000148000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT = 1000148001, VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT = 1000148002, VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV = 1000149000, VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV = 1000152000, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO = 1000156000, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO = 1000156001, + VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO = 1000156002, + VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO = 1000156003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES = 1000156004, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES = 1000156005, + VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO = 1000157000, + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO = 1000157001, VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160000, VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160001, VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT = 1000161000, @@ -1503,6 +1731,8 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT = 1000161002, VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT = 1000161003, VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT = 1000161004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES = 1000168000, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT = 1000168001, VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT = 1000174000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD = 1000185000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT = 1000190000, @@ -1510,6 +1740,20 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_MAX_ENUM = 0x7fffffff, } VkStructureType; +typedef enum VkSubgroupFeatureFlagBits +{ + VK_SUBGROUP_FEATURE_BASIC_BIT = 0x00000001, + VK_SUBGROUP_FEATURE_VOTE_BIT = 0x00000002, + VK_SUBGROUP_FEATURE_ARITHMETIC_BIT = 0x00000004, + VK_SUBGROUP_FEATURE_BALLOT_BIT = 0x00000008, + VK_SUBGROUP_FEATURE_SHUFFLE_BIT = 0x00000010, + VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT = 0x00000020, + VK_SUBGROUP_FEATURE_CLUSTERED_BIT = 0x00000040, + VK_SUBGROUP_FEATURE_QUAD_BIT = 0x00000080, + VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV = 0x00000100, + VK_SUBGROUP_FEATURE_FLAG_BITS_MAX_ENUM = 0x7fffffff, +} VkSubgroupFeatureFlagBits; + typedef enum VkSubpassContents { VK_SUBPASS_CONTENTS_INLINE = 0, @@ -1538,6 +1782,8 @@ typedef enum VkSurfaceTransformFlagBitsKHR typedef enum VkSwapchainCreateFlagBitsKHR { + VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = 0x00000001, + VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR = 0x00000002, VK_SWAPCHAIN_CREATE_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff, } VkSwapchainCreateFlagBitsKHR; @@ -1611,6 +1857,17 @@ typedef void* (VKAPI_PTR * PFN_vkReallocationFunction)( typedef void (VKAPI_PTR * PFN_vkVoidFunction)( void); +typedef struct VkAcquireNextImageInfoKHR +{ + VkStructureType sType; + const void *pNext; + VkSwapchainKHR WINE_VK_ALIGN(8) swapchain; + uint64_t WINE_VK_ALIGN(8) timeout; + VkSemaphore WINE_VK_ALIGN(8) semaphore; + VkFence WINE_VK_ALIGN(8) fence; + uint32_t deviceMask; +} VkAcquireNextImageInfoKHR; + typedef struct VkApplicationInfo { VkStructureType sType; @@ -1634,6 +1891,14 @@ typedef struct VkBaseInStructure const struct VkBaseInStructure *pNext; } VkBaseInStructure; +typedef struct VkBindBufferMemoryDeviceGroupInfo +{ + VkStructureType sType; + const void *pNext; + uint32_t deviceIndexCount; + const uint32_t *pDeviceIndices; +} VkBindBufferMemoryDeviceGroupInfo; + typedef struct VkBindBufferMemoryInfo { VkStructureType sType; @@ -1643,14 +1908,12 @@ typedef struct VkBindBufferMemoryInfo VkDeviceSize WINE_VK_ALIGN(8) memoryOffset; } VkBindBufferMemoryInfo; -typedef struct VkBindImageMemoryInfo +typedef struct VkBindImagePlaneMemoryInfo { VkStructureType sType; const void *pNext; - VkImage WINE_VK_ALIGN(8) image; - VkDeviceMemory WINE_VK_ALIGN(8) memory; - VkDeviceSize WINE_VK_ALIGN(8) memoryOffset; -} VkBindImageMemoryInfo; + VkImageAspectFlagBits planeAspect; +} VkBindImagePlaneMemoryInfo; typedef struct VkBufferCopy { @@ -1766,6 +2029,15 @@ typedef struct VkDescriptorSetVariableDescriptorCountLayoutSupportEXT uint32_t maxVariableDescriptorCount; } VkDescriptorSetVariableDescriptorCountLayoutSupportEXT; +typedef struct VkDeviceGroupPresentInfoKHR +{ + VkStructureType sType; + const void *pNext; + uint32_t swapchainCount; + const uint32_t *pDeviceMasks; + VkDeviceGroupPresentModeFlagBitsKHR mode; +} VkDeviceGroupPresentInfoKHR; + typedef struct VkDeviceQueueCreateInfo { VkStructureType sType; @@ -1776,6 +2048,15 @@ typedef struct VkDeviceQueueCreateInfo const float *pQueuePriorities; } VkDeviceQueueCreateInfo; +typedef struct VkDeviceQueueInfo2 +{ + VkStructureType sType; + const void *pNext; + VkDeviceQueueCreateFlags flags; + uint32_t queueFamilyIndex; + uint32_t queueIndex; +} VkDeviceQueueInfo2; + typedef struct VkDrawIndirectCommand { uint32_t vertexCount; @@ -1784,12 +2065,40 @@ typedef struct VkDrawIndirectCommand uint32_t firstInstance; } VkDrawIndirectCommand; +typedef struct VkExportFenceCreateInfo +{ + VkStructureType sType; + const void *pNext; + VkExternalFenceHandleTypeFlags handleTypes; +} VkExportFenceCreateInfo; + +typedef struct VkExportSemaphoreCreateInfo +{ + VkStructureType sType; + const void *pNext; + VkExternalSemaphoreHandleTypeFlags handleTypes; +} VkExportSemaphoreCreateInfo; + typedef struct VkExtent2D { uint32_t width; uint32_t height; } VkExtent2D; +typedef struct VkExternalMemoryBufferCreateInfo +{ + VkStructureType sType; + const void *pNext; + VkExternalMemoryHandleTypeFlags handleTypes; +} VkExternalMemoryBufferCreateInfo; + +typedef struct VkExternalMemoryImageCreateInfo +{ + VkStructureType sType; + const void *pNext; + VkExternalMemoryHandleTypeFlags handleTypes; +} VkExternalMemoryImageCreateInfo; + typedef struct VkExternalMemoryImageCreateInfoNV { VkStructureType sType; @@ -1961,6 +2270,29 @@ typedef struct VkPhysicalDeviceDescriptorIndexingPropertiesEXT uint32_t maxDescriptorSetUpdateAfterBindInputAttachments; } VkPhysicalDeviceDescriptorIndexingPropertiesEXT; +typedef struct VkPhysicalDeviceExternalBufferInfo +{ + VkStructureType sType; + const void *pNext; + VkBufferCreateFlags flags; + VkBufferUsageFlags usage; + VkExternalMemoryHandleTypeFlagBits handleType; +} VkPhysicalDeviceExternalBufferInfo; + +typedef struct VkPhysicalDeviceExternalFenceInfo +{ + VkStructureType sType; + const void *pNext; + VkExternalFenceHandleTypeFlagBits handleType; +} VkPhysicalDeviceExternalFenceInfo; + +typedef struct VkPhysicalDeviceExternalImageFormatInfo +{ + VkStructureType sType; + const void *pNext; + VkExternalMemoryHandleTypeFlagBits handleType; +} VkPhysicalDeviceExternalImageFormatInfo; + typedef struct VkPhysicalDeviceMaintenance3Properties { VkStructureType sType; @@ -1984,6 +2316,13 @@ typedef struct VkPhysicalDevicePointClippingProperties VkPointClippingBehavior pointClippingBehavior; } VkPhysicalDevicePointClippingProperties; +typedef struct VkPhysicalDeviceProtectedMemoryProperties +{ + VkStructureType sType; + void *pNext; + VkBool32 protectedNoFault; +} VkPhysicalDeviceProtectedMemoryProperties; + typedef struct VkPhysicalDeviceSampleLocationsPropertiesEXT { VkStructureType sType; @@ -2140,6 +2479,13 @@ typedef struct VkPresentInfoKHR VkResult *pResults; } VkPresentInfoKHR; +typedef struct VkProtectedSubmitInfo +{ + VkStructureType sType; + const void *pNext; + VkBool32 protectedSubmit; +} VkProtectedSubmitInfo; + typedef struct VkQueryPoolCreateInfo { VkStructureType sType; @@ -2310,6 +2656,15 @@ typedef struct VkBaseOutStructure struct VkBaseOutStructure *pNext; } VkBaseOutStructure; +typedef struct VkBindImageMemoryInfo +{ + VkStructureType sType; + const void *pNext; + VkImage WINE_VK_ALIGN(8) image; + VkDeviceMemory WINE_VK_ALIGN(8) memory; + VkDeviceSize WINE_VK_ALIGN(8) memoryOffset; +} VkBindImageMemoryInfo; + typedef struct VkBufferCreateInfo { VkStructureType sType; @@ -2393,6 +2748,33 @@ typedef struct VkDescriptorUpdateTemplateEntry size_t stride; } VkDescriptorUpdateTemplateEntry; +typedef struct VkDeviceGroupCommandBufferBeginInfo +{ + VkStructureType sType; + const void *pNext; + uint32_t deviceMask; +} VkDeviceGroupCommandBufferBeginInfo; + +typedef struct VkDeviceGroupPresentCapabilitiesKHR +{ + VkStructureType sType; + const void *pNext; + uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE]; + VkDeviceGroupPresentModeFlagsKHR modes; +} VkDeviceGroupPresentCapabilitiesKHR; + +typedef struct VkDeviceGroupSubmitInfo +{ + VkStructureType sType; + const void *pNext; + uint32_t waitSemaphoreCount; + const uint32_t *pWaitSemaphoreDeviceIndices; + uint32_t commandBufferCount; + const uint32_t *pCommandBufferDeviceMasks; + uint32_t signalSemaphoreCount; + const uint32_t *pSignalSemaphoreDeviceIndices; +} VkDeviceGroupSubmitInfo; + typedef struct VkDeviceQueueGlobalPriorityCreateInfoEXT { VkStructureType sType; @@ -2407,25 +2789,49 @@ typedef struct VkEventCreateInfo VkEventCreateFlags flags; } VkEventCreateInfo; +typedef struct VkExportMemoryAllocateInfo +{ + VkStructureType sType; + const void *pNext; + VkExternalMemoryHandleTypeFlags handleTypes; +} VkExportMemoryAllocateInfo; + typedef struct VkExtensionProperties { char extensionName[VK_MAX_EXTENSION_NAME_SIZE]; uint32_t specVersion; } VkExtensionProperties; -typedef struct VkFenceCreateInfo +typedef struct VkExternalFenceProperties { VkStructureType sType; - const void *pNext; - VkFenceCreateFlags flags; -} VkFenceCreateInfo; + void *pNext; + VkExternalFenceHandleTypeFlags exportFromImportedHandleTypes; + VkExternalFenceHandleTypeFlags compatibleHandleTypes; + VkExternalFenceFeatureFlags externalFenceFeatures; +} VkExternalFenceProperties; -typedef struct VkFormatProperties2 +typedef struct VkExternalSemaphoreProperties { VkStructureType sType; void *pNext; - VkFormatProperties formatProperties; -} VkFormatProperties2; + VkExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes; + VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes; + VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures; +} VkExternalSemaphoreProperties; + +typedef struct VkFramebufferCreateInfo +{ + VkStructureType sType; + const void *pNext; + VkFramebufferCreateFlags flags; + VkRenderPass WINE_VK_ALIGN(8) renderPass; + uint32_t attachmentCount; + const VkImageView *pAttachments; + uint32_t width; + uint32_t height; + uint32_t layers; +} VkFramebufferCreateInfo; typedef struct VkImageMemoryBarrier { @@ -2441,6 +2847,13 @@ typedef struct VkImageMemoryBarrier VkImageSubresourceRange subresourceRange; } VkImageMemoryBarrier; +typedef struct VkImageSwapchainCreateInfoKHR +{ + VkStructureType sType; + const void *pNext; + VkSwapchainKHR WINE_VK_ALIGN(8) swapchain; +} VkImageSwapchainCreateInfoKHR; + typedef struct VkInputAttachmentAspectReference { uint32_t subpass; @@ -2568,6 +2981,15 @@ typedef struct VkPhysicalDeviceFeatures VkBool32 inheritedQueries; } VkPhysicalDeviceFeatures; +typedef struct VkPhysicalDeviceGroupProperties +{ + VkStructureType sType; + void *pNext; + uint32_t physicalDeviceCount; + VkPhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE]; + VkBool32 subsetAllocation; +} VkPhysicalDeviceGroupProperties; + typedef struct VkPhysicalDeviceImageFormatInfo2 { VkStructureType sType; @@ -2588,6 +3010,13 @@ typedef struct VkPhysicalDeviceMultiviewFeatures VkBool32 multiviewTessellationShader; } VkPhysicalDeviceMultiviewFeatures; +typedef struct VkPhysicalDeviceProtectedMemoryFeatures +{ + VkStructureType sType; + void *pNext; + VkBool32 protectedMemory; +} VkPhysicalDeviceProtectedMemoryFeatures; + typedef struct VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT { VkStructureType sType; @@ -2596,6 +3025,23 @@ typedef struct VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT VkBool32 filterMinmaxImageComponentMapping; } VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT; +typedef struct VkPhysicalDeviceShaderDrawParameterFeatures +{ + VkStructureType sType; + void *pNext; + VkBool32 shaderDrawParameters; +} VkPhysicalDeviceShaderDrawParameterFeatures; + +typedef struct VkPhysicalDeviceSubgroupProperties +{ + VkStructureType sType; + void *pNext; + uint32_t subgroupSize; + VkShaderStageFlags supportedStages; + VkSubgroupFeatureFlags supportedOperations; + VkBool32 quadOperationsInAllStages; +} VkPhysicalDeviceSubgroupProperties; + typedef struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT { VkStructureType sType; @@ -2777,6 +3223,16 @@ typedef struct VkAttachmentSampleLocationsEXT VkSampleLocationsInfoEXT sampleLocationsInfo; } VkAttachmentSampleLocationsEXT; +typedef struct VkBindImageMemoryDeviceGroupInfo +{ + VkStructureType sType; + const void *pNext; + uint32_t deviceIndexCount; + const uint32_t *pDeviceIndices; + uint32_t splitInstanceBindRegionCount; + const VkRect2D *pSplitInstanceBindRegions; +} VkBindImageMemoryDeviceGroupInfo; + typedef struct VkBufferViewCreateInfo { VkStructureType sType; @@ -2833,6 +3289,23 @@ typedef struct VkDescriptorUpdateTemplateCreateInfo uint32_t set; } VkDescriptorUpdateTemplateCreateInfo; +typedef struct VkDeviceGroupBindSparseInfo +{ + VkStructureType sType; + const void *pNext; + uint32_t resourceDeviceIndex; + uint32_t memoryDeviceIndex; +} VkDeviceGroupBindSparseInfo; + +typedef struct VkDeviceGroupRenderPassBeginInfo +{ + VkStructureType sType; + const void *pNext; + uint32_t deviceMask; + uint32_t deviceRenderAreaCount; + const VkRect2D *pDeviceRenderAreas; +} VkDeviceGroupRenderPassBeginInfo; + typedef struct VkDispatchIndirectCommand { uint32_t x; @@ -2863,18 +3336,12 @@ typedef struct VkExtent3D uint32_t depth; } VkExtent3D; -typedef struct VkFramebufferCreateInfo +typedef struct VkFenceCreateInfo { VkStructureType sType; const void *pNext; - VkFramebufferCreateFlags flags; - VkRenderPass WINE_VK_ALIGN(8) renderPass; - uint32_t attachmentCount; - const VkImageView *pAttachments; - uint32_t width; - uint32_t height; - uint32_t layers; -} VkFramebufferCreateInfo; + VkFenceCreateFlags flags; +} VkFenceCreateInfo; typedef struct VkImageCreateInfo { @@ -2903,6 +3370,14 @@ typedef struct VkImageSubresourceLayers uint32_t layerCount; } VkImageSubresourceLayers; +typedef struct VkMemoryAllocateFlagsInfo +{ + VkStructureType sType; + const void *pNext; + VkMemoryAllocateFlags flags; + uint32_t deviceMask; +} VkMemoryAllocateFlagsInfo; + typedef struct VkMemoryRequirements2 { VkStructureType sType; @@ -2917,6 +3392,24 @@ typedef struct VkPhysicalDeviceDiscardRectanglePropertiesEXT uint32_t maxDiscardRectangles; } VkPhysicalDeviceDiscardRectanglePropertiesEXT; +typedef struct VkPhysicalDeviceExternalSemaphoreInfo +{ + VkStructureType sType; + const void *pNext; + VkExternalSemaphoreHandleTypeFlagBits handleType; +} VkPhysicalDeviceExternalSemaphoreInfo; + +typedef struct VkPhysicalDeviceIDProperties +{ + VkStructureType sType; + void *pNext; + uint8_t deviceUUID[VK_UUID_SIZE]; + uint8_t driverUUID[VK_UUID_SIZE]; + uint8_t deviceLUID[VK_LUID_SIZE]; + uint32_t deviceNodeMask; + VkBool32 deviceLUIDValid; +} VkPhysicalDeviceIDProperties; + typedef struct VkPhysicalDevicePushDescriptorPropertiesKHR { VkStructureType sType; @@ -3062,12 +3555,13 @@ typedef struct VkAttachmentDescription VkImageLayout finalLayout; } VkAttachmentDescription; -typedef struct VkBindImagePlaneMemoryInfo +typedef struct VkBindImageMemorySwapchainInfoKHR { VkStructureType sType; const void *pNext; - VkImageAspectFlagBits planeAspect; -} VkBindImagePlaneMemoryInfo; + VkSwapchainKHR WINE_VK_ALIGN(8) swapchain; + uint32_t imageIndex; +} VkBindImageMemorySwapchainInfoKHR; typedef struct VkBufferImageCopy { @@ -3086,6 +3580,21 @@ typedef struct VkDescriptorSetLayoutSupport VkBool32 supported; } VkDescriptorSetLayoutSupport; +typedef struct VkDeviceGroupDeviceCreateInfo +{ + VkStructureType sType; + const void *pNext; + uint32_t physicalDeviceCount; + const VkPhysicalDevice *pPhysicalDevices; +} VkDeviceGroupDeviceCreateInfo; + +typedef struct VkExternalMemoryProperties +{ + VkExternalMemoryFeatureFlags externalMemoryFeatures; + VkExternalMemoryHandleTypeFlags exportFromImportedHandleTypes; + VkExternalMemoryHandleTypeFlags compatibleHandleTypes; +} VkExternalMemoryProperties; + typedef struct VkImageBlit { VkImageSubresourceLayers srcSubresource; @@ -3257,6 +3766,20 @@ typedef struct VkDescriptorImageInfo VkImageLayout imageLayout; } VkDescriptorImageInfo; +typedef struct VkDeviceGroupSwapchainCreateInfoKHR +{ + VkStructureType sType; + const void *pNext; + VkDeviceGroupPresentModeFlagsKHR modes; +} VkDeviceGroupSwapchainCreateInfoKHR; + +typedef struct VkExternalImageFormatProperties +{ + VkStructureType sType; + void *pNext; + VkExternalMemoryProperties externalMemoryProperties; +} VkExternalImageFormatProperties; + typedef struct VkGraphicsPipelineCreateInfo { VkStructureType sType; @@ -3497,12 +4020,35 @@ typedef struct VkDeviceCreateInfo const VkPhysicalDeviceFeatures *pEnabledFeatures; } VkDeviceCreateInfo; -typedef struct VkImageViewUsageCreateInfo +typedef struct VkExternalBufferProperties { VkStructureType sType; - const void *pNext; - VkImageUsageFlags usage; -} VkImageViewUsageCreateInfo; + void *pNext; + VkExternalMemoryProperties externalMemoryProperties; +} VkExternalBufferProperties; + +typedef struct VkImageCopy +{ + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffset; + VkExtent3D extent; +} VkImageCopy; + +typedef struct VkMemoryHeap +{ + VkDeviceSize WINE_VK_ALIGN(8) size; + VkMemoryHeapFlags flags; +} VkMemoryHeap; + +typedef struct VkPhysicalDeviceMemoryProperties +{ + uint32_t memoryTypeCount; + VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES]; + uint32_t memoryHeapCount; + VkMemoryHeap WINE_VK_ALIGN(8) memoryHeaps[VK_MAX_MEMORY_HEAPS]; +} VkPhysicalDeviceMemoryProperties; typedef struct VkPhysicalDeviceProperties2 { @@ -3555,14 +4101,12 @@ typedef struct VkComputePipelineCreateInfo int32_t basePipelineIndex; } VkComputePipelineCreateInfo; -typedef struct VkImageCopy +typedef struct VkFormatProperties2 { - VkImageSubresourceLayers srcSubresource; - VkOffset3D srcOffset; - VkImageSubresourceLayers dstSubresource; - VkOffset3D dstOffset; - VkExtent3D extent; -} VkImageCopy; + VkStructureType sType; + void *pNext; + VkFormatProperties formatProperties; +} VkFormatProperties2; typedef struct VkPipelineDiscardRectangleStateCreateInfoEXT { @@ -3585,19 +4129,12 @@ typedef struct VkSubpassDependency VkDependencyFlags dependencyFlags; } VkSubpassDependency; -typedef struct VkPresentRegionsKHR +typedef struct VkPhysicalDeviceMemoryProperties2 { VkStructureType sType; - const void *pNext; - uint32_t swapchainCount; - const VkPresentRegionKHR *pRegions; -} VkPresentRegionsKHR; - -typedef struct VkMemoryHeap -{ - VkDeviceSize WINE_VK_ALIGN(8) size; - VkMemoryHeapFlags flags; -} VkMemoryHeap; + void *pNext; + VkPhysicalDeviceMemoryProperties WINE_VK_ALIGN(8) memoryProperties; +} VkPhysicalDeviceMemoryProperties2; typedef struct VkRenderPassCreateInfo { @@ -3612,20 +4149,20 @@ typedef struct VkRenderPassCreateInfo const VkSubpassDependency *pDependencies; } VkRenderPassCreateInfo; -typedef struct VkPhysicalDeviceMemoryProperties +typedef struct VkImageViewUsageCreateInfo { - uint32_t memoryTypeCount; - VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES]; - uint32_t memoryHeapCount; - VkMemoryHeap WINE_VK_ALIGN(8) memoryHeaps[VK_MAX_MEMORY_HEAPS]; -} VkPhysicalDeviceMemoryProperties; + VkStructureType sType; + const void *pNext; + VkImageUsageFlags usage; +} VkImageViewUsageCreateInfo; -typedef struct VkPhysicalDeviceMemoryProperties2 +typedef struct VkPresentRegionsKHR { VkStructureType sType; - void *pNext; - VkPhysicalDeviceMemoryProperties WINE_VK_ALIGN(8) memoryProperties; -} VkPhysicalDeviceMemoryProperties2; + const void *pNext; + uint32_t swapchainCount; + const VkPresentRegionKHR *pRegions; +} VkPresentRegionsKHR; typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImageKHR)(VkDevice, VkSwapchainKHR, uint64_t, VkSemaphore, VkFence, uint32_t *); typedef VkResult (VKAPI_PTR *PFN_vkAllocateCommandBuffers)(VkDevice, const VkCommandBufferAllocateInfo *, VkCommandBuffer *); -- 2.16.4

1 0

[PATCH 2/8] winevulkan: Pull in required types into Vulkan header.
by Józef Kucia 12 Jul '18

12 Jul '18

Not all types are referenced by commands. Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/winevulkan/make_vulkan | 24 +- include/wine/vulkan.h | 1069 ++++++++++++++++++++++++++++++++++--------- 2 files changed, 870 insertions(+), 223 deletions(-) diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan index 944b015a6368..70aa5ee0d8d9 100755 --- a/dlls/winevulkan/make_vulkan +++ b/dlls/winevulkan/make_vulkan @@ -188,7 +188,7 @@ class Direction(Enum): class VkBaseType(object): - def __init__(self, name, _type, alias=False, requires=None): + def __init__(self, name, _type, alias=None, requires=None): """ Vulkan base type class. VkBaseType is mostly used by Vulkan to define its own @@ -213,7 +213,7 @@ class VkBaseType(object): return "typedef {0} {1};\n".format(self.type, self.name) def is_alias(self): - return self.alias + return bool(self.alias) class VkConstant(object): @@ -291,7 +291,7 @@ class VkDefine(object): class VkEnum(object): - def __init__(self, name, values, alias=False): + def __init__(self, name, values, alias=None): self.name = name self.values = values self.required = False @@ -300,7 +300,7 @@ class VkEnum(object): @staticmethod def from_alias(enum, alias): name = enum.attrib.get("name") - return VkEnum(name, alias.values) + return VkEnum(name, alias.values, alias=alias) @staticmethod def from_xml(enum): @@ -353,7 +353,7 @@ class VkEnum(object): return text def is_alias(self): - return self.alias + return bool(self.alias) class VkEnumValue(object): @@ -1477,7 +1477,7 @@ class VkParam(object): class VkStruct(Sequence): """ Class which represents the type union and struct. """ - def __init__(self, name, members, returnedonly, alias=False, union=False): + def __init__(self, name, members, returnedonly, alias=None, union=False): self.name = name self.members = members self.returnedonly = returnedonly @@ -1495,7 +1495,7 @@ class VkStruct(Sequence): @staticmethod def from_alias(struct, alias): name = struct.attrib.get("name") - return VkStruct(name, alias.members, alias.returnedonly, alias=True) + return VkStruct(name, alias.members, alias.returnedonly, alias=alias) @staticmethod def from_xml(struct): @@ -1602,7 +1602,7 @@ class VkStruct(Sequence): return text def is_alias(self): - return self.alias + return bool(self.alias) def needs_alignment(self): """ Check if structure needs alignment for 64-bit data. @@ -2527,6 +2527,12 @@ class VkRegistry(object): # This seems to be used to pull in constants e.g. VK_MAX_DEVICE_GROUP_KHX continue + for t in require.findall("type"): + type_info = self.types[t.attrib["name"]]["data"] + if type_info.is_alias(): + type_info = type_info.alias + type_info.required = True + # Pull in any commands we need. We infer types to pull in from the command # as well. for command in require.findall("command"): @@ -2678,7 +2684,7 @@ class VkRegistry(object): alias = t.attrib.get("alias") if type_info["category"] == "bitmask": - bitmask = VkBaseType(type_info["name"], alias, alias=True) + bitmask = VkBaseType(type_info["name"], alias, alias=self.types[alias]["data"]) bitmasks.append(bitmask) type_info["data"] = bitmask diff --git a/include/wine/vulkan.h b/include/wine/vulkan.h index d85ba8d65371..1d07a077d322 100644 --- a/include/wine/vulkan.h +++ b/include/wine/vulkan.h @@ -513,6 +513,14 @@ typedef enum VkBlendOp VK_BLEND_OP_MAX_ENUM = 0x7fffffff, } VkBlendOp; +typedef enum VkBlendOverlapEXT +{ + VK_BLEND_OVERLAP_UNCORRELATED_EXT = 0, + VK_BLEND_OVERLAP_DISJOINT_EXT = 1, + VK_BLEND_OVERLAP_CONJOINT_EXT = 2, + VK_BLEND_OVERLAP_EXT_MAX_ENUM = 0x7fffffff, +} VkBlendOverlapEXT; + typedef enum VkBorderColor { VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0, @@ -624,6 +632,23 @@ typedef enum VkCompositeAlphaFlagBitsKHR VK_COMPOSITE_ALPHA_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff, } VkCompositeAlphaFlagBitsKHR; +typedef enum VkConservativeRasterizationModeEXT +{ + VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT = 0, + VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT = 1, + VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT = 2, + VK_CONSERVATIVE_RASTERIZATION_MODE_EXT_MAX_ENUM = 0x7fffffff, +} VkConservativeRasterizationModeEXT; + +typedef enum VkCoverageModulationModeNV +{ + VK_COVERAGE_MODULATION_MODE_NONE_NV = 0, + VK_COVERAGE_MODULATION_MODE_RGB_NV = 1, + VK_COVERAGE_MODULATION_MODE_ALPHA_NV = 2, + VK_COVERAGE_MODULATION_MODE_RGBA_NV = 3, + VK_COVERAGE_MODULATION_MODE_NV_MAX_ENUM = 0x7fffffff, +} VkCoverageModulationModeNV; + typedef enum VkCullModeFlagBits { VK_CULL_MODE_NONE = 0, @@ -680,6 +705,13 @@ typedef enum VkDeviceQueueCreateFlagBits VK_DEVICE_QUEUE_CREATE_FLAG_BITS_MAX_ENUM = 0x7fffffff, } VkDeviceQueueCreateFlagBits; +typedef enum VkDiscardRectangleModeEXT +{ + VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT = 0, + VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT = 1, + VK_DISCARD_RECTANGLE_MODE_EXT_MAX_ENUM = 0x7fffffff, +} VkDiscardRectangleModeEXT; + typedef enum VkDynamicState { VK_DYNAMIC_STATE_VIEWPORT = 0, @@ -1148,6 +1180,13 @@ typedef enum VkPipelineStageFlagBits VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7fffffff, } VkPipelineStageFlagBits; +typedef enum VkPointClippingBehavior +{ + VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES = 0, + VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY = 1, + VK_POINT_CLIPPING_BEHAVIOR_MAX_ENUM = 0x7fffffff, +} VkPointClippingBehavior; + typedef enum VkPolygonMode { VK_POLYGON_MODE_FILL = 0, @@ -1221,6 +1260,22 @@ typedef enum VkQueueFlagBits VK_QUEUE_FLAG_BITS_MAX_ENUM = 0x7fffffff, } VkQueueFlagBits; +typedef enum VkQueueGlobalPriorityEXT +{ + VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT = 128, + VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT = 256, + VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT = 512, + VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT = 1024, + VK_QUEUE_GLOBAL_PRIORITY_EXT_MAX_ENUM = 0x7fffffff, +} VkQueueGlobalPriorityEXT; + +typedef enum VkRasterizationOrderAMD +{ + VK_RASTERIZATION_ORDER_STRICT_AMD = 0, + VK_RASTERIZATION_ORDER_RELAXED_AMD = 1, + VK_RASTERIZATION_ORDER_AMD_MAX_ENUM = 0x7fffffff, +} VkRasterizationOrderAMD; + typedef enum VkResult { VK_ERROR_NOT_PERMITTED_EXT = -1000174001, @@ -1279,6 +1334,14 @@ typedef enum VkSamplerMipmapMode VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7fffffff, } VkSamplerMipmapMode; +typedef enum VkSamplerReductionModeEXT +{ + VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT = 0, + VK_SAMPLER_REDUCTION_MODE_MIN_EXT = 1, + VK_SAMPLER_REDUCTION_MODE_MAX_EXT = 2, + VK_SAMPLER_REDUCTION_MODE_EXT_MAX_ENUM = 0x7fffffff, +} VkSamplerReductionModeEXT; + typedef enum VkSamplerYcbcrModelConversion { VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY = 0, @@ -1488,6 +1551,19 @@ typedef enum VkSystemAllocationScope VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7fffffff, } VkSystemAllocationScope; +typedef enum VkTessellationDomainOrigin +{ + VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT = 0, + VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT = 1, + VK_TESSELLATION_DOMAIN_ORIGIN_MAX_ENUM = 0x7fffffff, +} VkTessellationDomainOrigin; + +typedef enum VkValidationCacheHeaderVersionEXT +{ + VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT = 1, + VK_VALIDATION_CACHE_HEADER_VERSION_EXT_MAX_ENUM = 0x7fffffff, +} VkValidationCacheHeaderVersionEXT; + typedef enum VkVertexInputRate { VK_VERTEX_INPUT_RATE_VERTEX = 0, @@ -1495,6 +1571,19 @@ typedef enum VkVertexInputRate VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7fffffff, } VkVertexInputRate; +typedef enum VkViewportCoordinateSwizzleNV +{ + VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV = 0, + VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV = 1, + VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV = 2, + VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV = 3, + VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV = 4, + VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV = 5, + VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV = 6, + VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV = 7, + VK_VIEWPORT_COORDINATE_SWIZZLE_NV_MAX_ENUM = 0x7fffffff, +} VkViewportCoordinateSwizzleNV; + typedef void* (VKAPI_PTR * PFN_vkAllocationFunction)( void *pUserData, size_t size, @@ -1632,6 +1721,13 @@ typedef struct VkCopyDescriptorSet uint32_t descriptorCount; } VkCopyDescriptorSet; +typedef struct VkDedicatedAllocationImageCreateInfoNV +{ + VkStructureType sType; + const void *pNext; + VkBool32 dedicatedAllocation; +} VkDedicatedAllocationImageCreateInfoNV; + typedef struct VkDescriptorBufferInfo { VkBuffer WINE_VK_ALIGN(8) buffer; @@ -1663,6 +1759,13 @@ typedef struct VkDescriptorSetLayoutCreateInfo const VkDescriptorSetLayoutBinding *pBindings; } VkDescriptorSetLayoutCreateInfo; +typedef struct VkDescriptorSetVariableDescriptorCountLayoutSupportEXT +{ + VkStructureType sType; + void *pNext; + uint32_t maxVariableDescriptorCount; +} VkDescriptorSetVariableDescriptorCountLayoutSupportEXT; + typedef struct VkDeviceQueueCreateInfo { VkStructureType sType; @@ -1687,6 +1790,13 @@ typedef struct VkExtent2D uint32_t height; } VkExtent2D; +typedef struct VkExternalMemoryImageCreateInfoNV +{ + VkStructureType sType; + const void *pNext; + VkExternalMemoryHandleTypeFlagsNV handleTypes; +} VkExternalMemoryImageCreateInfoNV; + typedef struct VkFormatProperties { VkFormatFeatureFlags linearTilingFeatures; @@ -1694,6 +1804,14 @@ typedef struct VkFormatProperties VkFormatFeatureFlags bufferFeatures; } VkFormatProperties; +typedef struct VkImageFormatListCreateInfoKHR +{ + VkStructureType sType; + const void *pNext; + uint32_t viewFormatCount; + const VkFormat *pViewFormats; +} VkImageFormatListCreateInfoKHR; + typedef struct VkImageMemoryRequirementsInfo2 { VkStructureType sType; @@ -1701,6 +1819,13 @@ typedef struct VkImageMemoryRequirementsInfo2 VkImage WINE_VK_ALIGN(8) image; } VkImageMemoryRequirementsInfo2; +typedef struct VkImagePlaneMemoryRequirementsInfo +{ + VkStructureType sType; + const void *pNext; + VkImageAspectFlagBits planeAspect; +} VkImagePlaneMemoryRequirementsInfo; + typedef struct VkImageSparseMemoryRequirementsInfo2 { VkStructureType sType; @@ -1775,6 +1900,128 @@ typedef struct VkOffset3D int32_t z; } VkOffset3D; +typedef struct VkPhysicalDevice16BitStorageFeatures +{ + VkStructureType sType; + void *pNext; + VkBool32 storageBuffer16BitAccess; + VkBool32 uniformAndStorageBuffer16BitAccess; + VkBool32 storagePushConstant16; + VkBool32 storageInputOutput16; +} VkPhysicalDevice16BitStorageFeatures; + +typedef struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT +{ + VkStructureType sType; + void *pNext; + VkBool32 advancedBlendCoherentOperations; +} VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT; + +typedef struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT +{ + VkStructureType sType; + void *pNext; + float primitiveOverestimationSize; + float maxExtraPrimitiveOverestimationSize; + float extraPrimitiveOverestimationSizeGranularity; + VkBool32 primitiveUnderestimation; + VkBool32 conservativePointAndLineRasterization; + VkBool32 degenerateTrianglesRasterized; + VkBool32 degenerateLinesRasterized; + VkBool32 fullyCoveredFragmentShaderInputVariable; + VkBool32 conservativeRasterizationPostDepthCoverage; +} VkPhysicalDeviceConservativeRasterizationPropertiesEXT; + +typedef struct VkPhysicalDeviceDescriptorIndexingPropertiesEXT +{ + VkStructureType sType; + void *pNext; + uint32_t maxUpdateAfterBindDescriptorsInAllPools; + VkBool32 shaderUniformBufferArrayNonUniformIndexingNative; + VkBool32 shaderSampledImageArrayNonUniformIndexingNative; + VkBool32 shaderStorageBufferArrayNonUniformIndexingNative; + VkBool32 shaderStorageImageArrayNonUniformIndexingNative; + VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative; + VkBool32 robustBufferAccessUpdateAfterBind; + VkBool32 quadDivergentImplicitLod; + uint32_t maxPerStageDescriptorUpdateAfterBindSamplers; + uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers; + uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages; + uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments; + uint32_t maxPerStageUpdateAfterBindResources; + uint32_t maxDescriptorSetUpdateAfterBindSamplers; + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers; + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers; + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; + uint32_t maxDescriptorSetUpdateAfterBindSampledImages; + uint32_t maxDescriptorSetUpdateAfterBindStorageImages; + uint32_t maxDescriptorSetUpdateAfterBindInputAttachments; +} VkPhysicalDeviceDescriptorIndexingPropertiesEXT; + +typedef struct VkPhysicalDeviceMaintenance3Properties +{ + VkStructureType sType; + void *pNext; + uint32_t maxPerSetDescriptors; + VkDeviceSize WINE_VK_ALIGN(8) maxMemoryAllocationSize; +} VkPhysicalDeviceMaintenance3Properties; + +typedef struct VkPhysicalDeviceMultiviewProperties +{ + VkStructureType sType; + void *pNext; + uint32_t maxMultiviewViewCount; + uint32_t maxMultiviewInstanceIndex; +} VkPhysicalDeviceMultiviewProperties; + +typedef struct VkPhysicalDevicePointClippingProperties +{ + VkStructureType sType; + void *pNext; + VkPointClippingBehavior pointClippingBehavior; +} VkPhysicalDevicePointClippingProperties; + +typedef struct VkPhysicalDeviceSampleLocationsPropertiesEXT +{ + VkStructureType sType; + void *pNext; + VkSampleCountFlags sampleLocationSampleCounts; + VkExtent2D maxSampleLocationGridSize; + float sampleLocationCoordinateRange[2]; + uint32_t sampleLocationSubPixelBits; + VkBool32 variableSampleLocations; +} VkPhysicalDeviceSampleLocationsPropertiesEXT; + +typedef struct VkPhysicalDeviceSamplerYcbcrConversionFeatures +{ + VkStructureType sType; + void *pNext; + VkBool32 samplerYcbcrConversion; +} VkPhysicalDeviceSamplerYcbcrConversionFeatures; + +typedef struct VkPhysicalDeviceShaderCorePropertiesAMD +{ + VkStructureType sType; + void *pNext; + uint32_t shaderEngineCount; + uint32_t shaderArraysPerEngineCount; + uint32_t computeUnitsPerShaderArray; + uint32_t simdPerComputeUnit; + uint32_t wavefrontsPerSimd; + uint32_t wavefrontSize; + uint32_t sgprsPerSimd; + uint32_t minSgprAllocation; + uint32_t maxSgprAllocation; + uint32_t sgprAllocationGranularity; + uint32_t vgprsPerSimd; + uint32_t minVgprAllocation; + uint32_t maxVgprAllocation; + uint32_t vgprAllocationGranularity; +} VkPhysicalDeviceShaderCorePropertiesAMD; + typedef struct VkPhysicalDeviceSparseImageFormatInfo2 { VkStructureType sType; @@ -1816,14 +2063,25 @@ typedef struct VkPipelineColorBlendAttachmentState VkColorComponentFlags colorWriteMask; } VkPipelineColorBlendAttachmentState; -typedef struct VkPipelineInputAssemblyStateCreateInfo +typedef struct VkPipelineCoverageModulationStateCreateInfoNV { VkStructureType sType; const void *pNext; - VkPipelineInputAssemblyStateCreateFlags flags; - VkPrimitiveTopology topology; - VkBool32 primitiveRestartEnable; -} VkPipelineInputAssemblyStateCreateInfo; + VkPipelineCoverageModulationStateCreateFlagsNV flags; + VkCoverageModulationModeNV coverageModulationMode; + VkBool32 coverageModulationTableEnable; + uint32_t coverageModulationTableCount; + const float *pCoverageModulationTable; +} VkPipelineCoverageModulationStateCreateInfoNV; + +typedef struct VkPipelineDynamicStateCreateInfo +{ + VkStructureType sType; + const void *pNext; + VkPipelineDynamicStateCreateFlags flags; + uint32_t dynamicStateCount; + const VkDynamicState *pDynamicStates; +} VkPipelineDynamicStateCreateInfo; typedef struct VkPipelineMultisampleStateCreateInfo { @@ -1855,6 +2113,13 @@ typedef struct VkPipelineRasterizationStateCreateInfo float lineWidth; } VkPipelineRasterizationStateCreateInfo; +typedef struct VkPipelineTessellationDomainOriginStateCreateInfo +{ + VkStructureType sType; + const void *pNext; + VkTessellationDomainOrigin domainOrigin; +} VkPipelineTessellationDomainOriginStateCreateInfo; + typedef struct VkPipelineTessellationStateCreateInfo { VkStructureType sType; @@ -1875,12 +2140,21 @@ typedef struct VkPresentInfoKHR VkResult *pResults; } VkPresentInfoKHR; -typedef struct VkPushConstantRange +typedef struct VkQueryPoolCreateInfo { - VkShaderStageFlags stageFlags; - uint32_t offset; - uint32_t size; -} VkPushConstantRange; + VkStructureType sType; + const void *pNext; + VkQueryPoolCreateFlags flags; + VkQueryType queryType; + uint32_t queryCount; + VkQueryPipelineStatisticFlags pipelineStatistics; +} VkQueryPoolCreateInfo; + +typedef struct VkSampleLocationEXT +{ + float x; + float y; +} VkSampleLocationEXT; typedef struct VkSamplerCreateInfo { @@ -1918,6 +2192,20 @@ typedef struct VkSamplerYcbcrConversionCreateInfo VkBool32 forceExplicitReconstruction; } VkSamplerYcbcrConversionCreateInfo; +typedef struct VkSamplerYcbcrConversionImageFormatProperties +{ + VkStructureType sType; + void *pNext; + uint32_t combinedImageSamplerDescriptorCount; +} VkSamplerYcbcrConversionImageFormatProperties; + +typedef struct VkSamplerYcbcrConversionInfo +{ + VkStructureType sType; + const void *pNext; + VkSamplerYcbcrConversion WINE_VK_ALIGN(8) conversion; +} VkSamplerYcbcrConversionInfo; + typedef struct VkSemaphoreCreateInfo { VkStructureType sType; @@ -1925,6 +2213,13 @@ typedef struct VkSemaphoreCreateInfo VkSemaphoreCreateFlags flags; } VkSemaphoreCreateInfo; +typedef struct VkShaderModuleValidationCacheCreateInfoEXT +{ + VkStructureType sType; + const void *pNext; + VkValidationCacheEXT WINE_VK_ALIGN(8) validationCache; +} VkShaderModuleValidationCacheCreateInfoEXT; + typedef struct VkSparseMemoryBind { VkDeviceSize WINE_VK_ALIGN(8) resourceOffset; @@ -1977,6 +2272,13 @@ typedef struct VkSubresourceLayout VkDeviceSize WINE_VK_ALIGN(8) depthPitch; } VkSubresourceLayout; +typedef struct VkTextureLODGatherFormatPropertiesAMD +{ + VkStructureType sType; + void *pNext; + VkBool32 supportsTextureGatherLODBiasAMD; +} VkTextureLODGatherFormatPropertiesAMD; + typedef struct VkVertexInputBindingDescription { uint32_t binding; @@ -1984,6 +2286,14 @@ typedef struct VkVertexInputBindingDescription VkVertexInputRate inputRate; } VkVertexInputBindingDescription; +typedef struct VkViewportSwizzleNV +{ + VkViewportCoordinateSwizzleNV x; + VkViewportCoordinateSwizzleNV y; + VkViewportCoordinateSwizzleNV z; + VkViewportCoordinateSwizzleNV w; +} VkViewportSwizzleNV; + typedef struct VkAllocationCallbacks { void *pUserData; @@ -1994,6 +2304,12 @@ typedef struct VkAllocationCallbacks PFN_vkInternalFreeNotification pfnInternalFree; } VkAllocationCallbacks; +typedef struct VkBaseOutStructure +{ + VkStructureType sType; + struct VkBaseOutStructure *pNext; +} VkBaseOutStructure; + typedef struct VkBufferCreateInfo { VkStructureType sType; @@ -2033,6 +2349,14 @@ typedef struct VkCommandBufferBeginInfo const VkCommandBufferInheritanceInfo *pInheritanceInfo; } VkCommandBufferBeginInfo; +typedef struct VkDedicatedAllocationMemoryAllocateInfoNV +{ + VkStructureType sType; + const void *pNext; + VkImage WINE_VK_ALIGN(8) image; + VkBuffer WINE_VK_ALIGN(8) buffer; +} VkDedicatedAllocationMemoryAllocateInfoNV; + typedef struct VkDescriptorPoolCreateInfo { VkStructureType sType; @@ -2043,6 +2367,22 @@ typedef struct VkDescriptorPoolCreateInfo const VkDescriptorPoolSize *pPoolSizes; } VkDescriptorPoolCreateInfo; +typedef struct VkDescriptorSetLayoutBindingFlagsCreateInfoEXT +{ + VkStructureType sType; + const void *pNext; + uint32_t bindingCount; + const VkDescriptorBindingFlagsEXT *pBindingFlags; +} VkDescriptorSetLayoutBindingFlagsCreateInfoEXT; + +typedef struct VkDescriptorSetVariableDescriptorCountAllocateInfoEXT +{ + VkStructureType sType; + const void *pNext; + uint32_t descriptorSetCount; + const uint32_t *pDescriptorCounts; +} VkDescriptorSetVariableDescriptorCountAllocateInfoEXT; + typedef struct VkDescriptorUpdateTemplateEntry { uint32_t dstBinding; @@ -2053,6 +2393,13 @@ typedef struct VkDescriptorUpdateTemplateEntry size_t stride; } VkDescriptorUpdateTemplateEntry; +typedef struct VkDeviceQueueGlobalPriorityCreateInfoEXT +{ + VkStructureType sType; + const void *pNext; + VkQueueGlobalPriorityEXT globalPriority; +} VkDeviceQueueGlobalPriorityCreateInfoEXT; + typedef struct VkEventCreateInfo { VkStructureType sType; @@ -2094,6 +2441,13 @@ typedef struct VkImageMemoryBarrier VkImageSubresourceRange subresourceRange; } VkImageMemoryBarrier; +typedef struct VkInputAttachmentAspectReference +{ + uint32_t subpass; + uint32_t inputAttachmentIndex; + VkImageAspectFlags aspectMask; +} VkInputAttachmentAspectReference; + typedef struct VkMemoryAllocateInfo { VkStructureType sType; @@ -2102,6 +2456,14 @@ typedef struct VkMemoryAllocateInfo uint32_t memoryTypeIndex; } VkMemoryAllocateInfo; +typedef struct VkMemoryDedicatedRequirements +{ + VkStructureType sType; + void *pNext; + VkBool32 prefersDedicatedAllocation; + VkBool32 requiresDedicatedAllocation; +} VkMemoryDedicatedRequirements; + typedef struct VkMemoryRequirements { VkDeviceSize WINE_VK_ALIGN(8) size; @@ -2121,6 +2483,32 @@ typedef struct VkOffset2D int32_t y; } VkOffset2D; +typedef struct VkPhysicalDeviceDescriptorIndexingFeaturesEXT +{ + VkStructureType sType; + void *pNext; + VkBool32 shaderInputAttachmentArrayDynamicIndexing; + VkBool32 shaderUniformTexelBufferArrayDynamicIndexing; + VkBool32 shaderStorageTexelBufferArrayDynamicIndexing; + VkBool32 shaderUniformBufferArrayNonUniformIndexing; + VkBool32 shaderSampledImageArrayNonUniformIndexing; + VkBool32 shaderStorageBufferArrayNonUniformIndexing; + VkBool32 shaderStorageImageArrayNonUniformIndexing; + VkBool32 shaderInputAttachmentArrayNonUniformIndexing; + VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing; + VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing; + VkBool32 descriptorBindingUniformBufferUpdateAfterBind; + VkBool32 descriptorBindingSampledImageUpdateAfterBind; + VkBool32 descriptorBindingStorageImageUpdateAfterBind; + VkBool32 descriptorBindingStorageBufferUpdateAfterBind; + VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind; + VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind; + VkBool32 descriptorBindingUpdateUnusedWhilePending; + VkBool32 descriptorBindingPartiallyBound; + VkBool32 descriptorBindingVariableDescriptorCount; + VkBool32 runtimeDescriptorArray; +} VkPhysicalDeviceDescriptorIndexingFeaturesEXT; + typedef struct VkPhysicalDeviceFeatures { VkBool32 robustBufferAccess; @@ -2191,6 +2579,30 @@ typedef struct VkPhysicalDeviceImageFormatInfo2 VkImageCreateFlags flags; } VkPhysicalDeviceImageFormatInfo2; +typedef struct VkPhysicalDeviceMultiviewFeatures +{ + VkStructureType sType; + void *pNext; + VkBool32 multiview; + VkBool32 multiviewGeometryShader; + VkBool32 multiviewTessellationShader; +} VkPhysicalDeviceMultiviewFeatures; + +typedef struct VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT +{ + VkStructureType sType; + void *pNext; + VkBool32 filterMinmaxSingleComponentFormats; + VkBool32 filterMinmaxImageComponentMapping; +} VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT; + +typedef struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT +{ + VkStructureType sType; + void *pNext; + uint32_t maxVertexAttribDivisor; +} VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT; + typedef struct VkPipelineColorBlendStateCreateInfo { VkStructureType sType; @@ -2203,24 +2615,32 @@ typedef struct VkPipelineColorBlendStateCreateInfo float blendConstants[4]; } VkPipelineColorBlendStateCreateInfo; -typedef struct VkPipelineDynamicStateCreateInfo +typedef struct VkPipelineInputAssemblyStateCreateInfo { VkStructureType sType; const void *pNext; - VkPipelineDynamicStateCreateFlags flags; - uint32_t dynamicStateCount; - const VkDynamicState *pDynamicStates; -} VkPipelineDynamicStateCreateInfo; + VkPipelineInputAssemblyStateCreateFlags flags; + VkPrimitiveTopology topology; + VkBool32 primitiveRestartEnable; +} VkPipelineInputAssemblyStateCreateInfo; -typedef struct VkQueryPoolCreateInfo +typedef struct VkPipelineRasterizationConservativeStateCreateInfoEXT { VkStructureType sType; const void *pNext; - VkQueryPoolCreateFlags flags; - VkQueryType queryType; - uint32_t queryCount; - VkQueryPipelineStatisticFlags pipelineStatistics; -} VkQueryPoolCreateInfo; + VkPipelineRasterizationConservativeStateCreateFlagsEXT flags; + VkConservativeRasterizationModeEXT conservativeRasterizationMode; + float extraPrimitiveOverestimationSize; +} VkPipelineRasterizationConservativeStateCreateInfoEXT; + +typedef struct VkPipelineViewportSwizzleStateCreateInfoNV +{ + VkStructureType sType; + const void *pNext; + VkPipelineViewportSwizzleStateCreateFlagsNV flags; + uint32_t viewportCount; + const VkViewportSwizzleNV *pViewportSwizzles; +} VkPipelineViewportSwizzleStateCreateInfoNV; typedef struct VkRect2D { @@ -2239,11 +2659,32 @@ typedef struct VkRenderPassBeginInfo const VkClearValue *pClearValues; } VkRenderPassBeginInfo; -typedef struct VkSampleLocationEXT +typedef struct VkRenderPassInputAttachmentAspectCreateInfo { - float x; - float y; -} VkSampleLocationEXT; + VkStructureType sType; + const void *pNext; + uint32_t aspectReferenceCount; + const VkInputAttachmentAspectReference *pAspectReferences; +} VkRenderPassInputAttachmentAspectCreateInfo; + +typedef struct VkSampleLocationsInfoEXT +{ + VkStructureType sType; + const void *pNext; + VkSampleCountFlagBits sampleLocationsPerPixel; + VkExtent2D sampleLocationGridSize; + uint32_t sampleLocationsCount; + const VkSampleLocationEXT *pSampleLocations; +} VkSampleLocationsInfoEXT; + +typedef struct VkShaderModuleCreateInfo +{ + VkStructureType sType; + const void *pNext; + VkShaderModuleCreateFlags flags; + size_t codeSize; + const uint32_t *pCode; +} VkShaderModuleCreateInfo; typedef struct VkSparseBufferMemoryBindInfo { @@ -2270,6 +2711,12 @@ typedef struct VkStencilOpState uint32_t reference; } VkStencilOpState; +typedef struct VkSubpassSampleLocationsEXT +{ + uint32_t subpassIndex; + VkSampleLocationsInfoEXT sampleLocationsInfo; +} VkSubpassSampleLocationsEXT; + typedef struct VkSurfaceCapabilitiesKHR { uint32_t minImageCount; @@ -2324,11 +2771,11 @@ typedef struct VkViewport float maxDepth; } VkViewport; -typedef struct VkBaseOutStructure +typedef struct VkAttachmentSampleLocationsEXT { - VkStructureType sType; - struct VkBaseOutStructure *pNext; -} VkBaseOutStructure; + uint32_t attachmentIndex; + VkSampleLocationsInfoEXT sampleLocationsInfo; +} VkAttachmentSampleLocationsEXT; typedef struct VkBufferViewCreateInfo { @@ -2356,6 +2803,13 @@ typedef struct VkCommandPoolCreateInfo uint32_t queueFamilyIndex; } VkCommandPoolCreateInfo; +typedef struct VkDedicatedAllocationBufferCreateInfoNV +{ + VkStructureType sType; + const void *pNext; + VkBool32 dedicatedAllocation; +} VkDedicatedAllocationBufferCreateInfoNV; + typedef struct VkDescriptorSetAllocateInfo { VkStructureType sType; @@ -2395,6 +2849,13 @@ typedef struct VkDrawIndexedIndirectCommand uint32_t firstInstance; } VkDrawIndexedIndirectCommand; +typedef struct VkExportMemoryAllocateInfoNV +{ + VkStructureType sType; + const void *pNext; + VkExternalMemoryHandleTypeFlagsNV handleTypes; +} VkExportMemoryAllocateInfoNV; + typedef struct VkExtent3D { uint32_t width; @@ -2449,7 +2910,30 @@ typedef struct VkMemoryRequirements2 VkMemoryRequirements WINE_VK_ALIGN(8) memoryRequirements; } VkMemoryRequirements2; -typedef struct VkPipelineDepthStencilStateCreateInfo +typedef struct VkPhysicalDeviceDiscardRectanglePropertiesEXT +{ + VkStructureType sType; + void *pNext; + uint32_t maxDiscardRectangles; +} VkPhysicalDeviceDiscardRectanglePropertiesEXT; + +typedef struct VkPhysicalDevicePushDescriptorPropertiesKHR +{ + VkStructureType sType; + void *pNext; + uint32_t maxPushDescriptors; +} VkPhysicalDevicePushDescriptorPropertiesKHR; + +typedef struct VkPipelineColorBlendAdvancedStateCreateInfoEXT +{ + VkStructureType sType; + const void *pNext; + VkBool32 srcPremultiplied; + VkBool32 dstPremultiplied; + VkBlendOverlapEXT blendOverlap; +} VkPipelineColorBlendAdvancedStateCreateInfoEXT; + +typedef struct VkPipelineDepthStencilStateCreateInfo { VkStructureType sType; const void *pNext; @@ -2465,25 +2949,56 @@ typedef struct VkPipelineDepthStencilStateCreateInfo float maxDepthBounds; } VkPipelineDepthStencilStateCreateInfo; -typedef struct VkPipelineViewportStateCreateInfo +typedef struct VkPipelineRasterizationStateRasterizationOrderAMD { VkStructureType sType; const void *pNext; - VkPipelineViewportStateCreateFlags flags; - uint32_t viewportCount; - const VkViewport *pViewports; - uint32_t scissorCount; - const VkRect2D *pScissors; -} VkPipelineViewportStateCreateInfo; + VkRasterizationOrderAMD rasterizationOrder; +} VkPipelineRasterizationStateRasterizationOrderAMD; -typedef struct VkShaderModuleCreateInfo +typedef struct VkPipelineVertexInputStateCreateInfo { VkStructureType sType; const void *pNext; - VkShaderModuleCreateFlags flags; - size_t codeSize; - const uint32_t *pCode; -} VkShaderModuleCreateInfo; + VkPipelineVertexInputStateCreateFlags flags; + uint32_t vertexBindingDescriptionCount; + const VkVertexInputBindingDescription *pVertexBindingDescriptions; + uint32_t vertexAttributeDescriptionCount; + const VkVertexInputAttributeDescription *pVertexAttributeDescriptions; +} VkPipelineVertexInputStateCreateInfo; + +typedef struct VkPushConstantRange +{ + VkShaderStageFlags stageFlags; + uint32_t offset; + uint32_t size; +} VkPushConstantRange; + +typedef struct VkRectLayerKHR +{ + VkOffset2D offset; + VkExtent2D extent; + uint32_t layer; +} VkRectLayerKHR; + +typedef struct VkRenderPassMultiviewCreateInfo +{ + VkStructureType sType; + const void *pNext; + uint32_t subpassCount; + const uint32_t *pViewMasks; + uint32_t dependencyCount; + const int32_t *pViewOffsets; + uint32_t correlationMaskCount; + const uint32_t *pCorrelationMasks; +} VkRenderPassMultiviewCreateInfo; + +typedef struct VkSamplerReductionModeCreateInfoEXT +{ + VkStructureType sType; + const void *pNext; + VkSamplerReductionModeEXT reductionMode; +} VkSamplerReductionModeCreateInfoEXT; typedef struct VkSparseImageFormatProperties { @@ -2547,6 +3062,13 @@ typedef struct VkAttachmentDescription VkImageLayout finalLayout; } VkAttachmentDescription; +typedef struct VkBindImagePlaneMemoryInfo +{ + VkStructureType sType; + const void *pNext; + VkImageAspectFlagBits planeAspect; +} VkBindImagePlaneMemoryInfo; + typedef struct VkBufferImageCopy { VkDeviceSize WINE_VK_ALIGN(8) bufferOffset; @@ -2590,6 +3112,26 @@ typedef struct VkImageResolve VkExtent3D extent; } VkImageResolve; +typedef struct VkMemoryDedicatedAllocateInfo +{ + VkStructureType sType; + const void *pNext; + VkImage WINE_VK_ALIGN(8) image; + VkBuffer WINE_VK_ALIGN(8) buffer; +} VkMemoryDedicatedAllocateInfo; + +typedef struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT +{ + VkStructureType sType; + void *pNext; + uint32_t advancedBlendMaxColorAttachments; + VkBool32 advancedBlendIndependentBlend; + VkBool32 advancedBlendNonPremultipliedSrcColor; + VkBool32 advancedBlendNonPremultipliedDstColor; + VkBool32 advancedBlendCorrelatedOverlap; + VkBool32 advancedBlendAllOperations; +} VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT; + typedef struct VkPhysicalDeviceFeatures2 { VkStructureType sType; @@ -2597,6 +3139,26 @@ typedef struct VkPhysicalDeviceFeatures2 VkPhysicalDeviceFeatures features; } VkPhysicalDeviceFeatures2; +typedef struct VkPipelineCoverageToColorStateCreateInfoNV +{ + VkStructureType sType; + const void *pNext; + VkPipelineCoverageToColorStateCreateFlagsNV flags; + VkBool32 coverageToColorEnable; + uint32_t coverageToColorLocation; +} VkPipelineCoverageToColorStateCreateInfoNV; + +typedef struct VkPipelineLayoutCreateInfo +{ + VkStructureType sType; + const void *pNext; + VkPipelineLayoutCreateFlags flags; + uint32_t setLayoutCount; + const VkDescriptorSetLayout *pSetLayouts; + uint32_t pushConstantRangeCount; + const VkPushConstantRange *pPushConstantRanges; +} VkPipelineLayoutCreateInfo; + typedef struct VkPipelineShaderStageCreateInfo { VkStructureType sType; @@ -2608,94 +3170,49 @@ typedef struct VkPipelineShaderStageCreateInfo const VkSpecializationInfo *pSpecializationInfo; } VkPipelineShaderStageCreateInfo; -typedef struct VkSampleLocationsInfoEXT +typedef struct VkPipelineViewportStateCreateInfo { VkStructureType sType; const void *pNext; - VkSampleCountFlagBits sampleLocationsPerPixel; - VkExtent2D sampleLocationGridSize; - uint32_t sampleLocationsCount; - const VkSampleLocationEXT *pSampleLocations; -} VkSampleLocationsInfoEXT; - -typedef struct VkSparseImageMemoryBindInfo -{ - VkImage WINE_VK_ALIGN(8) image; - uint32_t bindCount; - const VkSparseImageMemoryBind *pBinds; -} VkSparseImageMemoryBindInfo; - -typedef struct VkSubpassDependency -{ - uint32_t srcSubpass; - uint32_t dstSubpass; - VkPipelineStageFlags srcStageMask; - VkPipelineStageFlags dstStageMask; - VkAccessFlags srcAccessMask; - VkAccessFlags dstAccessMask; - VkDependencyFlags dependencyFlags; -} VkSubpassDependency; - -typedef struct VkClearAttachment -{ - VkImageAspectFlags aspectMask; - uint32_t colorAttachment; - VkClearValue clearValue; -} VkClearAttachment; - -typedef struct VkDescriptorImageInfo -{ - VkSampler WINE_VK_ALIGN(8) sampler; - VkImageView WINE_VK_ALIGN(8) imageView; - VkImageLayout imageLayout; -} VkDescriptorImageInfo; - -typedef struct VkImageCopy -{ - VkImageSubresourceLayers srcSubresource; - VkOffset3D srcOffset; - VkImageSubresourceLayers dstSubresource; - VkOffset3D dstOffset; - VkExtent3D extent; -} VkImageCopy; + VkPipelineViewportStateCreateFlags flags; + uint32_t viewportCount; + const VkViewport *pViewports; + uint32_t scissorCount; + const VkRect2D *pScissors; +} VkPipelineViewportStateCreateInfo; -typedef struct VkMemoryHeap +typedef struct VkPresentRegionKHR { - VkDeviceSize WINE_VK_ALIGN(8) size; - VkMemoryHeapFlags flags; -} VkMemoryHeap; + uint32_t rectangleCount; + const VkRectLayerKHR *pRectangles; +} VkPresentRegionKHR; -typedef struct VkPhysicalDeviceMemoryProperties +typedef struct VkQueueFamilyProperties { - uint32_t memoryTypeCount; - VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES]; - uint32_t memoryHeapCount; - VkMemoryHeap WINE_VK_ALIGN(8) memoryHeaps[VK_MAX_MEMORY_HEAPS]; -} VkPhysicalDeviceMemoryProperties; + VkQueueFlags queueFlags; + uint32_t queueCount; + uint32_t timestampValidBits; + VkExtent3D minImageTransferGranularity; +} VkQueueFamilyProperties; -typedef struct VkPipelineVertexInputStateCreateInfo +typedef struct VkRenderPassSampleLocationsBeginInfoEXT { VkStructureType sType; const void *pNext; - VkPipelineVertexInputStateCreateFlags flags; - uint32_t vertexBindingDescriptionCount; - const VkVertexInputBindingDescription *pVertexBindingDescriptions; - uint32_t vertexAttributeDescriptionCount; - const VkVertexInputAttributeDescription *pVertexAttributeDescriptions; -} VkPipelineVertexInputStateCreateInfo; + uint32_t attachmentInitialSampleLocationsCount; + const VkAttachmentSampleLocationsEXT *pAttachmentInitialSampleLocations; + uint32_t postSubpassSampleLocationsCount; + const VkSubpassSampleLocationsEXT *pPostSubpassSampleLocations; +} VkRenderPassSampleLocationsBeginInfoEXT; -typedef struct VkRenderPassCreateInfo +typedef struct VkShaderResourceUsageAMD { - VkStructureType sType; - const void *pNext; - VkRenderPassCreateFlags flags; - uint32_t attachmentCount; - const VkAttachmentDescription *pAttachments; - uint32_t subpassCount; - const VkSubpassDescription *pSubpasses; - uint32_t dependencyCount; - const VkSubpassDependency *pDependencies; -} VkRenderPassCreateInfo; + uint32_t numUsedVgprs; + uint32_t numUsedSgprs; + uint32_t ldsSizePerLocalWorkGroup; + size_t ldsUsageSizeInBytes; + size_t scratchMemUsageInBytes; +} VkShaderResourceUsageAMD; typedef struct VkSparseImageFormatProperties2 { @@ -2704,80 +3221,18 @@ typedef struct VkSparseImageFormatProperties2 VkSparseImageFormatProperties properties; } VkSparseImageFormatProperties2; -typedef struct VkSurfaceFormatKHR -{ - VkFormat format; - VkColorSpaceKHR colorSpace; -} VkSurfaceFormatKHR; - -typedef struct VkWriteDescriptorSet -{ - VkStructureType sType; - const void *pNext; - VkDescriptorSet WINE_VK_ALIGN(8) dstSet; - uint32_t dstBinding; - uint32_t dstArrayElement; - uint32_t descriptorCount; - VkDescriptorType descriptorType; - const VkDescriptorImageInfo *pImageInfo; - const VkDescriptorBufferInfo *pBufferInfo; - const VkBufferView *pTexelBufferView; -} VkWriteDescriptorSet; - -typedef struct VkBindSparseInfo -{ - VkStructureType sType; - const void *pNext; - uint32_t waitSemaphoreCount; - const VkSemaphore *pWaitSemaphores; - uint32_t bufferBindCount; - const VkSparseBufferMemoryBindInfo *pBufferBinds; - uint32_t imageOpaqueBindCount; - const VkSparseImageOpaqueMemoryBindInfo *pImageOpaqueBinds; - uint32_t imageBindCount; - const VkSparseImageMemoryBindInfo *pImageBinds; - uint32_t signalSemaphoreCount; - const VkSemaphore *pSignalSemaphores; -} VkBindSparseInfo; - -typedef struct VkDeviceCreateInfo -{ - VkStructureType sType; - const void *pNext; - VkDeviceCreateFlags flags; - uint32_t queueCreateInfoCount; - const VkDeviceQueueCreateInfo *pQueueCreateInfos; - uint32_t enabledLayerCount; - const char * const*ppEnabledLayerNames; - uint32_t enabledExtensionCount; - const char * const*ppEnabledExtensionNames; - const VkPhysicalDeviceFeatures *pEnabledFeatures; -} VkDeviceCreateInfo; - -typedef struct VkImageFormatProperties2 -{ - VkStructureType sType; - void *pNext; - VkImageFormatProperties WINE_VK_ALIGN(8) imageFormatProperties; -} VkImageFormatProperties2; - -typedef struct VkPhysicalDeviceMemoryProperties2 +typedef struct VkSparseImageMemoryRequirements2 { VkStructureType sType; void *pNext; - VkPhysicalDeviceMemoryProperties WINE_VK_ALIGN(8) memoryProperties; -} VkPhysicalDeviceMemoryProperties2; + VkSparseImageMemoryRequirements WINE_VK_ALIGN(8) memoryRequirements; +} VkSparseImageMemoryRequirements2; -typedef struct VkPipelineLayoutCreateInfo +typedef struct VkSurfaceFormatKHR { - VkStructureType sType; - const void *pNext; - VkPipelineLayoutCreateFlags flags; - uint32_t setLayoutCount; - const VkDescriptorSetLayout *pSetLayouts; - uint32_t pushConstantRangeCount; - const VkPushConstantRange *pPushConstantRanges; -} VkPipelineLayoutCreateInfo; + VkFormat format; + VkColorSpaceKHR colorSpace; +} VkSurfaceFormatKHR; typedef struct VkWin32SurfaceCreateInfoKHR { @@ -2788,16 +3243,19 @@ typedef struct VkWin32SurfaceCreateInfoKHR HWND hwnd; } VkWin32SurfaceCreateInfoKHR; -typedef struct VkComputePipelineCreateInfo +typedef struct VkClearAttachment { - VkStructureType sType; - const void *pNext; - VkPipelineCreateFlags flags; - VkPipelineShaderStageCreateInfo WINE_VK_ALIGN(8) stage; - VkPipelineLayout WINE_VK_ALIGN(8) layout; - VkPipeline WINE_VK_ALIGN(8) basePipelineHandle; - int32_t basePipelineIndex; -} VkComputePipelineCreateInfo; + VkImageAspectFlags aspectMask; + uint32_t colorAttachment; + VkClearValue clearValue; +} VkClearAttachment; + +typedef struct VkDescriptorImageInfo +{ + VkSampler WINE_VK_ALIGN(8) sampler; + VkImageView WINE_VK_ALIGN(8) imageView; + VkImageLayout imageLayout; +} VkDescriptorImageInfo; typedef struct VkGraphicsPipelineCreateInfo { @@ -2822,6 +3280,25 @@ typedef struct VkGraphicsPipelineCreateInfo int32_t basePipelineIndex; } VkGraphicsPipelineCreateInfo; +typedef struct VkImageFormatProperties2 +{ + VkStructureType sType; + void *pNext; + VkImageFormatProperties WINE_VK_ALIGN(8) imageFormatProperties; +} VkImageFormatProperties2; + +typedef struct VkInstanceCreateInfo +{ + VkStructureType sType; + const void *pNext; + VkInstanceCreateFlags flags; + const VkApplicationInfo *pApplicationInfo; + uint32_t enabledLayerCount; + const char * const*ppEnabledLayerNames; + uint32_t enabledExtensionCount; + const char * const*ppEnabledExtensionNames; +} VkInstanceCreateInfo; + typedef struct VkPhysicalDeviceLimits { uint32_t maxImageDimension1D; @@ -2932,21 +3409,6 @@ typedef struct VkPhysicalDeviceLimits VkDeviceSize WINE_VK_ALIGN(8) nonCoherentAtomSize; } VkPhysicalDeviceLimits; -typedef struct VkQueueFamilyProperties -{ - VkQueueFlags queueFlags; - uint32_t queueCount; - uint32_t timestampValidBits; - VkExtent3D minImageTransferGranularity; -} VkQueueFamilyProperties; - -typedef struct VkSparseImageMemoryRequirements2 -{ - VkStructureType sType; - void *pNext; - VkSparseImageMemoryRequirements WINE_VK_ALIGN(8) memoryRequirements; -} VkSparseImageMemoryRequirements2; - typedef struct VkPhysicalDeviceProperties { uint32_t apiVersion; @@ -2960,6 +3422,31 @@ typedef struct VkPhysicalDeviceProperties VkPhysicalDeviceSparseProperties sparseProperties; } VkPhysicalDeviceProperties; +typedef struct VkPhysicalDeviceVariablePointerFeatures +{ + VkStructureType sType; + void *pNext; + VkBool32 variablePointersStorageBuffer; + VkBool32 variablePointers; +} VkPhysicalDeviceVariablePointerFeatures; + +typedef struct VkPipelineSampleLocationsStateCreateInfoEXT +{ + VkStructureType sType; + const void *pNext; + VkBool32 sampleLocationsEnable; + VkSampleLocationsInfoEXT sampleLocationsInfo; +} VkPipelineSampleLocationsStateCreateInfoEXT; + +typedef struct VkPipelineViewportWScalingStateCreateInfoNV +{ + VkStructureType sType; + const void *pNext; + VkBool32 viewportWScalingEnable; + uint32_t viewportCount; + const VkViewportWScalingNV *pViewportWScalings; +} VkPipelineViewportWScalingStateCreateInfoNV; + typedef struct VkQueueFamilyProperties2 { VkStructureType sType; @@ -2967,17 +3454,55 @@ typedef struct VkQueueFamilyProperties2 VkQueueFamilyProperties queueFamilyProperties; } VkQueueFamilyProperties2; -typedef struct VkInstanceCreateInfo +typedef struct VkSparseImageMemoryBindInfo +{ + VkImage WINE_VK_ALIGN(8) image; + uint32_t bindCount; + const VkSparseImageMemoryBind *pBinds; +} VkSparseImageMemoryBindInfo; + +typedef struct VkVertexInputBindingDivisorDescriptionEXT +{ + uint32_t binding; + uint32_t divisor; +} VkVertexInputBindingDivisorDescriptionEXT; + +typedef struct VkBindSparseInfo { VkStructureType sType; const void *pNext; - VkInstanceCreateFlags flags; - const VkApplicationInfo *pApplicationInfo; + uint32_t waitSemaphoreCount; + const VkSemaphore *pWaitSemaphores; + uint32_t bufferBindCount; + const VkSparseBufferMemoryBindInfo *pBufferBinds; + uint32_t imageOpaqueBindCount; + const VkSparseImageOpaqueMemoryBindInfo *pImageOpaqueBinds; + uint32_t imageBindCount; + const VkSparseImageMemoryBindInfo *pImageBinds; + uint32_t signalSemaphoreCount; + const VkSemaphore *pSignalSemaphores; +} VkBindSparseInfo; + +typedef struct VkDeviceCreateInfo +{ + VkStructureType sType; + const void *pNext; + VkDeviceCreateFlags flags; + uint32_t queueCreateInfoCount; + const VkDeviceQueueCreateInfo *pQueueCreateInfos; uint32_t enabledLayerCount; const char * const*ppEnabledLayerNames; uint32_t enabledExtensionCount; const char * const*ppEnabledExtensionNames; -} VkInstanceCreateInfo; + const VkPhysicalDeviceFeatures *pEnabledFeatures; +} VkDeviceCreateInfo; + +typedef struct VkImageViewUsageCreateInfo +{ + VkStructureType sType; + const void *pNext; + VkImageUsageFlags usage; +} VkImageViewUsageCreateInfo; typedef struct VkPhysicalDeviceProperties2 { @@ -2986,6 +3511,122 @@ typedef struct VkPhysicalDeviceProperties2 VkPhysicalDeviceProperties WINE_VK_ALIGN(8) properties; } VkPhysicalDeviceProperties2; +typedef struct VkPipelineVertexInputDivisorStateCreateInfoEXT +{ + VkStructureType sType; + const void *pNext; + uint32_t vertexBindingDivisorCount; + const VkVertexInputBindingDivisorDescriptionEXT *pVertexBindingDivisors; +} VkPipelineVertexInputDivisorStateCreateInfoEXT; + +typedef struct VkShaderStatisticsInfoAMD +{ + VkShaderStageFlags shaderStageMask; + VkShaderResourceUsageAMD resourceUsage; + uint32_t numPhysicalVgprs; + uint32_t numPhysicalSgprs; + uint32_t numAvailableVgprs; + uint32_t numAvailableSgprs; + uint32_t computeWorkGroupSize[3]; +} VkShaderStatisticsInfoAMD; + +typedef struct VkWriteDescriptorSet +{ + VkStructureType sType; + const void *pNext; + VkDescriptorSet WINE_VK_ALIGN(8) dstSet; + uint32_t dstBinding; + uint32_t dstArrayElement; + uint32_t descriptorCount; + VkDescriptorType descriptorType; + const VkDescriptorImageInfo *pImageInfo; + const VkDescriptorBufferInfo *pBufferInfo; + const VkBufferView *pTexelBufferView; +} VkWriteDescriptorSet; + +typedef struct VkComputePipelineCreateInfo +{ + VkStructureType sType; + const void *pNext; + VkPipelineCreateFlags flags; + VkPipelineShaderStageCreateInfo WINE_VK_ALIGN(8) stage; + VkPipelineLayout WINE_VK_ALIGN(8) layout; + VkPipeline WINE_VK_ALIGN(8) basePipelineHandle; + int32_t basePipelineIndex; +} VkComputePipelineCreateInfo; + +typedef struct VkImageCopy +{ + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffset; + VkExtent3D extent; +} VkImageCopy; + +typedef struct VkPipelineDiscardRectangleStateCreateInfoEXT +{ + VkStructureType sType; + const void *pNext; + VkPipelineDiscardRectangleStateCreateFlagsEXT flags; + VkDiscardRectangleModeEXT discardRectangleMode; + uint32_t discardRectangleCount; + const VkRect2D *pDiscardRectangles; +} VkPipelineDiscardRectangleStateCreateInfoEXT; + +typedef struct VkSubpassDependency +{ + uint32_t srcSubpass; + uint32_t dstSubpass; + VkPipelineStageFlags srcStageMask; + VkPipelineStageFlags dstStageMask; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + VkDependencyFlags dependencyFlags; +} VkSubpassDependency; + +typedef struct VkPresentRegionsKHR +{ + VkStructureType sType; + const void *pNext; + uint32_t swapchainCount; + const VkPresentRegionKHR *pRegions; +} VkPresentRegionsKHR; + +typedef struct VkMemoryHeap +{ + VkDeviceSize WINE_VK_ALIGN(8) size; + VkMemoryHeapFlags flags; +} VkMemoryHeap; + +typedef struct VkRenderPassCreateInfo +{ + VkStructureType sType; + const void *pNext; + VkRenderPassCreateFlags flags; + uint32_t attachmentCount; + const VkAttachmentDescription *pAttachments; + uint32_t subpassCount; + const VkSubpassDescription *pSubpasses; + uint32_t dependencyCount; + const VkSubpassDependency *pDependencies; +} VkRenderPassCreateInfo; + +typedef struct VkPhysicalDeviceMemoryProperties +{ + uint32_t memoryTypeCount; + VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES]; + uint32_t memoryHeapCount; + VkMemoryHeap WINE_VK_ALIGN(8) memoryHeaps[VK_MAX_MEMORY_HEAPS]; +} VkPhysicalDeviceMemoryProperties; + +typedef struct VkPhysicalDeviceMemoryProperties2 +{ + VkStructureType sType; + void *pNext; + VkPhysicalDeviceMemoryProperties WINE_VK_ALIGN(8) memoryProperties; +} VkPhysicalDeviceMemoryProperties2; + typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImageKHR)(VkDevice, VkSwapchainKHR, uint64_t, VkSemaphore, VkFence, uint32_t *); typedef VkResult (VKAPI_PTR *PFN_vkAllocateCommandBuffers)(VkDevice, const VkCommandBufferAllocateInfo *, VkCommandBuffer *); typedef VkResult (VKAPI_PTR *PFN_vkAllocateDescriptorSets)(VkDevice, const VkDescriptorSetAllocateInfo *, VkDescriptorSet *); -- 2.16.4

1 0

[PATCH 1/8] winevulkan: Generate code for supported core commands.
by Józef Kucia 12 Jul '18

12 Jul '18

Generate thunks for core commands if command aliases are already supported. Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/vulkan-1/vulkan-1.spec | 38 +++---- dlls/winevulkan/make_vulkan | 9 +- dlls/winevulkan/vulkan_thunks.c | 233 ++++++++++++++++++++++++++++++++++++++++ dlls/winevulkan/vulkan_thunks.h | 74 +++++++++++++ dlls/winevulkan/winevulkan.spec | 38 +++---- include/wine/vulkan.h | 38 +++++++ 6 files changed, 389 insertions(+), 41 deletions(-) diff --git a/dlls/vulkan-1/vulkan-1.spec b/dlls/vulkan-1/vulkan-1.spec index 860b4c84c7b1..79031395a099 100644 --- a/dlls/vulkan-1/vulkan-1.spec +++ b/dlls/vulkan-1/vulkan-1.spec @@ -41,9 +41,9 @@ @ stdcall vkAllocateMemory(ptr ptr ptr ptr) winevulkan.wine_vkAllocateMemory @ stdcall vkBeginCommandBuffer(ptr ptr) winevulkan.wine_vkBeginCommandBuffer @ stdcall vkBindBufferMemory(ptr int64 int64 int64) winevulkan.wine_vkBindBufferMemory -@ stub vkBindBufferMemory2 +@ stdcall vkBindBufferMemory2(ptr long ptr) winevulkan.wine_vkBindBufferMemory2 @ stdcall vkBindImageMemory(ptr int64 int64 int64) winevulkan.wine_vkBindImageMemory -@ stub vkBindImageMemory2 +@ stdcall vkBindImageMemory2(ptr long ptr) winevulkan.wine_vkBindImageMemory2 @ stdcall vkCmdBeginQuery(ptr int64 long long) winevulkan.wine_vkCmdBeginQuery @ stdcall vkCmdBeginRenderPass(ptr ptr long) winevulkan.wine_vkCmdBeginRenderPass @ stdcall vkCmdBindDescriptorSets(ptr long int64 long long ptr long ptr) winevulkan.wine_vkCmdBindDescriptorSets @@ -96,7 +96,7 @@ @ stdcall vkCreateComputePipelines(ptr int64 long ptr ptr ptr) winevulkan.wine_vkCreateComputePipelines @ stdcall vkCreateDescriptorPool(ptr ptr ptr ptr) winevulkan.wine_vkCreateDescriptorPool @ stdcall vkCreateDescriptorSetLayout(ptr ptr ptr ptr) winevulkan.wine_vkCreateDescriptorSetLayout -@ stub vkCreateDescriptorUpdateTemplate +@ stdcall vkCreateDescriptorUpdateTemplate(ptr ptr ptr ptr) winevulkan.wine_vkCreateDescriptorUpdateTemplate @ stdcall vkCreateDevice(ptr ptr ptr ptr) winevulkan.wine_vkCreateDevice @ stub vkCreateDisplayModeKHR @ stub vkCreateDisplayPlaneSurfaceKHR @@ -112,7 +112,7 @@ @ stdcall vkCreateQueryPool(ptr ptr ptr ptr) winevulkan.wine_vkCreateQueryPool @ stdcall vkCreateRenderPass(ptr ptr ptr ptr) winevulkan.wine_vkCreateRenderPass @ stdcall vkCreateSampler(ptr ptr ptr ptr) winevulkan.wine_vkCreateSampler -@ stub vkCreateSamplerYcbcrConversion +@ stdcall vkCreateSamplerYcbcrConversion(ptr ptr ptr ptr) winevulkan.wine_vkCreateSamplerYcbcrConversion @ stdcall vkCreateSemaphore(ptr ptr ptr ptr) winevulkan.wine_vkCreateSemaphore @ stdcall vkCreateShaderModule(ptr ptr ptr ptr) winevulkan.wine_vkCreateShaderModule @ stub vkCreateSharedSwapchainsKHR @@ -123,7 +123,7 @@ @ stdcall vkDestroyCommandPool(ptr int64 ptr) winevulkan.wine_vkDestroyCommandPool @ stdcall vkDestroyDescriptorPool(ptr int64 ptr) winevulkan.wine_vkDestroyDescriptorPool @ stdcall vkDestroyDescriptorSetLayout(ptr int64 ptr) winevulkan.wine_vkDestroyDescriptorSetLayout -@ stub vkDestroyDescriptorUpdateTemplate +@ stdcall vkDestroyDescriptorUpdateTemplate(ptr int64 ptr) winevulkan.wine_vkDestroyDescriptorUpdateTemplate @ stdcall vkDestroyDevice(ptr ptr) winevulkan.wine_vkDestroyDevice @ stdcall vkDestroyEvent(ptr int64 ptr) winevulkan.wine_vkDestroyEvent @ stdcall vkDestroyFence(ptr int64 ptr) winevulkan.wine_vkDestroyFence @@ -137,7 +137,7 @@ @ stdcall vkDestroyQueryPool(ptr int64 ptr) winevulkan.wine_vkDestroyQueryPool @ stdcall vkDestroyRenderPass(ptr int64 ptr) winevulkan.wine_vkDestroyRenderPass @ stdcall vkDestroySampler(ptr int64 ptr) winevulkan.wine_vkDestroySampler -@ stub vkDestroySamplerYcbcrConversion +@ stdcall vkDestroySamplerYcbcrConversion(ptr int64 ptr) winevulkan.wine_vkDestroySamplerYcbcrConversion @ stdcall vkDestroySemaphore(ptr int64 ptr) winevulkan.wine_vkDestroySemaphore @ stdcall vkDestroyShaderModule(ptr int64 ptr) winevulkan.wine_vkDestroyShaderModule @ stdcall vkDestroySurfaceKHR(ptr int64 ptr) winevulkan.wine_vkDestroySurfaceKHR @@ -156,8 +156,8 @@ @ stdcall vkFreeDescriptorSets(ptr int64 long ptr) winevulkan.wine_vkFreeDescriptorSets @ stdcall vkFreeMemory(ptr int64 ptr) winevulkan.wine_vkFreeMemory @ stdcall vkGetBufferMemoryRequirements(ptr int64 ptr) winevulkan.wine_vkGetBufferMemoryRequirements -@ stub vkGetBufferMemoryRequirements2 -@ stub vkGetDescriptorSetLayoutSupport +@ stdcall vkGetBufferMemoryRequirements2(ptr ptr ptr) winevulkan.wine_vkGetBufferMemoryRequirements2 +@ stdcall vkGetDescriptorSetLayoutSupport(ptr ptr ptr) winevulkan.wine_vkGetDescriptorSetLayoutSupport @ stub vkGetDeviceGroupPeerMemoryFeatures @ stub vkGetDeviceGroupPresentCapabilitiesKHR @ stub vkGetDeviceGroupSurfacePresentModesKHR @@ -171,9 +171,9 @@ @ stdcall vkGetEventStatus(ptr int64) winevulkan.wine_vkGetEventStatus @ stdcall vkGetFenceStatus(ptr int64) winevulkan.wine_vkGetFenceStatus @ stdcall vkGetImageMemoryRequirements(ptr int64 ptr) winevulkan.wine_vkGetImageMemoryRequirements -@ stub vkGetImageMemoryRequirements2 +@ stdcall vkGetImageMemoryRequirements2(ptr ptr ptr) winevulkan.wine_vkGetImageMemoryRequirements2 @ stdcall vkGetImageSparseMemoryRequirements(ptr int64 ptr ptr) winevulkan.wine_vkGetImageSparseMemoryRequirements -@ stub vkGetImageSparseMemoryRequirements2 +@ stdcall vkGetImageSparseMemoryRequirements2(ptr ptr ptr ptr) winevulkan.wine_vkGetImageSparseMemoryRequirements2 @ stdcall vkGetImageSubresourceLayout(ptr int64 ptr ptr) winevulkan.wine_vkGetImageSubresourceLayout @ stdcall vkGetInstanceProcAddr(ptr str) @ stub vkGetPhysicalDeviceDisplayPlanePropertiesKHR @@ -182,20 +182,20 @@ @ stub vkGetPhysicalDeviceExternalFenceProperties @ stub vkGetPhysicalDeviceExternalSemaphoreProperties @ stdcall vkGetPhysicalDeviceFeatures(ptr ptr) winevulkan.wine_vkGetPhysicalDeviceFeatures -@ stub vkGetPhysicalDeviceFeatures2 +@ stdcall vkGetPhysicalDeviceFeatures2(ptr ptr) winevulkan.wine_vkGetPhysicalDeviceFeatures2 @ stdcall vkGetPhysicalDeviceFormatProperties(ptr long ptr) winevulkan.wine_vkGetPhysicalDeviceFormatProperties -@ stub vkGetPhysicalDeviceFormatProperties2 +@ stdcall vkGetPhysicalDeviceFormatProperties2(ptr long ptr) winevulkan.wine_vkGetPhysicalDeviceFormatProperties2 @ stdcall vkGetPhysicalDeviceImageFormatProperties(ptr long long long long long ptr) winevulkan.wine_vkGetPhysicalDeviceImageFormatProperties -@ stub vkGetPhysicalDeviceImageFormatProperties2 +@ stdcall vkGetPhysicalDeviceImageFormatProperties2(ptr ptr ptr) winevulkan.wine_vkGetPhysicalDeviceImageFormatProperties2 @ stdcall vkGetPhysicalDeviceMemoryProperties(ptr ptr) winevulkan.wine_vkGetPhysicalDeviceMemoryProperties -@ stub vkGetPhysicalDeviceMemoryProperties2 +@ stdcall vkGetPhysicalDeviceMemoryProperties2(ptr ptr) winevulkan.wine_vkGetPhysicalDeviceMemoryProperties2 @ stub vkGetPhysicalDevicePresentRectanglesKHR @ stdcall vkGetPhysicalDeviceProperties(ptr ptr) winevulkan.wine_vkGetPhysicalDeviceProperties -@ stub vkGetPhysicalDeviceProperties2 +@ stdcall vkGetPhysicalDeviceProperties2(ptr ptr) winevulkan.wine_vkGetPhysicalDeviceProperties2 @ stdcall vkGetPhysicalDeviceQueueFamilyProperties(ptr ptr ptr) winevulkan.wine_vkGetPhysicalDeviceQueueFamilyProperties -@ stub vkGetPhysicalDeviceQueueFamilyProperties2 +@ stdcall vkGetPhysicalDeviceQueueFamilyProperties2(ptr ptr ptr) winevulkan.wine_vkGetPhysicalDeviceQueueFamilyProperties2 @ stdcall vkGetPhysicalDeviceSparseImageFormatProperties(ptr long long long long long ptr ptr) winevulkan.wine_vkGetPhysicalDeviceSparseImageFormatProperties -@ stub vkGetPhysicalDeviceSparseImageFormatProperties2 +@ stdcall vkGetPhysicalDeviceSparseImageFormatProperties2(ptr ptr ptr ptr) winevulkan.wine_vkGetPhysicalDeviceSparseImageFormatProperties2 @ stdcall vkGetPhysicalDeviceSurfaceCapabilitiesKHR(ptr int64 ptr) winevulkan.wine_vkGetPhysicalDeviceSurfaceCapabilitiesKHR @ stdcall vkGetPhysicalDeviceSurfaceFormatsKHR(ptr int64 ptr ptr) winevulkan.wine_vkGetPhysicalDeviceSurfaceFormatsKHR @ stdcall vkGetPhysicalDeviceSurfacePresentModesKHR(ptr int64 ptr long) winevulkan.wine_vkGetPhysicalDeviceSurfacePresentModesKHR @@ -218,8 +218,8 @@ @ stdcall vkResetEvent(ptr int64) winevulkan.wine_vkResetEvent @ stdcall vkResetFences(ptr long ptr) winevulkan.wine_vkResetFences @ stdcall vkSetEvent(ptr int64) winevulkan.wine_vkSetEvent -@ stub vkTrimCommandPool +@ stdcall vkTrimCommandPool(ptr int64 long) winevulkan.wine_vkTrimCommandPool @ stdcall vkUnmapMemory(ptr int64) winevulkan.wine_vkUnmapMemory -@ stub vkUpdateDescriptorSetWithTemplate +@ stdcall vkUpdateDescriptorSetWithTemplate(ptr int64 int64 ptr) winevulkan.wine_vkUpdateDescriptorSetWithTemplate @ stdcall vkUpdateDescriptorSets(ptr long ptr long ptr) winevulkan.wine_vkUpdateDescriptorSets @ stdcall vkWaitForFences(ptr long ptr long int64) winevulkan.wine_vkWaitForFences diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan index c32d9edc4e34..944b015a6368 100755 --- a/dlls/winevulkan/make_vulkan +++ b/dlls/winevulkan/make_vulkan @@ -377,7 +377,7 @@ class VkEnumValue(object): class VkFunction(object): - def __init__(self, _type=None, name=None, params=[], extensions=[], alias=False): + def __init__(self, _type=None, name=None, params=[], extensions=[], alias=None): self.extensions = [] self.name = name self.type = _type @@ -409,7 +409,7 @@ class VkFunction(object): func_type = alias.type params = alias.params - return VkFunction(_type=func_type, name=func_name, params=params, alias=True) + return VkFunction(_type=func_type, name=func_name, params=params, alias=alias) @staticmethod def from_xml(command, types): @@ -440,7 +440,7 @@ class VkFunction(object): return conversions def is_alias(self): - return self.alias + return bool(self.alias) def is_core_func(self): """ Returns whether the function is a Vulkan core function. @@ -2364,6 +2364,9 @@ class VkRegistry(object): struct = type_info["data"] mark_struct_dependencies(struct, self.types) + if func.is_alias(): + func.alias.required = True + def _parse_commands(self, root): """ Parse command section containing the Vulkan function calls. """ funcs = {} diff --git a/dlls/winevulkan/vulkan_thunks.c b/dlls/winevulkan/vulkan_thunks.c index 2f89fdb5bde4..31ea551d5314 100644 --- a/dlls/winevulkan/vulkan_thunks.c +++ b/dlls/winevulkan/vulkan_thunks.c @@ -1185,6 +1185,24 @@ VkResult WINAPI wine_vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDevi return device->funcs.p_vkBindBufferMemory(device->device, buffer, memory, memoryOffset); } +VkResult WINAPI wine_vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos) +{ +#if defined(USE_STRUCT_CONVERSION) + VkResult result; + VkBindBufferMemoryInfo_host *pBindInfos_host; + TRACE("%p, %u, %p\n", device, bindInfoCount, pBindInfos); + + pBindInfos_host = convert_VkBindBufferMemoryInfo_array_win_to_host(pBindInfos, bindInfoCount); + result = device->funcs.p_vkBindBufferMemory2(device->device, bindInfoCount, pBindInfos_host); + + free_VkBindBufferMemoryInfo_array(pBindInfos_host, bindInfoCount); + return result; +#else + TRACE("%p, %u, %p\n", device, bindInfoCount, pBindInfos); + return device->funcs.p_vkBindBufferMemory2(device->device, bindInfoCount, pBindInfos); +#endif +} + static VkResult WINAPI wine_vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos) { #if defined(USE_STRUCT_CONVERSION) @@ -1209,6 +1227,24 @@ VkResult WINAPI wine_vkBindImageMemory(VkDevice device, VkImage image, VkDeviceM return device->funcs.p_vkBindImageMemory(device->device, image, memory, memoryOffset); } +VkResult WINAPI wine_vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos) +{ +#if defined(USE_STRUCT_CONVERSION) + VkResult result; + VkBindImageMemoryInfo_host *pBindInfos_host; + TRACE("%p, %u, %p\n", device, bindInfoCount, pBindInfos); + + pBindInfos_host = convert_VkBindImageMemoryInfo_array_win_to_host(pBindInfos, bindInfoCount); + result = device->funcs.p_vkBindImageMemory2(device->device, bindInfoCount, pBindInfos_host); + + free_VkBindImageMemoryInfo_array(pBindInfos_host, bindInfoCount); + return result; +#else + TRACE("%p, %u, %p\n", device, bindInfoCount, pBindInfos); + return device->funcs.p_vkBindImageMemory2(device->device, bindInfoCount, pBindInfos); +#endif +} + static VkResult WINAPI wine_vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos) { #if defined(USE_STRUCT_CONVERSION) @@ -1690,6 +1726,23 @@ VkResult WINAPI wine_vkCreateDescriptorSetLayout(VkDevice device, const VkDescri return device->funcs.p_vkCreateDescriptorSetLayout(device->device, pCreateInfo, NULL, pSetLayout); } +VkResult WINAPI wine_vkCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate) +{ +#if defined(USE_STRUCT_CONVERSION) + VkResult result; + VkDescriptorUpdateTemplateCreateInfo_host pCreateInfo_host; + TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); + + convert_VkDescriptorUpdateTemplateCreateInfo_win_to_host(pCreateInfo, &pCreateInfo_host); + result = device->funcs.p_vkCreateDescriptorUpdateTemplate(device->device, &pCreateInfo_host, NULL, pDescriptorUpdateTemplate); + + return result; +#else + TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); + return device->funcs.p_vkCreateDescriptorUpdateTemplate(device->device, pCreateInfo, NULL, pDescriptorUpdateTemplate); +#endif +} + static VkResult WINAPI wine_vkCreateDescriptorUpdateTemplateKHR(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate) { #if defined(USE_STRUCT_CONVERSION) @@ -1807,6 +1860,12 @@ VkResult WINAPI wine_vkCreateSampler(VkDevice device, const VkSamplerCreateInfo return device->funcs.p_vkCreateSampler(device->device, pCreateInfo, NULL, pSampler); } +VkResult WINAPI wine_vkCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion) +{ + TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pYcbcrConversion); + return device->funcs.p_vkCreateSamplerYcbcrConversion(device->device, pCreateInfo, NULL, pYcbcrConversion); +} + static VkResult WINAPI wine_vkCreateSamplerYcbcrConversionKHR(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion) { TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pYcbcrConversion); @@ -1884,6 +1943,12 @@ void WINAPI wine_vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLa device->funcs.p_vkDestroyDescriptorSetLayout(device->device, descriptorSetLayout, NULL); } +void WINAPI wine_vkDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator) +{ + TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(descriptorUpdateTemplate), pAllocator); + device->funcs.p_vkDestroyDescriptorUpdateTemplate(device->device, descriptorUpdateTemplate, NULL); +} + static void WINAPI wine_vkDestroyDescriptorUpdateTemplateKHR(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator) { TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(descriptorUpdateTemplate), pAllocator); @@ -1956,6 +2021,12 @@ void WINAPI wine_vkDestroySampler(VkDevice device, VkSampler sampler, const VkAl device->funcs.p_vkDestroySampler(device->device, sampler, NULL); } +void WINAPI wine_vkDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator) +{ + TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(ycbcrConversion), pAllocator); + device->funcs.p_vkDestroySamplerYcbcrConversion(device->device, ycbcrConversion, NULL); +} + static void WINAPI wine_vkDestroySamplerYcbcrConversionKHR(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator) { TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(ycbcrConversion), pAllocator); @@ -2055,6 +2126,24 @@ void WINAPI wine_vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, #endif } +void WINAPI wine_vkGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements) +{ +#if defined(USE_STRUCT_CONVERSION) + VkBufferMemoryRequirementsInfo2_host pInfo_host; + VkMemoryRequirements2_host pMemoryRequirements_host; + TRACE("%p, %p, %p\n", device, pInfo, pMemoryRequirements); + + convert_VkBufferMemoryRequirementsInfo2_win_to_host(pInfo, &pInfo_host); + convert_VkMemoryRequirements2_win_to_host(pMemoryRequirements, &pMemoryRequirements_host); + device->funcs.p_vkGetBufferMemoryRequirements2(device->device, &pInfo_host, &pMemoryRequirements_host); + + convert_VkMemoryRequirements2_host_to_win(&pMemoryRequirements_host, pMemoryRequirements); +#else + TRACE("%p, %p, %p\n", device, pInfo, pMemoryRequirements); + device->funcs.p_vkGetBufferMemoryRequirements2(device->device, pInfo, pMemoryRequirements); +#endif +} + static void WINAPI wine_vkGetBufferMemoryRequirements2KHR(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements) { #if defined(USE_STRUCT_CONVERSION) @@ -2073,6 +2162,12 @@ static void WINAPI wine_vkGetBufferMemoryRequirements2KHR(VkDevice device, const #endif } +void WINAPI wine_vkGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport) +{ + TRACE("%p, %p, %p\n", device, pCreateInfo, pSupport); + device->funcs.p_vkGetDescriptorSetLayoutSupport(device->device, pCreateInfo, pSupport); +} + static void WINAPI wine_vkGetDescriptorSetLayoutSupportKHR(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport) { TRACE("%p, %p, %p\n", device, pCreateInfo, pSupport); @@ -2112,6 +2207,24 @@ void WINAPI wine_vkGetImageMemoryRequirements(VkDevice device, VkImage image, Vk #endif } +void WINAPI wine_vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements) +{ +#if defined(USE_STRUCT_CONVERSION) + VkImageMemoryRequirementsInfo2_host pInfo_host; + VkMemoryRequirements2_host pMemoryRequirements_host; + TRACE("%p, %p, %p\n", device, pInfo, pMemoryRequirements); + + convert_VkImageMemoryRequirementsInfo2_win_to_host(pInfo, &pInfo_host); + convert_VkMemoryRequirements2_win_to_host(pMemoryRequirements, &pMemoryRequirements_host); + device->funcs.p_vkGetImageMemoryRequirements2(device->device, &pInfo_host, &pMemoryRequirements_host); + + convert_VkMemoryRequirements2_host_to_win(&pMemoryRequirements_host, pMemoryRequirements); +#else + TRACE("%p, %p, %p\n", device, pInfo, pMemoryRequirements); + device->funcs.p_vkGetImageMemoryRequirements2(device->device, pInfo, pMemoryRequirements); +#endif +} + static void WINAPI wine_vkGetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements) { #if defined(USE_STRUCT_CONVERSION) @@ -2136,6 +2249,21 @@ void WINAPI wine_vkGetImageSparseMemoryRequirements(VkDevice device, VkImage ima device->funcs.p_vkGetImageSparseMemoryRequirements(device->device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements); } +void WINAPI wine_vkGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements) +{ +#if defined(USE_STRUCT_CONVERSION) + VkImageSparseMemoryRequirementsInfo2_host pInfo_host; + TRACE("%p, %p, %p, %p\n", device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); + + convert_VkImageSparseMemoryRequirementsInfo2_win_to_host(pInfo, &pInfo_host); + device->funcs.p_vkGetImageSparseMemoryRequirements2(device->device, &pInfo_host, pSparseMemoryRequirementCount, pSparseMemoryRequirements); + +#else + TRACE("%p, %p, %p, %p\n", device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); + device->funcs.p_vkGetImageSparseMemoryRequirements2(device->device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); +#endif +} + static void WINAPI wine_vkGetImageSparseMemoryRequirements2KHR(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements) { #if defined(USE_STRUCT_CONVERSION) @@ -2172,6 +2300,12 @@ void WINAPI wine_vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, Vk physicalDevice->instance->funcs.p_vkGetPhysicalDeviceFeatures(physicalDevice->phys_dev, pFeatures); } +void WINAPI wine_vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures) +{ + TRACE("%p, %p\n", physicalDevice, pFeatures); + physicalDevice->instance->funcs.p_vkGetPhysicalDeviceFeatures2(physicalDevice->phys_dev, pFeatures); +} + static void WINAPI wine_vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures) { TRACE("%p, %p\n", physicalDevice, pFeatures); @@ -2184,6 +2318,12 @@ void WINAPI wine_vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDe physicalDevice->instance->funcs.p_vkGetPhysicalDeviceFormatProperties(physicalDevice->phys_dev, format, pFormatProperties); } +void WINAPI wine_vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties) +{ + TRACE("%p, %#x, %p\n", physicalDevice, format, pFormatProperties); + physicalDevice->instance->funcs.p_vkGetPhysicalDeviceFormatProperties2(physicalDevice->phys_dev, format, pFormatProperties); +} + static void WINAPI wine_vkGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties) { TRACE("%p, %#x, %p\n", physicalDevice, format, pFormatProperties); @@ -2207,6 +2347,24 @@ VkResult WINAPI wine_vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice p #endif } +VkResult WINAPI wine_vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties) +{ +#if defined(USE_STRUCT_CONVERSION) + VkResult result; + VkImageFormatProperties2_host pImageFormatProperties_host; + TRACE("%p, %p, %p\n", physicalDevice, pImageFormatInfo, pImageFormatProperties); + + convert_VkImageFormatProperties2_win_to_host(pImageFormatProperties, &pImageFormatProperties_host); + result = physicalDevice->instance->funcs.p_vkGetPhysicalDeviceImageFormatProperties2(physicalDevice->phys_dev, pImageFormatInfo, &pImageFormatProperties_host); + + convert_VkImageFormatProperties2_host_to_win(&pImageFormatProperties_host, pImageFormatProperties); + return result; +#else + TRACE("%p, %p, %p\n", physicalDevice, pImageFormatInfo, pImageFormatProperties); + return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceImageFormatProperties2(physicalDevice->phys_dev, pImageFormatInfo, pImageFormatProperties); +#endif +} + static VkResult WINAPI wine_vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties) { #if defined(USE_STRUCT_CONVERSION) @@ -2240,6 +2398,22 @@ void WINAPI wine_vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDe #endif } +void WINAPI wine_vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties) +{ +#if defined(USE_STRUCT_CONVERSION) + VkPhysicalDeviceMemoryProperties2_host pMemoryProperties_host; + TRACE("%p, %p\n", physicalDevice, pMemoryProperties); + + convert_VkPhysicalDeviceMemoryProperties2_win_to_host(pMemoryProperties, &pMemoryProperties_host); + physicalDevice->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties2(physicalDevice->phys_dev, &pMemoryProperties_host); + + convert_VkPhysicalDeviceMemoryProperties2_host_to_win(&pMemoryProperties_host, pMemoryProperties); +#else + TRACE("%p, %p\n", physicalDevice, pMemoryProperties); + physicalDevice->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties2(physicalDevice->phys_dev, pMemoryProperties); +#endif +} + static void WINAPI wine_vkGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties) { #if defined(USE_STRUCT_CONVERSION) @@ -2277,6 +2451,22 @@ void WINAPI wine_vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, #endif } +void WINAPI wine_vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties) +{ +#if defined(USE_STRUCT_CONVERSION) + VkPhysicalDeviceProperties2_host pProperties_host; + TRACE("%p, %p\n", physicalDevice, pProperties); + + convert_VkPhysicalDeviceProperties2_win_to_host(pProperties, &pProperties_host); + physicalDevice->instance->funcs.p_vkGetPhysicalDeviceProperties2(physicalDevice->phys_dev, &pProperties_host); + + convert_VkPhysicalDeviceProperties2_host_to_win(&pProperties_host, pProperties); +#else + TRACE("%p, %p\n", physicalDevice, pProperties); + physicalDevice->instance->funcs.p_vkGetPhysicalDeviceProperties2(physicalDevice->phys_dev, pProperties); +#endif +} + static void WINAPI wine_vkGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties) { #if defined(USE_STRUCT_CONVERSION) @@ -2299,6 +2489,12 @@ void WINAPI wine_vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physi physicalDevice->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice->phys_dev, pQueueFamilyPropertyCount, pQueueFamilyProperties); } +void WINAPI wine_vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties) +{ + TRACE("%p, %p, %p\n", physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); + physicalDevice->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice->phys_dev, pQueueFamilyPropertyCount, pQueueFamilyProperties); +} + static void WINAPI wine_vkGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties) { TRACE("%p, %p, %p\n", physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); @@ -2311,6 +2507,12 @@ void WINAPI wine_vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice->phys_dev, format, type, samples, usage, tiling, pPropertyCount, pProperties); } +void WINAPI wine_vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties) +{ + TRACE("%p, %p, %p, %p\n", physicalDevice, pFormatInfo, pPropertyCount, pProperties); + physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSparseImageFormatProperties2(physicalDevice->phys_dev, pFormatInfo, pPropertyCount, pProperties); +} + static void WINAPI wine_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties) { TRACE("%p, %p, %p, %p\n", physicalDevice, pFormatInfo, pPropertyCount, pProperties); @@ -2485,6 +2687,12 @@ VkResult WINAPI wine_vkSetEvent(VkDevice device, VkEvent event) return device->funcs.p_vkSetEvent(device->device, event); } +void WINAPI wine_vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) +{ + TRACE("%p, 0x%s, %#x\n", device, wine_dbgstr_longlong(commandPool), flags); + device->funcs.p_vkTrimCommandPool(device->device, commandPool, flags); +} + static void WINAPI wine_vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) { TRACE("%p, 0x%s, %#x\n", device, wine_dbgstr_longlong(commandPool), flags); @@ -2497,6 +2705,12 @@ void WINAPI wine_vkUnmapMemory(VkDevice device, VkDeviceMemory memory) device->funcs.p_vkUnmapMemory(device->device, memory); } +void WINAPI wine_vkUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData) +{ + TRACE("%p, 0x%s, 0x%s, %p\n", device, wine_dbgstr_longlong(descriptorSet), wine_dbgstr_longlong(descriptorUpdateTemplate), pData); + device->funcs.p_vkUpdateDescriptorSetWithTemplate(device->device, descriptorSet, descriptorUpdateTemplate, pData); +} + static void WINAPI wine_vkUpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData) { TRACE("%p, 0x%s, 0x%s, %p\n", device, wine_dbgstr_longlong(descriptorSet), wine_dbgstr_longlong(descriptorUpdateTemplate), pData); @@ -2536,8 +2750,10 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkAllocateMemory", &wine_vkAllocateMemory}, {"vkBeginCommandBuffer", &wine_vkBeginCommandBuffer}, {"vkBindBufferMemory", &wine_vkBindBufferMemory}, + {"vkBindBufferMemory2", &wine_vkBindBufferMemory2}, {"vkBindBufferMemory2KHR", &wine_vkBindBufferMemory2KHR}, {"vkBindImageMemory", &wine_vkBindImageMemory}, + {"vkBindImageMemory2", &wine_vkBindImageMemory2}, {"vkBindImageMemory2KHR", &wine_vkBindImageMemory2KHR}, {"vkCmdBeginQuery", &wine_vkCmdBeginQuery}, {"vkCmdBeginRenderPass", &wine_vkCmdBeginRenderPass}, @@ -2599,6 +2815,7 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkCreateComputePipelines", &wine_vkCreateComputePipelines}, {"vkCreateDescriptorPool", &wine_vkCreateDescriptorPool}, {"vkCreateDescriptorSetLayout", &wine_vkCreateDescriptorSetLayout}, + {"vkCreateDescriptorUpdateTemplate", &wine_vkCreateDescriptorUpdateTemplate}, {"vkCreateDescriptorUpdateTemplateKHR", &wine_vkCreateDescriptorUpdateTemplateKHR}, {"vkCreateEvent", &wine_vkCreateEvent}, {"vkCreateFence", &wine_vkCreateFence}, @@ -2611,6 +2828,7 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkCreateQueryPool", &wine_vkCreateQueryPool}, {"vkCreateRenderPass", &wine_vkCreateRenderPass}, {"vkCreateSampler", &wine_vkCreateSampler}, + {"vkCreateSamplerYcbcrConversion", &wine_vkCreateSamplerYcbcrConversion}, {"vkCreateSamplerYcbcrConversionKHR", &wine_vkCreateSamplerYcbcrConversionKHR}, {"vkCreateSemaphore", &wine_vkCreateSemaphore}, {"vkCreateShaderModule", &wine_vkCreateShaderModule}, @@ -2621,6 +2839,7 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkDestroyCommandPool", &wine_vkDestroyCommandPool}, {"vkDestroyDescriptorPool", &wine_vkDestroyDescriptorPool}, {"vkDestroyDescriptorSetLayout", &wine_vkDestroyDescriptorSetLayout}, + {"vkDestroyDescriptorUpdateTemplate", &wine_vkDestroyDescriptorUpdateTemplate}, {"vkDestroyDescriptorUpdateTemplateKHR", &wine_vkDestroyDescriptorUpdateTemplateKHR}, {"vkDestroyDevice", &wine_vkDestroyDevice}, {"vkDestroyEvent", &wine_vkDestroyEvent}, @@ -2634,6 +2853,7 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkDestroyQueryPool", &wine_vkDestroyQueryPool}, {"vkDestroyRenderPass", &wine_vkDestroyRenderPass}, {"vkDestroySampler", &wine_vkDestroySampler}, + {"vkDestroySamplerYcbcrConversion", &wine_vkDestroySamplerYcbcrConversion}, {"vkDestroySamplerYcbcrConversionKHR", &wine_vkDestroySamplerYcbcrConversionKHR}, {"vkDestroySemaphore", &wine_vkDestroySemaphore}, {"vkDestroyShaderModule", &wine_vkDestroyShaderModule}, @@ -2646,7 +2866,9 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkFreeDescriptorSets", &wine_vkFreeDescriptorSets}, {"vkFreeMemory", &wine_vkFreeMemory}, {"vkGetBufferMemoryRequirements", &wine_vkGetBufferMemoryRequirements}, + {"vkGetBufferMemoryRequirements2", &wine_vkGetBufferMemoryRequirements2}, {"vkGetBufferMemoryRequirements2KHR", &wine_vkGetBufferMemoryRequirements2KHR}, + {"vkGetDescriptorSetLayoutSupport", &wine_vkGetDescriptorSetLayoutSupport}, {"vkGetDescriptorSetLayoutSupportKHR", &wine_vkGetDescriptorSetLayoutSupportKHR}, {"vkGetDeviceMemoryCommitment", &wine_vkGetDeviceMemoryCommitment}, {"vkGetDeviceProcAddr", &wine_vkGetDeviceProcAddr}, @@ -2654,8 +2876,10 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkGetEventStatus", &wine_vkGetEventStatus}, {"vkGetFenceStatus", &wine_vkGetFenceStatus}, {"vkGetImageMemoryRequirements", &wine_vkGetImageMemoryRequirements}, + {"vkGetImageMemoryRequirements2", &wine_vkGetImageMemoryRequirements2}, {"vkGetImageMemoryRequirements2KHR", &wine_vkGetImageMemoryRequirements2KHR}, {"vkGetImageSparseMemoryRequirements", &wine_vkGetImageSparseMemoryRequirements}, + {"vkGetImageSparseMemoryRequirements2", &wine_vkGetImageSparseMemoryRequirements2}, {"vkGetImageSparseMemoryRequirements2KHR", &wine_vkGetImageSparseMemoryRequirements2KHR}, {"vkGetImageSubresourceLayout", &wine_vkGetImageSubresourceLayout}, {"vkGetPipelineCacheData", &wine_vkGetPipelineCacheData}, @@ -2678,8 +2902,10 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkResetEvent", &wine_vkResetEvent}, {"vkResetFences", &wine_vkResetFences}, {"vkSetEvent", &wine_vkSetEvent}, + {"vkTrimCommandPool", &wine_vkTrimCommandPool}, {"vkTrimCommandPoolKHR", &wine_vkTrimCommandPoolKHR}, {"vkUnmapMemory", &wine_vkUnmapMemory}, + {"vkUpdateDescriptorSetWithTemplate", &wine_vkUpdateDescriptorSetWithTemplate}, {"vkUpdateDescriptorSetWithTemplateKHR", &wine_vkUpdateDescriptorSetWithTemplateKHR}, {"vkUpdateDescriptorSets", &wine_vkUpdateDescriptorSets}, {"vkWaitForFences", &wine_vkWaitForFences}, @@ -2695,19 +2921,26 @@ static const struct vulkan_func vk_instance_dispatch_table[] = {"vkEnumerateDeviceLayerProperties", &wine_vkEnumerateDeviceLayerProperties}, {"vkEnumeratePhysicalDevices", &wine_vkEnumeratePhysicalDevices}, {"vkGetPhysicalDeviceFeatures", &wine_vkGetPhysicalDeviceFeatures}, + {"vkGetPhysicalDeviceFeatures2", &wine_vkGetPhysicalDeviceFeatures2}, {"vkGetPhysicalDeviceFeatures2KHR", &wine_vkGetPhysicalDeviceFeatures2KHR}, {"vkGetPhysicalDeviceFormatProperties", &wine_vkGetPhysicalDeviceFormatProperties}, + {"vkGetPhysicalDeviceFormatProperties2", &wine_vkGetPhysicalDeviceFormatProperties2}, {"vkGetPhysicalDeviceFormatProperties2KHR", &wine_vkGetPhysicalDeviceFormatProperties2KHR}, {"vkGetPhysicalDeviceImageFormatProperties", &wine_vkGetPhysicalDeviceImageFormatProperties}, + {"vkGetPhysicalDeviceImageFormatProperties2", &wine_vkGetPhysicalDeviceImageFormatProperties2}, {"vkGetPhysicalDeviceImageFormatProperties2KHR", &wine_vkGetPhysicalDeviceImageFormatProperties2KHR}, {"vkGetPhysicalDeviceMemoryProperties", &wine_vkGetPhysicalDeviceMemoryProperties}, + {"vkGetPhysicalDeviceMemoryProperties2", &wine_vkGetPhysicalDeviceMemoryProperties2}, {"vkGetPhysicalDeviceMemoryProperties2KHR", &wine_vkGetPhysicalDeviceMemoryProperties2KHR}, {"vkGetPhysicalDeviceMultisamplePropertiesEXT", &wine_vkGetPhysicalDeviceMultisamplePropertiesEXT}, {"vkGetPhysicalDeviceProperties", &wine_vkGetPhysicalDeviceProperties}, + {"vkGetPhysicalDeviceProperties2", &wine_vkGetPhysicalDeviceProperties2}, {"vkGetPhysicalDeviceProperties2KHR", &wine_vkGetPhysicalDeviceProperties2KHR}, {"vkGetPhysicalDeviceQueueFamilyProperties", &wine_vkGetPhysicalDeviceQueueFamilyProperties}, + {"vkGetPhysicalDeviceQueueFamilyProperties2", &wine_vkGetPhysicalDeviceQueueFamilyProperties2}, {"vkGetPhysicalDeviceQueueFamilyProperties2KHR", &wine_vkGetPhysicalDeviceQueueFamilyProperties2KHR}, {"vkGetPhysicalDeviceSparseImageFormatProperties", &wine_vkGetPhysicalDeviceSparseImageFormatProperties}, + {"vkGetPhysicalDeviceSparseImageFormatProperties2", &wine_vkGetPhysicalDeviceSparseImageFormatProperties2}, {"vkGetPhysicalDeviceSparseImageFormatProperties2KHR", &wine_vkGetPhysicalDeviceSparseImageFormatProperties2KHR}, {"vkGetPhysicalDeviceSurfaceCapabilitiesKHR", &wine_vkGetPhysicalDeviceSurfaceCapabilitiesKHR}, {"vkGetPhysicalDeviceSurfaceFormatsKHR", &wine_vkGetPhysicalDeviceSurfaceFormatsKHR}, diff --git a/dlls/winevulkan/vulkan_thunks.h b/dlls/winevulkan/vulkan_thunks.h index 55645afd4735..dd85e4270087 100644 --- a/dlls/winevulkan/vulkan_thunks.h +++ b/dlls/winevulkan/vulkan_thunks.h @@ -642,12 +642,22 @@ struct vulkan_device_funcs VkResult (*p_vkBeginCommandBuffer)(VkCommandBuffer, const VkCommandBufferBeginInfo *); #endif VkResult (*p_vkBindBufferMemory)(VkDevice, VkBuffer, VkDeviceMemory, VkDeviceSize); +#if defined(USE_STRUCT_CONVERSION) + VkResult (*p_vkBindBufferMemory2)(VkDevice, uint32_t, const VkBindBufferMemoryInfo_host *); +#else + VkResult (*p_vkBindBufferMemory2)(VkDevice, uint32_t, const VkBindBufferMemoryInfo *); +#endif #if defined(USE_STRUCT_CONVERSION) VkResult (*p_vkBindBufferMemory2KHR)(VkDevice, uint32_t, const VkBindBufferMemoryInfo_host *); #else VkResult (*p_vkBindBufferMemory2KHR)(VkDevice, uint32_t, const VkBindBufferMemoryInfo *); #endif VkResult (*p_vkBindImageMemory)(VkDevice, VkImage, VkDeviceMemory, VkDeviceSize); +#if defined(USE_STRUCT_CONVERSION) + VkResult (*p_vkBindImageMemory2)(VkDevice, uint32_t, const VkBindImageMemoryInfo_host *); +#else + VkResult (*p_vkBindImageMemory2)(VkDevice, uint32_t, const VkBindImageMemoryInfo *); +#endif #if defined(USE_STRUCT_CONVERSION) VkResult (*p_vkBindImageMemory2KHR)(VkDevice, uint32_t, const VkBindImageMemoryInfo_host *); #else @@ -753,6 +763,11 @@ struct vulkan_device_funcs #endif VkResult (*p_vkCreateDescriptorPool)(VkDevice, const VkDescriptorPoolCreateInfo *, const VkAllocationCallbacks *, VkDescriptorPool *); VkResult (*p_vkCreateDescriptorSetLayout)(VkDevice, const VkDescriptorSetLayoutCreateInfo *, const VkAllocationCallbacks *, VkDescriptorSetLayout *); +#if defined(USE_STRUCT_CONVERSION) + VkResult (*p_vkCreateDescriptorUpdateTemplate)(VkDevice, const VkDescriptorUpdateTemplateCreateInfo_host *, const VkAllocationCallbacks *, VkDescriptorUpdateTemplate *); +#else + VkResult (*p_vkCreateDescriptorUpdateTemplate)(VkDevice, const VkDescriptorUpdateTemplateCreateInfo *, const VkAllocationCallbacks *, VkDescriptorUpdateTemplate *); +#endif #if defined(USE_STRUCT_CONVERSION) VkResult (*p_vkCreateDescriptorUpdateTemplateKHR)(VkDevice, const VkDescriptorUpdateTemplateCreateInfo_host *, const VkAllocationCallbacks *, VkDescriptorUpdateTemplate *); #else @@ -781,6 +796,7 @@ struct vulkan_device_funcs VkResult (*p_vkCreateQueryPool)(VkDevice, const VkQueryPoolCreateInfo *, const VkAllocationCallbacks *, VkQueryPool *); VkResult (*p_vkCreateRenderPass)(VkDevice, const VkRenderPassCreateInfo *, const VkAllocationCallbacks *, VkRenderPass *); VkResult (*p_vkCreateSampler)(VkDevice, const VkSamplerCreateInfo *, const VkAllocationCallbacks *, VkSampler *); + VkResult (*p_vkCreateSamplerYcbcrConversion)(VkDevice, const VkSamplerYcbcrConversionCreateInfo *, const VkAllocationCallbacks *, VkSamplerYcbcrConversion *); VkResult (*p_vkCreateSamplerYcbcrConversionKHR)(VkDevice, const VkSamplerYcbcrConversionCreateInfo *, const VkAllocationCallbacks *, VkSamplerYcbcrConversion *); VkResult (*p_vkCreateSemaphore)(VkDevice, const VkSemaphoreCreateInfo *, const VkAllocationCallbacks *, VkSemaphore *); VkResult (*p_vkCreateShaderModule)(VkDevice, const VkShaderModuleCreateInfo *, const VkAllocationCallbacks *, VkShaderModule *); @@ -795,6 +811,7 @@ struct vulkan_device_funcs void (*p_vkDestroyCommandPool)(VkDevice, VkCommandPool, const VkAllocationCallbacks *); void (*p_vkDestroyDescriptorPool)(VkDevice, VkDescriptorPool, const VkAllocationCallbacks *); void (*p_vkDestroyDescriptorSetLayout)(VkDevice, VkDescriptorSetLayout, const VkAllocationCallbacks *); + void (*p_vkDestroyDescriptorUpdateTemplate)(VkDevice, VkDescriptorUpdateTemplate, const VkAllocationCallbacks *); void (*p_vkDestroyDescriptorUpdateTemplateKHR)(VkDevice, VkDescriptorUpdateTemplate, const VkAllocationCallbacks *); void (*p_vkDestroyDevice)(VkDevice, const VkAllocationCallbacks *); void (*p_vkDestroyEvent)(VkDevice, VkEvent, const VkAllocationCallbacks *); @@ -808,6 +825,7 @@ struct vulkan_device_funcs void (*p_vkDestroyQueryPool)(VkDevice, VkQueryPool, const VkAllocationCallbacks *); void (*p_vkDestroyRenderPass)(VkDevice, VkRenderPass, const VkAllocationCallbacks *); void (*p_vkDestroySampler)(VkDevice, VkSampler, const VkAllocationCallbacks *); + void (*p_vkDestroySamplerYcbcrConversion)(VkDevice, VkSamplerYcbcrConversion, const VkAllocationCallbacks *); void (*p_vkDestroySamplerYcbcrConversionKHR)(VkDevice, VkSamplerYcbcrConversion, const VkAllocationCallbacks *); void (*p_vkDestroySemaphore)(VkDevice, VkSemaphore, const VkAllocationCallbacks *); void (*p_vkDestroyShaderModule)(VkDevice, VkShaderModule, const VkAllocationCallbacks *); @@ -828,11 +846,17 @@ struct vulkan_device_funcs #else void (*p_vkGetBufferMemoryRequirements)(VkDevice, VkBuffer, VkMemoryRequirements *); #endif +#if defined(USE_STRUCT_CONVERSION) + void (*p_vkGetBufferMemoryRequirements2)(VkDevice, const VkBufferMemoryRequirementsInfo2_host *, VkMemoryRequirements2_host *); +#else + void (*p_vkGetBufferMemoryRequirements2)(VkDevice, const VkBufferMemoryRequirementsInfo2 *, VkMemoryRequirements2 *); +#endif #if defined(USE_STRUCT_CONVERSION) void (*p_vkGetBufferMemoryRequirements2KHR)(VkDevice, const VkBufferMemoryRequirementsInfo2_host *, VkMemoryRequirements2_host *); #else void (*p_vkGetBufferMemoryRequirements2KHR)(VkDevice, const VkBufferMemoryRequirementsInfo2 *, VkMemoryRequirements2 *); #endif + void (*p_vkGetDescriptorSetLayoutSupport)(VkDevice, const VkDescriptorSetLayoutCreateInfo *, VkDescriptorSetLayoutSupport *); void (*p_vkGetDescriptorSetLayoutSupportKHR)(VkDevice, const VkDescriptorSetLayoutCreateInfo *, VkDescriptorSetLayoutSupport *); void (*p_vkGetDeviceMemoryCommitment)(VkDevice, VkDeviceMemory, VkDeviceSize *); void (*p_vkGetDeviceQueue)(VkDevice, uint32_t, uint32_t, VkQueue *); @@ -843,12 +867,22 @@ struct vulkan_device_funcs #else void (*p_vkGetImageMemoryRequirements)(VkDevice, VkImage, VkMemoryRequirements *); #endif +#if defined(USE_STRUCT_CONVERSION) + void (*p_vkGetImageMemoryRequirements2)(VkDevice, const VkImageMemoryRequirementsInfo2_host *, VkMemoryRequirements2_host *); +#else + void (*p_vkGetImageMemoryRequirements2)(VkDevice, const VkImageMemoryRequirementsInfo2 *, VkMemoryRequirements2 *); +#endif #if defined(USE_STRUCT_CONVERSION) void (*p_vkGetImageMemoryRequirements2KHR)(VkDevice, const VkImageMemoryRequirementsInfo2_host *, VkMemoryRequirements2_host *); #else void (*p_vkGetImageMemoryRequirements2KHR)(VkDevice, const VkImageMemoryRequirementsInfo2 *, VkMemoryRequirements2 *); #endif void (*p_vkGetImageSparseMemoryRequirements)(VkDevice, VkImage, uint32_t *, VkSparseImageMemoryRequirements *); +#if defined(USE_STRUCT_CONVERSION) + void (*p_vkGetImageSparseMemoryRequirements2)(VkDevice, const VkImageSparseMemoryRequirementsInfo2_host *, uint32_t *, VkSparseImageMemoryRequirements2 *); +#else + void (*p_vkGetImageSparseMemoryRequirements2)(VkDevice, const VkImageSparseMemoryRequirementsInfo2 *, uint32_t *, VkSparseImageMemoryRequirements2 *); +#endif #if defined(USE_STRUCT_CONVERSION) void (*p_vkGetImageSparseMemoryRequirements2KHR)(VkDevice, const VkImageSparseMemoryRequirementsInfo2_host *, uint32_t *, VkSparseImageMemoryRequirements2 *); #else @@ -887,8 +921,10 @@ struct vulkan_device_funcs VkResult (*p_vkResetEvent)(VkDevice, VkEvent); VkResult (*p_vkResetFences)(VkDevice, uint32_t, const VkFence *); VkResult (*p_vkSetEvent)(VkDevice, VkEvent); + void (*p_vkTrimCommandPool)(VkDevice, VkCommandPool, VkCommandPoolTrimFlags); void (*p_vkTrimCommandPoolKHR)(VkDevice, VkCommandPool, VkCommandPoolTrimFlags); void (*p_vkUnmapMemory)(VkDevice, VkDeviceMemory); + void (*p_vkUpdateDescriptorSetWithTemplate)(VkDevice, VkDescriptorSet, VkDescriptorUpdateTemplate, const void *); void (*p_vkUpdateDescriptorSetWithTemplateKHR)(VkDevice, VkDescriptorSet, VkDescriptorUpdateTemplate, const void *); #if defined(USE_STRUCT_CONVERSION) void (*p_vkUpdateDescriptorSets)(VkDevice, uint32_t, const VkWriteDescriptorSet_host *, uint32_t, const VkCopyDescriptorSet_host *); @@ -908,14 +944,21 @@ struct vulkan_instance_funcs VkResult (*p_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice, uint32_t *, VkLayerProperties *); VkResult (*p_vkEnumeratePhysicalDevices)(VkInstance, uint32_t *, VkPhysicalDevice *); void (*p_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice, VkPhysicalDeviceFeatures *); + void (*p_vkGetPhysicalDeviceFeatures2)(VkPhysicalDevice, VkPhysicalDeviceFeatures2 *); void (*p_vkGetPhysicalDeviceFeatures2KHR)(VkPhysicalDevice, VkPhysicalDeviceFeatures2 *); void (*p_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice, VkFormat, VkFormatProperties *); + void (*p_vkGetPhysicalDeviceFormatProperties2)(VkPhysicalDevice, VkFormat, VkFormatProperties2 *); void (*p_vkGetPhysicalDeviceFormatProperties2KHR)(VkPhysicalDevice, VkFormat, VkFormatProperties2 *); #if defined(USE_STRUCT_CONVERSION) VkResult (*p_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice, VkFormat, VkImageType, VkImageTiling, VkImageUsageFlags, VkImageCreateFlags, VkImageFormatProperties_host *); #else VkResult (*p_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice, VkFormat, VkImageType, VkImageTiling, VkImageUsageFlags, VkImageCreateFlags, VkImageFormatProperties *); #endif +#if defined(USE_STRUCT_CONVERSION) + VkResult (*p_vkGetPhysicalDeviceImageFormatProperties2)(VkPhysicalDevice, const VkPhysicalDeviceImageFormatInfo2 *, VkImageFormatProperties2_host *); +#else + VkResult (*p_vkGetPhysicalDeviceImageFormatProperties2)(VkPhysicalDevice, const VkPhysicalDeviceImageFormatInfo2 *, VkImageFormatProperties2 *); +#endif #if defined(USE_STRUCT_CONVERSION) VkResult (*p_vkGetPhysicalDeviceImageFormatProperties2KHR)(VkPhysicalDevice, const VkPhysicalDeviceImageFormatInfo2 *, VkImageFormatProperties2_host *); #else @@ -926,6 +969,11 @@ struct vulkan_instance_funcs #else void (*p_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice, VkPhysicalDeviceMemoryProperties *); #endif +#if defined(USE_STRUCT_CONVERSION) + void (*p_vkGetPhysicalDeviceMemoryProperties2)(VkPhysicalDevice, VkPhysicalDeviceMemoryProperties2_host *); +#else + void (*p_vkGetPhysicalDeviceMemoryProperties2)(VkPhysicalDevice, VkPhysicalDeviceMemoryProperties2 *); +#endif #if defined(USE_STRUCT_CONVERSION) void (*p_vkGetPhysicalDeviceMemoryProperties2KHR)(VkPhysicalDevice, VkPhysicalDeviceMemoryProperties2_host *); #else @@ -937,14 +985,21 @@ struct vulkan_instance_funcs #else void (*p_vkGetPhysicalDeviceProperties)(VkPhysicalDevice, VkPhysicalDeviceProperties *); #endif +#if defined(USE_STRUCT_CONVERSION) + void (*p_vkGetPhysicalDeviceProperties2)(VkPhysicalDevice, VkPhysicalDeviceProperties2_host *); +#else + void (*p_vkGetPhysicalDeviceProperties2)(VkPhysicalDevice, VkPhysicalDeviceProperties2 *); +#endif #if defined(USE_STRUCT_CONVERSION) void (*p_vkGetPhysicalDeviceProperties2KHR)(VkPhysicalDevice, VkPhysicalDeviceProperties2_host *); #else void (*p_vkGetPhysicalDeviceProperties2KHR)(VkPhysicalDevice, VkPhysicalDeviceProperties2 *); #endif void (*p_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice, uint32_t *, VkQueueFamilyProperties *); + void (*p_vkGetPhysicalDeviceQueueFamilyProperties2)(VkPhysicalDevice, uint32_t *, VkQueueFamilyProperties2 *); void (*p_vkGetPhysicalDeviceQueueFamilyProperties2KHR)(VkPhysicalDevice, uint32_t *, VkQueueFamilyProperties2 *); void (*p_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice, VkFormat, VkImageType, VkSampleCountFlagBits, VkImageUsageFlags, VkImageTiling, uint32_t *, VkSparseImageFormatProperties *); + void (*p_vkGetPhysicalDeviceSparseImageFormatProperties2)(VkPhysicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *, uint32_t *, VkSparseImageFormatProperties2 *); void (*p_vkGetPhysicalDeviceSparseImageFormatProperties2KHR)(VkPhysicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *, uint32_t *, VkSparseImageFormatProperties2 *); VkResult (*p_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice, VkSurfaceKHR, VkSurfaceCapabilitiesKHR *); VkResult (*p_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice, VkSurfaceKHR, uint32_t *, VkSurfaceFormatKHR *); @@ -960,8 +1015,10 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkAllocateMemory) \ USE_VK_FUNC(vkBeginCommandBuffer) \ USE_VK_FUNC(vkBindBufferMemory) \ + USE_VK_FUNC(vkBindBufferMemory2) \ USE_VK_FUNC(vkBindBufferMemory2KHR) \ USE_VK_FUNC(vkBindImageMemory) \ + USE_VK_FUNC(vkBindImageMemory2) \ USE_VK_FUNC(vkBindImageMemory2KHR) \ USE_VK_FUNC(vkCmdBeginQuery) \ USE_VK_FUNC(vkCmdBeginRenderPass) \ @@ -1023,6 +1080,7 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkCreateComputePipelines) \ USE_VK_FUNC(vkCreateDescriptorPool) \ USE_VK_FUNC(vkCreateDescriptorSetLayout) \ + USE_VK_FUNC(vkCreateDescriptorUpdateTemplate) \ USE_VK_FUNC(vkCreateDescriptorUpdateTemplateKHR) \ USE_VK_FUNC(vkCreateEvent) \ USE_VK_FUNC(vkCreateFence) \ @@ -1035,6 +1093,7 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkCreateQueryPool) \ USE_VK_FUNC(vkCreateRenderPass) \ USE_VK_FUNC(vkCreateSampler) \ + USE_VK_FUNC(vkCreateSamplerYcbcrConversion) \ USE_VK_FUNC(vkCreateSamplerYcbcrConversionKHR) \ USE_VK_FUNC(vkCreateSemaphore) \ USE_VK_FUNC(vkCreateShaderModule) \ @@ -1045,6 +1104,7 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkDestroyCommandPool) \ USE_VK_FUNC(vkDestroyDescriptorPool) \ USE_VK_FUNC(vkDestroyDescriptorSetLayout) \ + USE_VK_FUNC(vkDestroyDescriptorUpdateTemplate) \ USE_VK_FUNC(vkDestroyDescriptorUpdateTemplateKHR) \ USE_VK_FUNC(vkDestroyDevice) \ USE_VK_FUNC(vkDestroyEvent) \ @@ -1058,6 +1118,7 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkDestroyQueryPool) \ USE_VK_FUNC(vkDestroyRenderPass) \ USE_VK_FUNC(vkDestroySampler) \ + USE_VK_FUNC(vkDestroySamplerYcbcrConversion) \ USE_VK_FUNC(vkDestroySamplerYcbcrConversionKHR) \ USE_VK_FUNC(vkDestroySemaphore) \ USE_VK_FUNC(vkDestroyShaderModule) \ @@ -1070,15 +1131,19 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkFreeDescriptorSets) \ USE_VK_FUNC(vkFreeMemory) \ USE_VK_FUNC(vkGetBufferMemoryRequirements) \ + USE_VK_FUNC(vkGetBufferMemoryRequirements2) \ USE_VK_FUNC(vkGetBufferMemoryRequirements2KHR) \ + USE_VK_FUNC(vkGetDescriptorSetLayoutSupport) \ USE_VK_FUNC(vkGetDescriptorSetLayoutSupportKHR) \ USE_VK_FUNC(vkGetDeviceMemoryCommitment) \ USE_VK_FUNC(vkGetDeviceQueue) \ USE_VK_FUNC(vkGetEventStatus) \ USE_VK_FUNC(vkGetFenceStatus) \ USE_VK_FUNC(vkGetImageMemoryRequirements) \ + USE_VK_FUNC(vkGetImageMemoryRequirements2) \ USE_VK_FUNC(vkGetImageMemoryRequirements2KHR) \ USE_VK_FUNC(vkGetImageSparseMemoryRequirements) \ + USE_VK_FUNC(vkGetImageSparseMemoryRequirements2) \ USE_VK_FUNC(vkGetImageSparseMemoryRequirements2KHR) \ USE_VK_FUNC(vkGetImageSubresourceLayout) \ USE_VK_FUNC(vkGetPipelineCacheData) \ @@ -1101,8 +1166,10 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkResetEvent) \ USE_VK_FUNC(vkResetFences) \ USE_VK_FUNC(vkSetEvent) \ + USE_VK_FUNC(vkTrimCommandPool) \ USE_VK_FUNC(vkTrimCommandPoolKHR) \ USE_VK_FUNC(vkUnmapMemory) \ + USE_VK_FUNC(vkUpdateDescriptorSetWithTemplate) \ USE_VK_FUNC(vkUpdateDescriptorSetWithTemplateKHR) \ USE_VK_FUNC(vkUpdateDescriptorSets) \ USE_VK_FUNC(vkWaitForFences) @@ -1115,19 +1182,26 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkEnumerateDeviceLayerProperties) \ USE_VK_FUNC(vkEnumeratePhysicalDevices) \ USE_VK_FUNC(vkGetPhysicalDeviceFeatures) \ + USE_VK_FUNC(vkGetPhysicalDeviceFeatures2) \ USE_VK_FUNC(vkGetPhysicalDeviceFeatures2KHR) \ USE_VK_FUNC(vkGetPhysicalDeviceFormatProperties) \ + USE_VK_FUNC(vkGetPhysicalDeviceFormatProperties2) \ USE_VK_FUNC(vkGetPhysicalDeviceFormatProperties2KHR) \ USE_VK_FUNC(vkGetPhysicalDeviceImageFormatProperties) \ + USE_VK_FUNC(vkGetPhysicalDeviceImageFormatProperties2) \ USE_VK_FUNC(vkGetPhysicalDeviceImageFormatProperties2KHR) \ USE_VK_FUNC(vkGetPhysicalDeviceMemoryProperties) \ + USE_VK_FUNC(vkGetPhysicalDeviceMemoryProperties2) \ USE_VK_FUNC(vkGetPhysicalDeviceMemoryProperties2KHR) \ USE_VK_FUNC(vkGetPhysicalDeviceMultisamplePropertiesEXT) \ USE_VK_FUNC(vkGetPhysicalDeviceProperties) \ + USE_VK_FUNC(vkGetPhysicalDeviceProperties2) \ USE_VK_FUNC(vkGetPhysicalDeviceProperties2KHR) \ USE_VK_FUNC(vkGetPhysicalDeviceQueueFamilyProperties) \ + USE_VK_FUNC(vkGetPhysicalDeviceQueueFamilyProperties2) \ USE_VK_FUNC(vkGetPhysicalDeviceQueueFamilyProperties2KHR) \ USE_VK_FUNC(vkGetPhysicalDeviceSparseImageFormatProperties) \ + USE_VK_FUNC(vkGetPhysicalDeviceSparseImageFormatProperties2) \ USE_VK_FUNC(vkGetPhysicalDeviceSparseImageFormatProperties2KHR) \ USE_VK_FUNC(vkGetPhysicalDeviceSurfaceCapabilitiesKHR) \ USE_VK_FUNC(vkGetPhysicalDeviceSurfaceFormatsKHR) \ diff --git a/dlls/winevulkan/winevulkan.spec b/dlls/winevulkan/winevulkan.spec index f825079ba6f6..dc43ef816b60 100644 --- a/dlls/winevulkan/winevulkan.spec +++ b/dlls/winevulkan/winevulkan.spec @@ -43,9 +43,9 @@ @ stdcall wine_vkAllocateMemory(ptr ptr ptr ptr) @ stdcall wine_vkBeginCommandBuffer(ptr ptr) @ stdcall wine_vkBindBufferMemory(ptr int64 int64 int64) -@ stub vkBindBufferMemory2 +@ stdcall wine_vkBindBufferMemory2(ptr long ptr) @ stdcall wine_vkBindImageMemory(ptr int64 int64 int64) -@ stub vkBindImageMemory2 +@ stdcall wine_vkBindImageMemory2(ptr long ptr) @ stdcall wine_vkCmdBeginQuery(ptr int64 long long) @ stdcall wine_vkCmdBeginRenderPass(ptr ptr long) @ stdcall wine_vkCmdBindDescriptorSets(ptr long int64 long long ptr long ptr) @@ -98,7 +98,7 @@ @ stdcall wine_vkCreateComputePipelines(ptr int64 long ptr ptr ptr) @ stdcall wine_vkCreateDescriptorPool(ptr ptr ptr ptr) @ stdcall wine_vkCreateDescriptorSetLayout(ptr ptr ptr ptr) -@ stub vkCreateDescriptorUpdateTemplate +@ stdcall wine_vkCreateDescriptorUpdateTemplate(ptr ptr ptr ptr) @ stdcall wine_vkCreateDevice(ptr ptr ptr ptr) @ stub vkCreateDisplayModeKHR @ stub vkCreateDisplayPlaneSurfaceKHR @@ -114,7 +114,7 @@ @ stdcall wine_vkCreateQueryPool(ptr ptr ptr ptr) @ stdcall wine_vkCreateRenderPass(ptr ptr ptr ptr) @ stdcall wine_vkCreateSampler(ptr ptr ptr ptr) -@ stub vkCreateSamplerYcbcrConversion +@ stdcall wine_vkCreateSamplerYcbcrConversion(ptr ptr ptr ptr) @ stdcall wine_vkCreateSemaphore(ptr ptr ptr ptr) @ stdcall wine_vkCreateShaderModule(ptr ptr ptr ptr) @ stub vkCreateSharedSwapchainsKHR @@ -125,7 +125,7 @@ @ stdcall wine_vkDestroyCommandPool(ptr int64 ptr) @ stdcall wine_vkDestroyDescriptorPool(ptr int64 ptr) @ stdcall wine_vkDestroyDescriptorSetLayout(ptr int64 ptr) -@ stub vkDestroyDescriptorUpdateTemplate +@ stdcall wine_vkDestroyDescriptorUpdateTemplate(ptr int64 ptr) @ stdcall wine_vkDestroyDevice(ptr ptr) @ stdcall wine_vkDestroyEvent(ptr int64 ptr) @ stdcall wine_vkDestroyFence(ptr int64 ptr) @@ -139,7 +139,7 @@ @ stdcall wine_vkDestroyQueryPool(ptr int64 ptr) @ stdcall wine_vkDestroyRenderPass(ptr int64 ptr) @ stdcall wine_vkDestroySampler(ptr int64 ptr) -@ stub vkDestroySamplerYcbcrConversion +@ stdcall wine_vkDestroySamplerYcbcrConversion(ptr int64 ptr) @ stdcall wine_vkDestroySemaphore(ptr int64 ptr) @ stdcall wine_vkDestroyShaderModule(ptr int64 ptr) @ stdcall wine_vkDestroySurfaceKHR(ptr int64 ptr) @@ -157,8 +157,8 @@ @ stdcall wine_vkFreeDescriptorSets(ptr int64 long ptr) @ stdcall wine_vkFreeMemory(ptr int64 ptr) @ stdcall wine_vkGetBufferMemoryRequirements(ptr int64 ptr) -@ stub vkGetBufferMemoryRequirements2 -@ stub vkGetDescriptorSetLayoutSupport +@ stdcall wine_vkGetBufferMemoryRequirements2(ptr ptr ptr) +@ stdcall wine_vkGetDescriptorSetLayoutSupport(ptr ptr ptr) @ stub vkGetDeviceGroupPeerMemoryFeatures @ stub vkGetDeviceGroupPresentCapabilitiesKHR @ stub vkGetDeviceGroupSurfacePresentModesKHR @@ -172,9 +172,9 @@ @ stdcall wine_vkGetEventStatus(ptr int64) @ stdcall wine_vkGetFenceStatus(ptr int64) @ stdcall wine_vkGetImageMemoryRequirements(ptr int64 ptr) -@ stub vkGetImageMemoryRequirements2 +@ stdcall wine_vkGetImageMemoryRequirements2(ptr ptr ptr) @ stdcall wine_vkGetImageSparseMemoryRequirements(ptr int64 ptr ptr) -@ stub vkGetImageSparseMemoryRequirements2 +@ stdcall wine_vkGetImageSparseMemoryRequirements2(ptr ptr ptr ptr) @ stdcall wine_vkGetImageSubresourceLayout(ptr int64 ptr ptr) @ stdcall wine_vkGetInstanceProcAddr(ptr str) @ stub vkGetPhysicalDeviceDisplayPlanePropertiesKHR @@ -183,20 +183,20 @@ @ stub vkGetPhysicalDeviceExternalFenceProperties @ stub vkGetPhysicalDeviceExternalSemaphoreProperties @ stdcall wine_vkGetPhysicalDeviceFeatures(ptr ptr) -@ stub vkGetPhysicalDeviceFeatures2 +@ stdcall wine_vkGetPhysicalDeviceFeatures2(ptr ptr) @ stdcall wine_vkGetPhysicalDeviceFormatProperties(ptr long ptr) -@ stub vkGetPhysicalDeviceFormatProperties2 +@ stdcall wine_vkGetPhysicalDeviceFormatProperties2(ptr long ptr) @ stdcall wine_vkGetPhysicalDeviceImageFormatProperties(ptr long long long long long ptr) -@ stub vkGetPhysicalDeviceImageFormatProperties2 +@ stdcall wine_vkGetPhysicalDeviceImageFormatProperties2(ptr ptr ptr) @ stdcall wine_vkGetPhysicalDeviceMemoryProperties(ptr ptr) -@ stub vkGetPhysicalDeviceMemoryProperties2 +@ stdcall wine_vkGetPhysicalDeviceMemoryProperties2(ptr ptr) @ stub vkGetPhysicalDevicePresentRectanglesKHR @ stdcall wine_vkGetPhysicalDeviceProperties(ptr ptr) -@ stub vkGetPhysicalDeviceProperties2 +@ stdcall wine_vkGetPhysicalDeviceProperties2(ptr ptr) @ stdcall wine_vkGetPhysicalDeviceQueueFamilyProperties(ptr ptr ptr) -@ stub vkGetPhysicalDeviceQueueFamilyProperties2 +@ stdcall wine_vkGetPhysicalDeviceQueueFamilyProperties2(ptr ptr ptr) @ stdcall wine_vkGetPhysicalDeviceSparseImageFormatProperties(ptr long long long long long ptr ptr) -@ stub vkGetPhysicalDeviceSparseImageFormatProperties2 +@ stdcall wine_vkGetPhysicalDeviceSparseImageFormatProperties2(ptr ptr ptr ptr) @ stdcall wine_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(ptr int64 ptr) @ stdcall wine_vkGetPhysicalDeviceSurfaceFormatsKHR(ptr int64 ptr ptr) @ stdcall wine_vkGetPhysicalDeviceSurfacePresentModesKHR(ptr int64 ptr long) @@ -219,8 +219,8 @@ @ stdcall wine_vkResetEvent(ptr int64) @ stdcall wine_vkResetFences(ptr long ptr) @ stdcall wine_vkSetEvent(ptr int64) -@ stub vkTrimCommandPool +@ stdcall wine_vkTrimCommandPool(ptr int64 long) @ stdcall wine_vkUnmapMemory(ptr int64) -@ stub vkUpdateDescriptorSetWithTemplate +@ stdcall wine_vkUpdateDescriptorSetWithTemplate(ptr int64 int64 ptr) @ stdcall wine_vkUpdateDescriptorSets(ptr long ptr long ptr) @ stdcall wine_vkWaitForFences(ptr long ptr long int64) diff --git a/include/wine/vulkan.h b/include/wine/vulkan.h index 93e0d0118ff8..d85ba8d65371 100644 --- a/include/wine/vulkan.h +++ b/include/wine/vulkan.h @@ -2992,8 +2992,10 @@ typedef VkResult (VKAPI_PTR *PFN_vkAllocateDescriptorSets)(VkDevice, const VkDes typedef VkResult (VKAPI_PTR *PFN_vkAllocateMemory)(VkDevice, const VkMemoryAllocateInfo *, const VkAllocationCallbacks *, VkDeviceMemory *); typedef VkResult (VKAPI_PTR *PFN_vkBeginCommandBuffer)(VkCommandBuffer, const VkCommandBufferBeginInfo *); typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory)(VkDevice, VkBuffer, VkDeviceMemory, VkDeviceSize); +typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2)(VkDevice, uint32_t, const VkBindBufferMemoryInfo *); typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2KHR)(VkDevice, uint32_t, const VkBindBufferMemoryInfo *); typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory)(VkDevice, VkImage, VkDeviceMemory, VkDeviceSize); +typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2)(VkDevice, uint32_t, const VkBindImageMemoryInfo *); typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2KHR)(VkDevice, uint32_t, const VkBindImageMemoryInfo *); typedef void (VKAPI_PTR *PFN_vkCmdBeginQuery)(VkCommandBuffer, VkQueryPool, uint32_t, VkQueryControlFlags); typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass)(VkCommandBuffer, const VkRenderPassBeginInfo *, VkSubpassContents); @@ -3055,6 +3057,7 @@ typedef VkResult (VKAPI_PTR *PFN_vkCreateCommandPool)(VkDevice, const VkCommandP typedef VkResult (VKAPI_PTR *PFN_vkCreateComputePipelines)(VkDevice, VkPipelineCache, uint32_t, const VkComputePipelineCreateInfo *, const VkAllocationCallbacks *, VkPipeline *); typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorPool)(VkDevice, const VkDescriptorPoolCreateInfo *, const VkAllocationCallbacks *, VkDescriptorPool *); typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorSetLayout)(VkDevice, const VkDescriptorSetLayoutCreateInfo *, const VkAllocationCallbacks *, VkDescriptorSetLayout *); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorUpdateTemplate)(VkDevice, const VkDescriptorUpdateTemplateCreateInfo *, const VkAllocationCallbacks *, VkDescriptorUpdateTemplate *); typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorUpdateTemplateKHR)(VkDevice, const VkDescriptorUpdateTemplateCreateInfo *, const VkAllocationCallbacks *, VkDescriptorUpdateTemplate *); typedef VkResult (VKAPI_PTR *PFN_vkCreateDevice)(VkPhysicalDevice, const VkDeviceCreateInfo *, const VkAllocationCallbacks *, VkDevice *); typedef VkResult (VKAPI_PTR *PFN_vkCreateEvent)(VkDevice, const VkEventCreateInfo *, const VkAllocationCallbacks *, VkEvent *); @@ -3069,6 +3072,7 @@ typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineLayout)(VkDevice, const VkPipel typedef VkResult (VKAPI_PTR *PFN_vkCreateQueryPool)(VkDevice, const VkQueryPoolCreateInfo *, const VkAllocationCallbacks *, VkQueryPool *); typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass)(VkDevice, const VkRenderPassCreateInfo *, const VkAllocationCallbacks *, VkRenderPass *); typedef VkResult (VKAPI_PTR *PFN_vkCreateSampler)(VkDevice, const VkSamplerCreateInfo *, const VkAllocationCallbacks *, VkSampler *); +typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversion)(VkDevice, const VkSamplerYcbcrConversionCreateInfo *, const VkAllocationCallbacks *, VkSamplerYcbcrConversion *); typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversionKHR)(VkDevice, const VkSamplerYcbcrConversionCreateInfo *, const VkAllocationCallbacks *, VkSamplerYcbcrConversion *); typedef VkResult (VKAPI_PTR *PFN_vkCreateSemaphore)(VkDevice, const VkSemaphoreCreateInfo *, const VkAllocationCallbacks *, VkSemaphore *); typedef VkResult (VKAPI_PTR *PFN_vkCreateShaderModule)(VkDevice, const VkShaderModuleCreateInfo *, const VkAllocationCallbacks *, VkShaderModule *); @@ -3080,6 +3084,7 @@ typedef void (VKAPI_PTR *PFN_vkDestroyBufferView)(VkDevice, VkBufferView, const typedef void (VKAPI_PTR *PFN_vkDestroyCommandPool)(VkDevice, VkCommandPool, const VkAllocationCallbacks *); typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorPool)(VkDevice, VkDescriptorPool, const VkAllocationCallbacks *); typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorSetLayout)(VkDevice, VkDescriptorSetLayout, const VkAllocationCallbacks *); +typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorUpdateTemplate)(VkDevice, VkDescriptorUpdateTemplate, const VkAllocationCallbacks *); typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorUpdateTemplateKHR)(VkDevice, VkDescriptorUpdateTemplate, const VkAllocationCallbacks *); typedef void (VKAPI_PTR *PFN_vkDestroyDevice)(VkDevice, const VkAllocationCallbacks *); typedef void (VKAPI_PTR *PFN_vkDestroyEvent)(VkDevice, VkEvent, const VkAllocationCallbacks *); @@ -3094,6 +3099,7 @@ typedef void (VKAPI_PTR *PFN_vkDestroyPipelineLayout)(VkDevice, VkPipelineLayout typedef void (VKAPI_PTR *PFN_vkDestroyQueryPool)(VkDevice, VkQueryPool, const VkAllocationCallbacks *); typedef void (VKAPI_PTR *PFN_vkDestroyRenderPass)(VkDevice, VkRenderPass, const VkAllocationCallbacks *); typedef void (VKAPI_PTR *PFN_vkDestroySampler)(VkDevice, VkSampler, const VkAllocationCallbacks *); +typedef void (VKAPI_PTR *PFN_vkDestroySamplerYcbcrConversion)(VkDevice, VkSamplerYcbcrConversion, const VkAllocationCallbacks *); typedef void (VKAPI_PTR *PFN_vkDestroySamplerYcbcrConversionKHR)(VkDevice, VkSamplerYcbcrConversion, const VkAllocationCallbacks *); typedef void (VKAPI_PTR *PFN_vkDestroySemaphore)(VkDevice, VkSemaphore, const VkAllocationCallbacks *); typedef void (VKAPI_PTR *PFN_vkDestroyShaderModule)(VkDevice, VkShaderModule, const VkAllocationCallbacks *); @@ -3112,7 +3118,9 @@ typedef void (VKAPI_PTR *PFN_vkFreeCommandBuffers)(VkDevice, VkCommandPool, uint typedef VkResult (VKAPI_PTR *PFN_vkFreeDescriptorSets)(VkDevice, VkDescriptorPool, uint32_t, const VkDescriptorSet *); typedef void (VKAPI_PTR *PFN_vkFreeMemory)(VkDevice, VkDeviceMemory, const VkAllocationCallbacks *); typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements)(VkDevice, VkBuffer, VkMemoryRequirements *); +typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2)(VkDevice, const VkBufferMemoryRequirementsInfo2 *, VkMemoryRequirements2 *); typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2KHR)(VkDevice, const VkBufferMemoryRequirementsInfo2 *, VkMemoryRequirements2 *); +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_vkGetDeviceMemoryCommitment)(VkDevice, VkDeviceMemory, VkDeviceSize *); typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetDeviceProcAddr)(VkDevice, const char *); @@ -3120,25 +3128,34 @@ typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue)(VkDevice, uint32_t, uint32_t, VkQ typedef VkResult (VKAPI_PTR *PFN_vkGetEventStatus)(VkDevice, VkEvent); typedef VkResult (VKAPI_PTR *PFN_vkGetFenceStatus)(VkDevice, VkFence); 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 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 *); typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout)(VkDevice, VkImage, const VkImageSubresource *, VkSubresourceLayout *); typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetInstanceProcAddr)(VkInstance, const char *); typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice, VkPhysicalDeviceFeatures *); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2)(VkPhysicalDevice, VkPhysicalDeviceFeatures2 *); typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2KHR)(VkPhysicalDevice, VkPhysicalDeviceFeatures2 *); typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice, VkFormat, VkFormatProperties *); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties2)(VkPhysicalDevice, VkFormat, VkFormatProperties2 *); typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties2KHR)(VkPhysicalDevice, VkFormat, VkFormatProperties2 *); typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice, VkFormat, VkImageType, VkImageTiling, VkImageUsageFlags, VkImageCreateFlags, VkImageFormatProperties *); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2)(VkPhysicalDevice, const VkPhysicalDeviceImageFormatInfo2 *, VkImageFormatProperties2 *); typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2KHR)(VkPhysicalDevice, const VkPhysicalDeviceImageFormatInfo2 *, VkImageFormatProperties2 *); typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice, VkPhysicalDeviceMemoryProperties *); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2)(VkPhysicalDevice, VkPhysicalDeviceMemoryProperties2 *); typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2KHR)(VkPhysicalDevice, VkPhysicalDeviceMemoryProperties2 *); typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT)(VkPhysicalDevice, VkSampleCountFlagBits, VkMultisamplePropertiesEXT *); typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice, VkPhysicalDeviceProperties *); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2)(VkPhysicalDevice, VkPhysicalDeviceProperties2 *); typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2KHR)(VkPhysicalDevice, VkPhysicalDeviceProperties2 *); typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice, uint32_t *, VkQueueFamilyProperties *); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties2)(VkPhysicalDevice, uint32_t *, VkQueueFamilyProperties2 *); typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR)(VkPhysicalDevice, uint32_t *, VkQueueFamilyProperties2 *); typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice, VkFormat, VkImageType, VkSampleCountFlagBits, VkImageUsageFlags, VkImageTiling, uint32_t *, VkSparseImageFormatProperties *); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2)(VkPhysicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *, uint32_t *, VkSparseImageFormatProperties2 *); typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR)(VkPhysicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *, uint32_t *, VkSparseImageFormatProperties2 *); typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice, VkSurfaceKHR, VkSurfaceCapabilitiesKHR *); typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice, VkSurfaceKHR, uint32_t *, VkSurfaceFormatKHR *); @@ -3165,8 +3182,10 @@ typedef VkResult (VKAPI_PTR *PFN_vkResetDescriptorPool)(VkDevice, VkDescriptorPo typedef VkResult (VKAPI_PTR *PFN_vkResetEvent)(VkDevice, VkEvent); typedef VkResult (VKAPI_PTR *PFN_vkResetFences)(VkDevice, uint32_t, const VkFence *); typedef VkResult (VKAPI_PTR *PFN_vkSetEvent)(VkDevice, VkEvent); +typedef void (VKAPI_PTR *PFN_vkTrimCommandPool)(VkDevice, VkCommandPool, VkCommandPoolTrimFlags); typedef void (VKAPI_PTR *PFN_vkTrimCommandPoolKHR)(VkDevice, VkCommandPool, VkCommandPoolTrimFlags); typedef void (VKAPI_PTR *PFN_vkUnmapMemory)(VkDevice, VkDeviceMemory); +typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplate)(VkDevice, VkDescriptorSet, VkDescriptorUpdateTemplate, const void *); typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplateKHR)(VkDevice, VkDescriptorSet, VkDescriptorUpdateTemplate, const void *); typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSets)(VkDevice, uint32_t, const VkWriteDescriptorSet *, uint32_t, const VkCopyDescriptorSet *); typedef VkResult (VKAPI_PTR *PFN_vkWaitForFences)(VkDevice, uint32_t, const VkFence *, VkBool32, uint64_t); @@ -3178,8 +3197,10 @@ VkResult VKAPI_CALL vkAllocateDescriptorSets(VkDevice device, const VkDescriptor VkResult VKAPI_CALL vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo, const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMemory); VkResult VKAPI_CALL vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo); VkResult VKAPI_CALL vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset); +VkResult VKAPI_CALL vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos); VkResult VKAPI_CALL vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos); VkResult VKAPI_CALL vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset); +VkResult VKAPI_CALL vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos); VkResult VKAPI_CALL vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos); void VKAPI_CALL vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags); void VKAPI_CALL vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, VkSubpassContents contents); @@ -3241,6 +3262,7 @@ VkResult VKAPI_CALL vkCreateCommandPool(VkDevice device, const VkCommandPoolCrea VkResult VKAPI_CALL vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines); VkResult VKAPI_CALL vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorPool *pDescriptorPool); VkResult VKAPI_CALL vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorSetLayout *pSetLayout); +VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate); VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplateKHR(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate); VkResult VKAPI_CALL vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDevice *pDevice); VkResult VKAPI_CALL vkCreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkEvent *pEvent); @@ -3255,6 +3277,7 @@ VkResult VKAPI_CALL vkCreatePipelineLayout(VkDevice device, const VkPipelineLayo VkResult VKAPI_CALL vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkQueryPool *pQueryPool); VkResult VKAPI_CALL vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass); VkResult VKAPI_CALL vkCreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSampler *pSampler); +VkResult VKAPI_CALL vkCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion); VkResult VKAPI_CALL vkCreateSamplerYcbcrConversionKHR(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion); VkResult VKAPI_CALL vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore); VkResult VKAPI_CALL vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkShaderModule *pShaderModule); @@ -3266,6 +3289,7 @@ void VKAPI_CALL vkDestroyBufferView(VkDevice device, VkBufferView bufferView, co void VKAPI_CALL vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator); void VKAPI_CALL vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks *pAllocator); void VKAPI_CALL vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks *pAllocator); +void VKAPI_CALL vkDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator); void VKAPI_CALL vkDestroyDescriptorUpdateTemplateKHR(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator); void VKAPI_CALL vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator); void VKAPI_CALL vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator); @@ -3280,6 +3304,7 @@ void VKAPI_CALL vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipeli void VKAPI_CALL vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks *pAllocator); void VKAPI_CALL vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator); void VKAPI_CALL vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks *pAllocator); +void VKAPI_CALL vkDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator); void VKAPI_CALL vkDestroySamplerYcbcrConversionKHR(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator); void VKAPI_CALL vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator); void VKAPI_CALL vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks *pAllocator); @@ -3298,7 +3323,9 @@ void VKAPI_CALL vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, VkResult VKAPI_CALL vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets); void VKAPI_CALL vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks *pAllocator); void VKAPI_CALL vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements *pMemoryRequirements); +void VKAPI_CALL vkGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements); void VKAPI_CALL vkGetBufferMemoryRequirements2KHR(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements); +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 vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize *pCommittedMemoryInBytes); PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkDevice device, const char *pName); @@ -3306,25 +3333,34 @@ void VKAPI_CALL vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uin VkResult VKAPI_CALL vkGetEventStatus(VkDevice device, VkEvent event); VkResult VKAPI_CALL vkGetFenceStatus(VkDevice device, VkFence fence); 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); 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); void VKAPI_CALL vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource *pSubresource, VkSubresourceLayout *pLayout); PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(VkInstance instance, const char *pName); void VKAPI_CALL vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures); +void VKAPI_CALL vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures); void VKAPI_CALL vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures); void VKAPI_CALL vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties *pFormatProperties); +void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties); void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties); VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties *pImageFormatProperties); +VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties); VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties); void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties *pMemoryProperties); +void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties); void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties); void VKAPI_CALL vkGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT *pMultisampleProperties); void VKAPI_CALL vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties); +void VKAPI_CALL vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties); void VKAPI_CALL vkGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties); void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties *pQueueFamilyProperties); +void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties); void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties); void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t *pPropertyCount, VkSparseImageFormatProperties *pProperties); +void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties); void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties); VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *pSurfaceCapabilities); VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pSurfaceFormatCount, VkSurfaceFormatKHR *pSurfaceFormats); @@ -3351,8 +3387,10 @@ VkResult VKAPI_CALL vkResetDescriptorPool(VkDevice device, VkDescriptorPool desc VkResult VKAPI_CALL vkResetEvent(VkDevice device, VkEvent event); VkResult VKAPI_CALL vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences); VkResult VKAPI_CALL vkSetEvent(VkDevice device, VkEvent event); +void VKAPI_CALL vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags); void VKAPI_CALL vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags); void VKAPI_CALL vkUnmapMemory(VkDevice device, VkDeviceMemory memory); +void VKAPI_CALL vkUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData); void VKAPI_CALL vkUpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData); void VKAPI_CALL vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet *pDescriptorCopies); VkResult VKAPI_CALL vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll, uint64_t timeout); -- 2.16.4

1 0