[PATCH 1/5] winevulkan/winex11: Add VK_KHR_display stub implementation.
Roderick Colenbrander
thunderbird2k at gmail.com
Tue Mar 27 02:00:02 CDT 2018
Signed-off-by: Roderick Colenbrander <thunderbird2k at gmail.com>
---
dlls/winevulkan/make_vulkan | 14 +-
dlls/winevulkan/vulkan.c | 117 +++++
dlls/winevulkan/vulkan_thunks.c | 59 +++
dlls/winevulkan/vulkan_thunks.h | 70 +++
dlls/winex11.drv/vulkan.c | 77 +++-
include/wine/vulkan.h | 952 ++++++++++++++++++++++------------------
include/wine/vulkan_driver.h | 9 +-
7 files changed, 861 insertions(+), 437 deletions(-)
diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan
index 2858309c06..bb02b2aa92 100755
--- a/dlls/winevulkan/make_vulkan
+++ b/dlls/winevulkan/make_vulkan
@@ -80,6 +80,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_display",
"VK_KHR_get_physical_device_properties2",
"VK_KHR_surface",
"VK_KHR_win32_surface",
@@ -95,7 +96,7 @@ BLACKLISTED_EXTENSIONS = [
"VK_EXT_display_control", # Requires VK_EXT_display_surface_counter
"VK_EXT_hdr_metadata", # Needs WSI work.
"VK_GOOGLE_display_timing",
- "VK_KHR_display", # Needs WSI work.
+ "VK_KHR_display_swapchain",
"VK_KHR_external_fence_fd",
"VK_KHR_external_fence_win32",
"VK_KHR_external_memory",
@@ -109,7 +110,7 @@ BLACKLISTED_EXTENSIONS = [
# Functions part of our winevulkan graphics driver interface.
# DRIVER_VERSION should be bumped on any change to driver interface
# in FUNCTION_OVERRIDES
-DRIVER_VERSION = 3
+DRIVER_VERSION = 4
# Table of functions for which we have a special implementation.
# This are regular device / instance functions for which we need
@@ -140,6 +141,15 @@ FUNCTION_OVERRIDES = {
"vkGetDeviceQueue" : {"dispatch": True, "driver" : False, "thunk" : False},
"vkQueueSubmit" : {"dispatch": True, "driver" : False, "thunk" : False},
+ # VK_KHR_display
+ "vkCreateDisplayModeKHR" : {"dispatch" : True, "driver" : True, "thunk" : True},
+ "vkCreateDisplayPlaneSurfaceKHR" : {"dispatch" : True, "driver" : True, "thunk" : True},
+ "vkGetDisplayModePropertiesKHR" : {"dispatch" : True, "driver" : True, "thunk" : False},
+ "vkGetDisplayPlaneCapabilitiesKHR" : {"dispatch" : True, "driver" : True, "thunk" : True},
+ "vkGetDisplayPlaneSupportedDisplaysKHR" : {"dispatch" : True, "driver" : True, "thunk" : True},
+ "vkGetPhysicalDeviceDisplayPropertiesKHR" : {"dispatch" : True, "driver" : True, "thunk" : False},
+ "vkGetPhysicalDeviceDisplayPlanePropertiesKHR" : {"dispatch" : True, "driver" : True, "thunk" : False},
+
# VK_KHR_surface
"vkDestroySurfaceKHR" : {"dispatch" : True, "driver" : True, "thunk" : True},
"vkGetPhysicalDeviceSurfaceSupportKHR" : {"dispatch" : True, "driver" : True, "thunk" : True},
diff --git a/dlls/winevulkan/vulkan.c b/dlls/winevulkan/vulkan.c
index ad1a35c934..809fd7203c 100644
--- a/dlls/winevulkan/vulkan.c
+++ b/dlls/winevulkan/vulkan.c
@@ -861,6 +861,123 @@ void WINAPI wine_vkGetDeviceQueue(VkDevice device, uint32_t family_index,
*queue = &device->queues[family_index][queue_index];
}
+VkResult WINAPI wine_vkGetDisplayModePropertiesKHR(VkPhysicalDevice phys_dev,
+ VkDisplayKHR display, uint32_t *count, VkDisplayModePropertiesKHR *properties)
+{
+#if defined(USE_STRUCT_CONVERSION)
+ VkResult result;
+ VkDisplayModePropertiesKHR_host *properties_host = NULL;
+ TRACE("%p, 0x%s, %p, %p\n", phys_dev, wine_dbgstr_longlong(display), count, properties);
+
+ if (properties)
+ {
+ properties_host = heap_calloc(*count, sizeof(*properties_host));
+ if (!properties_host)
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+ }
+
+ result = phys_dev->instance->funcs.p_vkGetDisplayModePropertiesKHR(phys_dev->phys_dev,
+ display, count, properties_host);
+
+ if (properties_host && (result == VK_SUCCESS || result == VK_INCOMPLETE))
+ {
+ unsigned int i;
+ for (i = 0; i < *count; i++)
+ {
+ properties[i].displayMode = properties_host[i].displayMode;
+ properties[i].parameters = properties_host[i].parameters;
+ }
+ }
+
+ heap_free(properties_host);
+ return result;
+#else
+ TRACE("%p, 0x%s, %p, %p\n", phys_dev, wine_dbgstr_longlong(display), count, properties);
+ return phys_dev->instance->funcs.p_vkGetDisplayModePropertiesKHR(phys_dev->phys_dev,
+ display, count, properties);
+#endif
+}
+
+VkResult WINAPI wine_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice phys_dev,
+ uint32_t *count, VkDisplayPlanePropertiesKHR *properties)
+{
+#if defined(USE_STRUCT_CONVERSION)
+ VkResult result;
+ VkDisplayPlanePropertiesKHR_host *properties_host = NULL;
+ TRACE("%p, %p, %p\n", phys_dev, count, properties);
+
+ if (properties)
+ {
+ properties_host = heap_calloc(*count, sizeof(*properties_host));
+ if (!properties_host)
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+ }
+
+ result = phys_dev->instance->funcs.p_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(phys_dev->phys_dev,
+ count, properties_host);
+
+ if (properties_host && (result == VK_SUCCESS || result == VK_INCOMPLETE))
+ {
+ unsigned int i;
+ for (i = 0; i < *count; i++)
+ {
+ properties[i].currentDisplay = properties_host[i].currentDisplay;
+ properties[i].currentStackIndex = properties_host[i].currentStackIndex;
+ }
+ }
+
+ heap_free(properties_host);
+ return result;
+#else
+ TRACE("%p, %p, %p\n", phys_dev, count, properties);
+ return phys_dev->instance->funcs.p_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(phys_dev->phys_dev,
+ count, properties);
+#endif
+}
+
+VkResult WINAPI wine_vkGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice phys_dev,
+ uint32_t *count, VkDisplayPropertiesKHR *properties)
+{
+#if defined(USE_STRUCT_CONVERSION)
+ VkResult result;
+ VkDisplayPropertiesKHR_host *properties_host = NULL;
+ TRACE("%p, %p, %p\n", phys_dev, count, properties);
+
+ if (properties)
+ {
+ properties_host = heap_calloc(*count, sizeof(*properties_host));
+ if (!properties_host)
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+ }
+
+ result = phys_dev->instance->funcs.p_vkGetPhysicalDeviceDisplayPropertiesKHR(phys_dev->phys_dev,
+ count, properties_host);
+
+ if (properties_host && (result == VK_SUCCESS || result == VK_INCOMPLETE))
+ {
+ unsigned int i;
+ for (i = 0; i < *count; i++)
+ {
+ properties[i].display = properties_host[i].display;
+ properties[i].displayName = properties_host[i].displayName;
+ properties[i].physicalDimensions = properties_host[i].physicalDimensions;
+ properties[i].physicalResolution = properties_host[i].physicalResolution;
+ properties[i].supportedTransforms = properties_host[i].supportedTransforms;
+ properties[i].planeReorderPossible = properties_host[i].planeReorderPossible;
+ properties[i].persistentContent = properties_host[i].persistentContent;
+ }
+ }
+
+ heap_free(properties_host);
+ return result;
+#else
+ TRACE("%p, %p, %p\n", phys_dev, count, properties);
+ return phys_dev->instance->funcs.p_vkGetPhysicalDeviceDisplayPropertiesKHR(phys_dev->phys_dev,
+ count, properties);
+#endif
+}
+
+
static PFN_vkVoidFunction WINAPI wine_vkGetInstanceProcAddr(VkInstance instance, const char *name)
{
void *func;
diff --git a/dlls/winevulkan/vulkan_thunks.c b/dlls/winevulkan/vulkan_thunks.c
index 2f2b8c196f..40e7f76c8f 100644
--- a/dlls/winevulkan/vulkan_thunks.c
+++ b/dlls/winevulkan/vulkan_thunks.c
@@ -381,6 +381,22 @@ static inline void convert_VkDescriptorUpdateTemplateCreateInfoKHR_win_to_host(c
out->set = in->set;
}
+static inline void convert_VkDisplaySurfaceCreateInfoKHR_win_to_host(const VkDisplaySurfaceCreateInfoKHR *in, VkDisplaySurfaceCreateInfoKHR_host *out)
+{
+ if (!in) return;
+
+ out->sType = in->sType;
+ out->pNext = in->pNext;
+ out->flags = in->flags;
+ out->displayMode = in->displayMode;
+ out->planeIndex = in->planeIndex;
+ out->planeStackIndex = in->planeStackIndex;
+ out->transform = in->transform;
+ out->globalAlpha = in->globalAlpha;
+ out->alphaMode = in->alphaMode;
+ out->imageExtent = in->imageExtent;
+}
+
static inline void convert_VkFramebufferCreateInfo_win_to_host(const VkFramebufferCreateInfo *in, VkFramebufferCreateInfo_host *out)
{
if (!in) return;
@@ -1518,6 +1534,29 @@ static VkResult WINAPI wine_vkCreateDescriptorUpdateTemplateKHR(VkDevice device,
#endif
}
+static VkResult WINAPI wine_vkCreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDisplayModeKHR *pMode)
+{
+ TRACE("%p, 0x%s, %p, %p, %p\n", physicalDevice, wine_dbgstr_longlong(display), pCreateInfo, pAllocator, pMode);
+ return physicalDevice->instance->funcs.p_vkCreateDisplayModeKHR(physicalDevice->phys_dev, display, pCreateInfo, NULL, pMode);
+}
+
+static VkResult WINAPI wine_vkCreateDisplayPlaneSurfaceKHR(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
+{
+#if defined(USE_STRUCT_CONVERSION)
+ VkResult result;
+ VkDisplaySurfaceCreateInfoKHR_host pCreateInfo_host;
+ TRACE("%p, %p, %p, %p\n", instance, pCreateInfo, pAllocator, pSurface);
+
+ convert_VkDisplaySurfaceCreateInfoKHR_win_to_host(pCreateInfo, &pCreateInfo_host);
+ result = instance->funcs.p_vkCreateDisplayPlaneSurfaceKHR(instance->instance, &pCreateInfo_host, NULL, pSurface);
+
+ return result;
+#else
+ TRACE("%p, %p, %p, %p\n", instance, pCreateInfo, pAllocator, pSurface);
+ return instance->funcs.p_vkCreateDisplayPlaneSurfaceKHR(instance->instance, pCreateInfo, NULL, pSurface);
+#endif
+}
+
static VkResult WINAPI wine_vkCreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkEvent *pEvent)
{
TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pEvent);
@@ -1848,6 +1887,18 @@ static void WINAPI wine_vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMem
device->funcs.p_vkGetDeviceMemoryCommitment(device->device, memory, pCommittedMemoryInBytes);
}
+static VkResult WINAPI wine_vkGetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR *pCapabilities)
+{
+ TRACE("%p, 0x%s, %u, %p\n", physicalDevice, wine_dbgstr_longlong(mode), planeIndex, pCapabilities);
+ return physicalDevice->instance->funcs.p_vkGetDisplayPlaneCapabilitiesKHR(physicalDevice->phys_dev, mode, planeIndex, pCapabilities);
+}
+
+static VkResult WINAPI wine_vkGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t *pDisplayCount, VkDisplayKHR *pDisplays)
+{
+ TRACE("%p, %u, %p, %p\n", physicalDevice, planeIndex, pDisplayCount, pDisplays);
+ return physicalDevice->instance->funcs.p_vkGetDisplayPlaneSupportedDisplaysKHR(physicalDevice->phys_dev, planeIndex, pDisplayCount, pDisplays);
+}
+
static VkResult WINAPI wine_vkGetEventStatus(VkDevice device, VkEvent event)
{
TRACE("%p, 0x%s\n", device, wine_dbgstr_longlong(event));
@@ -2377,12 +2428,19 @@ static const struct vulkan_func vk_device_dispatch_table[] =
static const struct vulkan_func vk_instance_dispatch_table[] =
{
{"vkCreateDevice", &wine_vkCreateDevice},
+ {"vkCreateDisplayModeKHR", &wine_vkCreateDisplayModeKHR},
+ {"vkCreateDisplayPlaneSurfaceKHR", &wine_vkCreateDisplayPlaneSurfaceKHR},
{"vkCreateWin32SurfaceKHR", &wine_vkCreateWin32SurfaceKHR},
{"vkDestroyInstance", &wine_vkDestroyInstance},
{"vkDestroySurfaceKHR", &wine_vkDestroySurfaceKHR},
{"vkEnumerateDeviceExtensionProperties", &wine_vkEnumerateDeviceExtensionProperties},
{"vkEnumerateDeviceLayerProperties", &wine_vkEnumerateDeviceLayerProperties},
{"vkEnumeratePhysicalDevices", &wine_vkEnumeratePhysicalDevices},
+ {"vkGetDisplayModePropertiesKHR", &wine_vkGetDisplayModePropertiesKHR},
+ {"vkGetDisplayPlaneCapabilitiesKHR", &wine_vkGetDisplayPlaneCapabilitiesKHR},
+ {"vkGetDisplayPlaneSupportedDisplaysKHR", &wine_vkGetDisplayPlaneSupportedDisplaysKHR},
+ {"vkGetPhysicalDeviceDisplayPlanePropertiesKHR", &wine_vkGetPhysicalDeviceDisplayPlanePropertiesKHR},
+ {"vkGetPhysicalDeviceDisplayPropertiesKHR", &wine_vkGetPhysicalDeviceDisplayPropertiesKHR},
{"vkGetPhysicalDeviceFeatures", &wine_vkGetPhysicalDeviceFeatures},
{"vkGetPhysicalDeviceFeatures2KHR", &wine_vkGetPhysicalDeviceFeatures2KHR},
{"vkGetPhysicalDeviceFormatProperties", &wine_vkGetPhysicalDeviceFormatProperties},
@@ -2467,6 +2525,7 @@ static const char * const vk_device_extensions[] =
static const char * const vk_instance_extensions[] =
{
+ "VK_KHR_display",
"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 fb9afdf524..00495d72c0 100644
--- a/dlls/winevulkan/vulkan_thunks.h
+++ b/dlls/winevulkan/vulkan_thunks.h
@@ -26,6 +26,9 @@ VkResult WINAPI wine_vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *p
void WINAPI wine_vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers) DECLSPEC_HIDDEN;
PFN_vkVoidFunction WINAPI wine_vkGetDeviceProcAddr(VkDevice device, const char *pName) DECLSPEC_HIDDEN;
void WINAPI wine_vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue) DECLSPEC_HIDDEN;
+VkResult WINAPI wine_vkGetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t *pPropertyCount, VkDisplayModePropertiesKHR *pProperties) DECLSPEC_HIDDEN;
+VkResult WINAPI wine_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPlanePropertiesKHR *pProperties) DECLSPEC_HIDDEN;
+VkResult WINAPI wine_vkGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPropertiesKHR *pProperties) DECLSPEC_HIDDEN;
VkResult WINAPI wine_vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence) DECLSPEC_HIDDEN;
typedef struct VkCommandBufferAllocateInfo_host
@@ -216,6 +219,20 @@ typedef struct VkDescriptorUpdateTemplateCreateInfoKHR_host
uint32_t set;
} VkDescriptorUpdateTemplateCreateInfoKHR_host;
+typedef struct VkDisplaySurfaceCreateInfoKHR_host
+{
+ VkStructureType sType;
+ const void *pNext;
+ VkDisplaySurfaceCreateFlagsKHR flags;
+ VkDisplayModeKHR displayMode;
+ uint32_t planeIndex;
+ uint32_t planeStackIndex;
+ VkSurfaceTransformFlagBitsKHR transform;
+ float globalAlpha;
+ VkDisplayPlaneAlphaFlagBitsKHR alphaMode;
+ VkExtent2D imageExtent;
+} VkDisplaySurfaceCreateInfoKHR_host;
+
typedef struct VkFramebufferCreateInfo_host
{
VkStructureType sType;
@@ -302,6 +319,12 @@ typedef struct VkMemoryRequirements_host
uint32_t memoryTypeBits;
} VkMemoryRequirements_host;
+typedef struct VkDisplayModePropertiesKHR_host
+{
+ VkDisplayModeKHR displayMode;
+ VkDisplayModeParametersKHR parameters;
+} VkDisplayModePropertiesKHR_host;
+
typedef struct VkSubresourceLayout_host
{
VkDeviceSize offset;
@@ -311,6 +334,23 @@ typedef struct VkSubresourceLayout_host
VkDeviceSize depthPitch;
} VkSubresourceLayout_host;
+typedef struct VkDisplayPlanePropertiesKHR_host
+{
+ VkDisplayKHR currentDisplay;
+ uint32_t currentStackIndex;
+} VkDisplayPlanePropertiesKHR_host;
+
+typedef struct VkDisplayPropertiesKHR_host
+{
+ VkDisplayKHR display;
+ const char *displayName;
+ VkExtent2D physicalDimensions;
+ VkExtent2D physicalResolution;
+ VkSurfaceTransformFlagsKHR supportedTransforms;
+ VkBool32 planeReorderPossible;
+ VkBool32 persistentContent;
+} VkDisplayPropertiesKHR_host;
+
typedef struct VkImageFormatProperties_host
{
VkExtent3D maxExtent;
@@ -796,11 +836,34 @@ struct vulkan_device_funcs
struct vulkan_instance_funcs
{
VkResult (*p_vkCreateDevice)(VkPhysicalDevice, const VkDeviceCreateInfo *, const VkAllocationCallbacks *, VkDevice *);
+ VkResult (*p_vkCreateDisplayModeKHR)(VkPhysicalDevice, VkDisplayKHR, const VkDisplayModeCreateInfoKHR *, const VkAllocationCallbacks *, VkDisplayModeKHR *);
+#if defined(USE_STRUCT_CONVERSION)
+ VkResult (*p_vkCreateDisplayPlaneSurfaceKHR)(VkInstance, const VkDisplaySurfaceCreateInfoKHR_host *, const VkAllocationCallbacks *, VkSurfaceKHR *);
+#else
+ VkResult (*p_vkCreateDisplayPlaneSurfaceKHR)(VkInstance, const VkDisplaySurfaceCreateInfoKHR *, const VkAllocationCallbacks *, VkSurfaceKHR *);
+#endif
VkResult (*p_vkCreateWin32SurfaceKHR)(VkInstance, const VkWin32SurfaceCreateInfoKHR *, const VkAllocationCallbacks *, VkSurfaceKHR *);
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_vkEnumeratePhysicalDevices)(VkInstance, uint32_t *, VkPhysicalDevice *);
+#if defined(USE_STRUCT_CONVERSION)
+ VkResult (*p_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice, VkDisplayKHR, uint32_t *, VkDisplayModePropertiesKHR_host *);
+#else
+ VkResult (*p_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice, VkDisplayKHR, uint32_t *, VkDisplayModePropertiesKHR *);
+#endif
+ VkResult (*p_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice, VkDisplayModeKHR, uint32_t, VkDisplayPlaneCapabilitiesKHR *);
+ VkResult (*p_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice, uint32_t, uint32_t *, VkDisplayKHR *);
+#if defined(USE_STRUCT_CONVERSION)
+ VkResult (*p_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice, uint32_t *, VkDisplayPlanePropertiesKHR_host *);
+#else
+ VkResult (*p_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice, uint32_t *, VkDisplayPlanePropertiesKHR *);
+#endif
+#if defined(USE_STRUCT_CONVERSION)
+ VkResult (*p_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice, uint32_t *, VkDisplayPropertiesKHR_host *);
+#else
+ VkResult (*p_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice, uint32_t *, VkDisplayPropertiesKHR *);
+#endif
void (*p_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice, VkPhysicalDeviceFeatures *);
void (*p_vkGetPhysicalDeviceFeatures2KHR)(VkPhysicalDevice, VkPhysicalDeviceFeatures2KHR *);
void (*p_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice, VkFormat, VkFormatProperties *);
@@ -985,11 +1048,18 @@ struct vulkan_instance_funcs
#define ALL_VK_INSTANCE_FUNCS() \
USE_VK_FUNC(vkCreateDevice) \
+ USE_VK_FUNC(vkCreateDisplayModeKHR) \
+ USE_VK_FUNC(vkCreateDisplayPlaneSurfaceKHR) \
USE_VK_FUNC(vkCreateWin32SurfaceKHR) \
USE_VK_FUNC(vkDestroySurfaceKHR) \
USE_VK_FUNC(vkEnumerateDeviceExtensionProperties) \
USE_VK_FUNC(vkEnumerateDeviceLayerProperties) \
USE_VK_FUNC(vkEnumeratePhysicalDevices) \
+ USE_VK_FUNC(vkGetDisplayModePropertiesKHR) \
+ USE_VK_FUNC(vkGetDisplayPlaneCapabilitiesKHR) \
+ USE_VK_FUNC(vkGetDisplayPlaneSupportedDisplaysKHR) \
+ USE_VK_FUNC(vkGetPhysicalDeviceDisplayPlanePropertiesKHR) \
+ USE_VK_FUNC(vkGetPhysicalDeviceDisplayPropertiesKHR) \
USE_VK_FUNC(vkGetPhysicalDeviceFeatures) \
USE_VK_FUNC(vkGetPhysicalDeviceFeatures2KHR) \
USE_VK_FUNC(vkGetPhysicalDeviceFormatProperties) \
diff --git a/dlls/winex11.drv/vulkan.c b/dlls/winex11.drv/vulkan.c
index c633579286..deefe67fdc 100644
--- a/dlls/winex11.drv/vulkan.c
+++ b/dlls/winex11.drv/vulkan.c
@@ -233,6 +233,23 @@ static VkResult X11DRV_vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swa
return pvkAcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, index);
}
+static VkResult X11DRV_vkCreateDisplayModeKHR(VkPhysicalDevice phys_dev,
+ VkDisplayKHR display, const VkDisplayModeCreateInfoKHR *create_info,
+ const VkAllocationCallbacks *allocator, VkDisplayModeKHR *mode)
+{
+ FIXME("stub: %p 0x%s %p %p %p\n", phys_dev, wine_dbgstr_longlong(display),
+ create_info, allocator, mode);
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+}
+
+static VkResult X11DRV_vkCreateDisplayPlaneSurfaceKHR(VkInstance instance,
+ const VkDisplaySurfaceCreateInfoKHR *create_info,
+ const VkAllocationCallbacks *allocator, VkSurfaceKHR *surface)
+{
+ FIXME("stub: %p %p %p %p\n", instance, create_info, allocator, surface);
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+}
+
static VkResult X11DRV_vkCreateInstance(const VkInstanceCreateInfo *create_info,
const VkAllocationCallbacks *allocator, VkInstance *instance)
{
@@ -410,7 +427,30 @@ static void *X11DRV_vkGetDeviceProcAddr(VkDevice device, const char *name)
return pvkGetDeviceProcAddr(device, name);
}
-static void *X11DRV_vkGetInstanceProcAddr(VkInstance instance, const char *name)
+static VkResult X11DRV_vkGetDisplayModePropertiesKHR(VkPhysicalDevice phys_dev,
+ VkDisplayKHR display, uint32_t *count, VkDisplayModePropertiesKHR *properties)
+{
+ FIXME("stub: %p 0x%s %p %p\n", phys_dev, wine_dbgstr_longlong(display), count,
+ properties);
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+}
+
+static VkResult X11DRV_vkGetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice phys_dev,
+ VkDisplayModeKHR mode, uint32_t index, VkDisplayPlaneCapabilitiesKHR *capabilities)
+{
+ FIXME("stub: %p 0x%s %u %p\n", phys_dev, wine_dbgstr_longlong(mode), index,
+ capabilities);
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+}
+
+static VkResult X11DRV_vkGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice phys_dev,
+ uint32_t index, uint32_t *count, VkDisplayKHR *displays)
+{
+ FIXME("stub: %p %u %p %p\n", phys_dev, index, count, displays);
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+}
+
+static void * X11DRV_vkGetInstanceProcAddr(VkInstance instance, const char *name)
{
void *proc_addr;
@@ -422,6 +462,20 @@ static void *X11DRV_vkGetInstanceProcAddr(VkInstance instance, const char *name)
return pvkGetInstanceProcAddr(instance, name);
}
+static VkResult X11DRV_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice phys_dev,
+ uint32_t *count, VkDisplayPlanePropertiesKHR *properties)
+{
+ FIXME("stub: %p %p %p\n", phys_dev, count, properties);
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+}
+
+static VkResult X11DRV_vkGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice phys_dev,
+ uint32_t *count, VkDisplayPropertiesKHR *properties)
+{
+ FIXME("stub: %p %p %p\n", phys_dev, count, properties);
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+}
+
static VkResult X11DRV_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice phys_dev,
VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *capabilities)
{
@@ -491,6 +545,8 @@ static VkResult X11DRV_vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *
static const struct vulkan_funcs vulkan_funcs =
{
X11DRV_vkAcquireNextImageKHR,
+ X11DRV_vkCreateDisplayModeKHR,
+ X11DRV_vkCreateDisplayPlaneSurfaceKHR,
X11DRV_vkCreateInstance,
X11DRV_vkCreateSwapchainKHR,
X11DRV_vkCreateWin32SurfaceKHR,
@@ -499,7 +555,12 @@ static const struct vulkan_funcs vulkan_funcs =
X11DRV_vkDestroySwapchainKHR,
X11DRV_vkEnumerateInstanceExtensionProperties,
X11DRV_vkGetDeviceProcAddr,
+ X11DRV_vkGetDisplayModePropertiesKHR,
+ X11DRV_vkGetDisplayPlaneCapabilitiesKHR,
+ X11DRV_vkGetDisplayPlaneSupportedDisplaysKHR,
X11DRV_vkGetInstanceProcAddr,
+ X11DRV_vkGetPhysicalDeviceDisplayPlanePropertiesKHR,
+ X11DRV_vkGetPhysicalDeviceDisplayPropertiesKHR,
X11DRV_vkGetPhysicalDeviceSurfaceCapabilitiesKHR,
X11DRV_vkGetPhysicalDeviceSurfaceFormatsKHR,
X11DRV_vkGetPhysicalDeviceSurfacePresentModesKHR,
@@ -525,14 +586,28 @@ static void *get_vulkan_driver_instance_proc_addr(const struct vulkan_funcs *vul
if (!instance)
return NULL;
+ if (!strcmp(name, "vkCreateDisplayModeKHR"))
+ return vulkan_funcs->p_vkCreateDisplayModeKHR;
+ if (!strcmp(name, "vkCreateDisplayPlaneSurfaceKHR"))
+ return vulkan_funcs->p_vkCreateDisplayPlaneSurfaceKHR;
if (!strcmp(name, "CreateWin32SurfaceKHR"))
return vulkan_funcs->p_vkCreateWin32SurfaceKHR;
if (!strcmp(name, "DestroyInstance"))
return vulkan_funcs->p_vkDestroyInstance;
if (!strcmp(name, "DestroySurfaceKHR"))
return vulkan_funcs->p_vkDestroySurfaceKHR;
+ if (!strcmp(name, "vkGetDisplayModePropertiesKHR"))
+ return vulkan_funcs->p_vkGetDisplayModePropertiesKHR;
+ if (!strcmp(name, "vkGetDisplayPlaneCapabilitiesKHR"))
+ return vulkan_funcs->p_vkGetDisplayPlaneCapabilitiesKHR;
+ if (!strcmp(name, "vkGetDisplayPlaneSupportedDisplaysKHR"))
+ return vulkan_funcs->p_vkGetDisplayPlaneSupportedDisplaysKHR;
if (!strcmp(name, "GetInstanceProcAddr"))
return vulkan_funcs->p_vkGetInstanceProcAddr;
+ if (!strcmp(name, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR"))
+ return vulkan_funcs->p_vkGetPhysicalDeviceDisplayPlanePropertiesKHR;
+ if (!strcmp(name, "vkGetPhysicalDeviceDisplayPropertiesKHR"))
+ return vulkan_funcs->p_vkGetPhysicalDeviceDisplayPropertiesKHR;
if (!strcmp(name, "GetPhysicalDeviceSurfaceCapabilitiesKHR"))
return vulkan_funcs->p_vkGetPhysicalDeviceSurfaceCapabilitiesKHR;
if (!strcmp(name, "GetPhysicalDeviceSurfaceFormatsKHR"))
diff --git a/include/wine/vulkan.h b/include/wine/vulkan.h
index fcc31bc3c9..07bcd1279c 100644
--- a/include/wine/vulkan.h
+++ b/include/wine/vulkan.h
@@ -60,6 +60,8 @@ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout)
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorUpdateTemplateKHR)
VK_DEFINE_HANDLE(VkDevice)
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR)
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent)
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence)
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer)
@@ -406,6 +408,15 @@ typedef enum VkDescriptorUpdateTemplateTypeKHR
VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_KHR_MAX_ENUM = 0x7fffffff,
} VkDescriptorUpdateTemplateTypeKHR;
+typedef enum VkDisplayPlaneAlphaFlagBitsKHR
+{
+ VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 0x00000001,
+ VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000002,
+ VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000004,
+ VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000008,
+ VK_DISPLAY_PLANE_ALPHA_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff,
+} VkDisplayPlaneAlphaFlagBitsKHR;
+
typedef enum VkDynamicState
{
VK_DYNAMIC_STATE_VIEWPORT = 0,
@@ -817,6 +828,8 @@ typedef enum VkObjectType
VK_OBJECT_TYPE_COMMAND_POOL = 25,
VK_OBJECT_TYPE_SURFACE_KHR = 1000000000,
VK_OBJECT_TYPE_SWAPCHAIN_KHR = 1000001000,
+ VK_OBJECT_TYPE_DISPLAY_KHR = 1000002000,
+ VK_OBJECT_TYPE_DISPLAY_MODE_KHR = 1000002001,
VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = 1000085000,
VK_OBJECT_TYPE_MAX_ENUM = 0x7fffffff,
} VkObjectType;
@@ -1103,6 +1116,8 @@ typedef enum VkStructureType
VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48,
VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000,
VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001,
+ VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000,
+ VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001,
VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000,
VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = 1000018000,
VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000,
@@ -1326,33 +1341,40 @@ typedef struct VkDispatchIndirectCommand
uint32_t z;
} VkDispatchIndirectCommand;
-typedef struct VkDrawIndirectCommand
+typedef struct VkDisplayPlanePropertiesKHR
{
- uint32_t vertexCount;
+ VkDisplayKHR WINE_VK_ALIGN(8) currentDisplay;
+ uint32_t currentStackIndex;
+} VkDisplayPlanePropertiesKHR;
+
+typedef struct VkDrawIndexedIndirectCommand
+{
+ uint32_t indexCount;
uint32_t instanceCount;
- uint32_t firstVertex;
+ uint32_t firstIndex;
+ int32_t vertexOffset;
uint32_t firstInstance;
-} VkDrawIndirectCommand;
+} VkDrawIndexedIndirectCommand;
-typedef struct VkExtensionProperties
+typedef struct VkEventCreateInfo
{
- char extensionName[VK_MAX_EXTENSION_NAME_SIZE];
- uint32_t specVersion;
-} VkExtensionProperties;
+ VkStructureType sType;
+ const void *pNext;
+ VkEventCreateFlags flags;
+} VkEventCreateInfo;
-typedef struct VkExtent3D
+typedef struct VkExtent2D
{
uint32_t width;
uint32_t height;
- uint32_t depth;
-} VkExtent3D;
+} VkExtent2D;
-typedef struct VkFormatProperties
+typedef struct VkFenceCreateInfo
{
- VkFormatFeatureFlags linearTilingFeatures;
- VkFormatFeatureFlags optimalTilingFeatures;
- VkFormatFeatureFlags bufferFeatures;
-} VkFormatProperties;
+ VkStructureType sType;
+ const void *pNext;
+ VkFenceCreateFlags flags;
+} VkFenceCreateInfo;
typedef struct VkFramebufferCreateInfo
{
@@ -1367,25 +1389,6 @@ typedef struct VkFramebufferCreateInfo
uint32_t layers;
} VkFramebufferCreateInfo;
-typedef struct VkImageCreateInfo
-{
- VkStructureType sType;
- const void *pNext;
- VkImageCreateFlags flags;
- VkImageType imageType;
- VkFormat format;
- VkExtent3D extent;
- uint32_t mipLevels;
- uint32_t arrayLayers;
- VkSampleCountFlagBits samples;
- VkImageTiling tiling;
- VkImageUsageFlags usage;
- VkSharingMode sharingMode;
- uint32_t queueFamilyIndexCount;
- const uint32_t *pQueueFamilyIndices;
- VkImageLayout initialLayout;
-} VkImageCreateInfo;
-
typedef struct VkImageSubresource
{
VkImageAspectFlags aspectMask;
@@ -1600,32 +1603,6 @@ typedef struct VkSemaphoreCreateInfo
VkSemaphoreCreateFlags flags;
} VkSemaphoreCreateInfo;
-typedef struct VkSparseImageFormatProperties
-{
- VkImageAspectFlags aspectMask;
- VkExtent3D imageGranularity;
- VkSparseImageFormatFlags flags;
-} VkSparseImageFormatProperties;
-
-typedef struct VkSparseImageMemoryBind
-{
- VkImageSubresource subresource;
- VkOffset3D offset;
- VkExtent3D extent;
- VkDeviceMemory WINE_VK_ALIGN(8) memory;
- VkDeviceSize WINE_VK_ALIGN(8) memoryOffset;
- VkSparseMemoryBindFlags flags;
-} VkSparseImageMemoryBind;
-
-typedef struct VkSparseImageMemoryRequirements
-{
- VkSparseImageFormatProperties formatProperties;
- uint32_t imageMipTailFirstLod;
- VkDeviceSize WINE_VK_ALIGN(8) imageMipTailSize;
- VkDeviceSize WINE_VK_ALIGN(8) imageMipTailOffset;
- VkDeviceSize WINE_VK_ALIGN(8) imageMipTailStride;
-} VkSparseImageMemoryRequirements;
-
typedef struct VkSparseMemoryBind
{
VkDeviceSize WINE_VK_ALIGN(8) resourceOffset;
@@ -1761,34 +1738,51 @@ typedef struct VkDescriptorUpdateTemplateCreateInfoKHR
uint32_t set;
} VkDescriptorUpdateTemplateCreateInfoKHR;
-typedef struct VkEventCreateInfo
+typedef struct VkDisplayModeParametersKHR
+{
+ VkExtent2D visibleRegion;
+ uint32_t refreshRate;
+} VkDisplayModeParametersKHR;
+
+typedef struct VkDisplaySurfaceCreateInfoKHR
{
VkStructureType sType;
const void *pNext;
- VkEventCreateFlags flags;
-} VkEventCreateInfo;
+ VkDisplaySurfaceCreateFlagsKHR flags;
+ VkDisplayModeKHR WINE_VK_ALIGN(8) displayMode;
+ uint32_t planeIndex;
+ uint32_t planeStackIndex;
+ VkSurfaceTransformFlagBitsKHR transform;
+ float globalAlpha;
+ VkDisplayPlaneAlphaFlagBitsKHR alphaMode;
+ VkExtent2D imageExtent;
+} VkDisplaySurfaceCreateInfoKHR;
-typedef struct VkExtent2D
+typedef struct VkExtent3D
{
uint32_t width;
uint32_t height;
-} VkExtent2D;
+ uint32_t depth;
+} VkExtent3D;
-typedef struct VkFormatProperties2KHR
+typedef struct VkImageCreateInfo
{
VkStructureType sType;
- void *pNext;
- VkFormatProperties formatProperties;
-} VkFormatProperties2KHR;
-
-typedef struct VkImageFormatProperties
-{
- VkExtent3D maxExtent;
- uint32_t maxMipLevels;
- uint32_t maxArrayLayers;
- VkSampleCountFlags sampleCounts;
- VkDeviceSize WINE_VK_ALIGN(8) maxResourceSize;
-} VkImageFormatProperties;
+ const void *pNext;
+ VkImageCreateFlags flags;
+ VkImageType imageType;
+ VkFormat format;
+ VkExtent3D extent;
+ uint32_t mipLevels;
+ uint32_t arrayLayers;
+ VkSampleCountFlagBits samples;
+ VkImageTiling tiling;
+ VkImageUsageFlags usage;
+ VkSharingMode sharingMode;
+ uint32_t queueFamilyIndexCount;
+ const uint32_t *pQueueFamilyIndices;
+ VkImageLayout initialLayout;
+} VkImageCreateInfo;
typedef struct VkImageMemoryBarrier
{
@@ -1912,61 +1906,105 @@ typedef struct VkSparseBufferMemoryBindInfo
const VkSparseMemoryBind *pBinds;
} VkSparseBufferMemoryBindInfo;
-typedef struct VkSparseImageMemoryBindInfo
+typedef struct VkSparseImageMemoryBind
+{
+ VkImageSubresource subresource;
+ VkOffset3D offset;
+ VkExtent3D extent;
+ VkDeviceMemory WINE_VK_ALIGN(8) memory;
+ VkDeviceSize WINE_VK_ALIGN(8) memoryOffset;
+ VkSparseMemoryBindFlags flags;
+} VkSparseImageMemoryBind;
+
+typedef struct VkSparseImageOpaqueMemoryBindInfo
{
VkImage WINE_VK_ALIGN(8) image;
uint32_t bindCount;
- const VkSparseImageMemoryBind *pBinds;
-} VkSparseImageMemoryBindInfo;
+ const VkSparseMemoryBind *pBinds;
+} VkSparseImageOpaqueMemoryBindInfo;
-typedef struct VkSpecializationInfo
+typedef struct VkStencilOpState
{
- uint32_t mapEntryCount;
- const VkSpecializationMapEntry *pMapEntries;
- size_t dataSize;
- const void *pData;
-} VkSpecializationInfo;
+ VkStencilOp failOp;
+ VkStencilOp passOp;
+ VkStencilOp depthFailOp;
+ VkCompareOp compareOp;
+ uint32_t compareMask;
+ uint32_t writeMask;
+ uint32_t reference;
+} VkStencilOpState;
-typedef struct VkSubpassDependency
+typedef struct VkSubpassDescription
{
- uint32_t srcSubpass;
- uint32_t dstSubpass;
- VkPipelineStageFlags srcStageMask;
- VkPipelineStageFlags dstStageMask;
- VkAccessFlags srcAccessMask;
- VkAccessFlags dstAccessMask;
- VkDependencyFlags dependencyFlags;
-} VkSubpassDependency;
+ VkSubpassDescriptionFlags flags;
+ VkPipelineBindPoint pipelineBindPoint;
+ uint32_t inputAttachmentCount;
+ const VkAttachmentReference *pInputAttachments;
+ uint32_t colorAttachmentCount;
+ const VkAttachmentReference *pColorAttachments;
+ const VkAttachmentReference *pResolveAttachments;
+ const VkAttachmentReference *pDepthStencilAttachment;
+ uint32_t preserveAttachmentCount;
+ const uint32_t *pPreserveAttachments;
+} VkSubpassDescription;
-typedef struct VkSurfaceFormatKHR
+typedef struct VkSurfaceCapabilitiesKHR
{
- VkFormat format;
- VkColorSpaceKHR colorSpace;
-} VkSurfaceFormatKHR;
+ uint32_t minImageCount;
+ uint32_t maxImageCount;
+ VkExtent2D currentExtent;
+ VkExtent2D minImageExtent;
+ VkExtent2D maxImageExtent;
+ uint32_t maxImageArrayLayers;
+ VkSurfaceTransformFlagsKHR supportedTransforms;
+ VkSurfaceTransformFlagBitsKHR currentTransform;
+ VkCompositeAlphaFlagsKHR supportedCompositeAlpha;
+ VkImageUsageFlags supportedUsageFlags;
+} VkSurfaceCapabilitiesKHR;
-typedef struct VkViewport
+typedef struct VkSwapchainCreateInfoKHR
{
- float x;
- float y;
- float width;
- float height;
- float minDepth;
- float maxDepth;
-} VkViewport;
+ VkStructureType sType;
+ const void *pNext;
+ VkSwapchainCreateFlagsKHR flags;
+ VkSurfaceKHR WINE_VK_ALIGN(8) surface;
+ uint32_t minImageCount;
+ VkFormat imageFormat;
+ VkColorSpaceKHR imageColorSpace;
+ VkExtent2D imageExtent;
+ uint32_t imageArrayLayers;
+ VkImageUsageFlags imageUsage;
+ VkSharingMode imageSharingMode;
+ uint32_t queueFamilyIndexCount;
+ const uint32_t *pQueueFamilyIndices;
+ VkSurfaceTransformFlagBitsKHR preTransform;
+ VkCompositeAlphaFlagBitsKHR compositeAlpha;
+ VkPresentModeKHR presentMode;
+ VkBool32 clipped;
+ VkSwapchainKHR WINE_VK_ALIGN(8) oldSwapchain;
+} VkSwapchainCreateInfoKHR;
-typedef struct VkWriteDescriptorSet
+typedef struct VkVertexInputBindingDescription
+{
+ uint32_t binding;
+ uint32_t stride;
+ VkVertexInputRate inputRate;
+} VkVertexInputBindingDescription;
+
+typedef struct VkViewportWScalingNV
+{
+ float xcoeff;
+ float ycoeff;
+} VkViewportWScalingNV;
+
+typedef struct VkWin32SurfaceCreateInfoKHR
{
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;
+ VkWin32SurfaceCreateFlagsKHR flags;
+ HINSTANCE hinstance;
+ HWND hwnd;
+} VkWin32SurfaceCreateInfoKHR;
typedef struct VkApplicationInfo
{
@@ -2009,51 +2047,223 @@ typedef struct VkDeviceQueueCreateInfo
const float *pQueuePriorities;
} VkDeviceQueueCreateInfo;
-typedef struct VkFenceCreateInfo
+typedef struct VkDisplayModePropertiesKHR
{
- VkStructureType sType;
- const void *pNext;
- VkFenceCreateFlags flags;
-} VkFenceCreateInfo;
+ VkDisplayModeKHR WINE_VK_ALIGN(8) displayMode;
+ VkDisplayModeParametersKHR parameters;
+} VkDisplayModePropertiesKHR;
-typedef struct VkImageBlit
+typedef struct VkDisplayPropertiesKHR
{
- VkImageSubresourceLayers srcSubresource;
- VkOffset3D srcOffsets[2];
- VkImageSubresourceLayers dstSubresource;
- VkOffset3D dstOffsets[2];
+ VkDisplayKHR WINE_VK_ALIGN(8) display;
+ const char *displayName;
+ VkExtent2D physicalDimensions;
+ VkExtent2D physicalResolution;
+ VkSurfaceTransformFlagsKHR supportedTransforms;
+ VkBool32 planeReorderPossible;
+ VkBool32 persistentContent;
+} VkDisplayPropertiesKHR;
+
+typedef struct VkFormatProperties
+{
+ VkFormatFeatureFlags linearTilingFeatures;
+ VkFormatFeatureFlags optimalTilingFeatures;
+ VkFormatFeatureFlags bufferFeatures;
+} VkFormatProperties;
+
+typedef struct VkImageBlit
+{
+ VkImageSubresourceLayers srcSubresource;
+ VkOffset3D srcOffsets[2];
+ VkImageSubresourceLayers dstSubresource;
+ VkOffset3D dstOffsets[2];
} VkImageBlit;
-typedef struct VkImageFormatProperties2KHR
+typedef struct VkImageFormatProperties
+{
+ VkExtent3D maxExtent;
+ uint32_t maxMipLevels;
+ uint32_t maxArrayLayers;
+ VkSampleCountFlags sampleCounts;
+ VkDeviceSize WINE_VK_ALIGN(8) maxResourceSize;
+} VkImageFormatProperties;
+
+typedef struct VkImageResolve
+{
+ VkImageSubresourceLayers srcSubresource;
+ VkOffset3D srcOffset;
+ VkImageSubresourceLayers dstSubresource;
+ VkOffset3D dstOffset;
+ VkExtent3D extent;
+} VkImageResolve;
+
+typedef struct VkInstanceCreateInfo
{
VkStructureType sType;
- void *pNext;
- VkImageFormatProperties WINE_VK_ALIGN(8) imageFormatProperties;
-} VkImageFormatProperties2KHR;
+ 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 VkOffset2D
+typedef struct VkMemoryHeap
{
- int32_t x;
- int32_t y;
-} VkOffset2D;
+ VkDeviceSize WINE_VK_ALIGN(8) size;
+ VkMemoryHeapFlags flags;
+} VkMemoryHeap;
-typedef struct VkPhysicalDeviceFeatures2KHR
+typedef struct VkPhysicalDeviceLimits
+{
+ uint32_t maxImageDimension1D;
+ uint32_t maxImageDimension2D;
+ uint32_t maxImageDimension3D;
+ uint32_t maxImageDimensionCube;
+ uint32_t maxImageArrayLayers;
+ uint32_t maxTexelBufferElements;
+ uint32_t maxUniformBufferRange;
+ uint32_t maxStorageBufferRange;
+ uint32_t maxPushConstantsSize;
+ uint32_t maxMemoryAllocationCount;
+ uint32_t maxSamplerAllocationCount;
+ VkDeviceSize WINE_VK_ALIGN(8) bufferImageGranularity;
+ VkDeviceSize WINE_VK_ALIGN(8) sparseAddressSpaceSize;
+ uint32_t maxBoundDescriptorSets;
+ uint32_t maxPerStageDescriptorSamplers;
+ uint32_t maxPerStageDescriptorUniformBuffers;
+ uint32_t maxPerStageDescriptorStorageBuffers;
+ uint32_t maxPerStageDescriptorSampledImages;
+ uint32_t maxPerStageDescriptorStorageImages;
+ uint32_t maxPerStageDescriptorInputAttachments;
+ uint32_t maxPerStageResources;
+ uint32_t maxDescriptorSetSamplers;
+ uint32_t maxDescriptorSetUniformBuffers;
+ uint32_t maxDescriptorSetUniformBuffersDynamic;
+ uint32_t maxDescriptorSetStorageBuffers;
+ uint32_t maxDescriptorSetStorageBuffersDynamic;
+ uint32_t maxDescriptorSetSampledImages;
+ uint32_t maxDescriptorSetStorageImages;
+ uint32_t maxDescriptorSetInputAttachments;
+ uint32_t maxVertexInputAttributes;
+ uint32_t maxVertexInputBindings;
+ uint32_t maxVertexInputAttributeOffset;
+ uint32_t maxVertexInputBindingStride;
+ uint32_t maxVertexOutputComponents;
+ uint32_t maxTessellationGenerationLevel;
+ uint32_t maxTessellationPatchSize;
+ uint32_t maxTessellationControlPerVertexInputComponents;
+ uint32_t maxTessellationControlPerVertexOutputComponents;
+ uint32_t maxTessellationControlPerPatchOutputComponents;
+ uint32_t maxTessellationControlTotalOutputComponents;
+ uint32_t maxTessellationEvaluationInputComponents;
+ uint32_t maxTessellationEvaluationOutputComponents;
+ uint32_t maxGeometryShaderInvocations;
+ uint32_t maxGeometryInputComponents;
+ uint32_t maxGeometryOutputComponents;
+ uint32_t maxGeometryOutputVertices;
+ uint32_t maxGeometryTotalOutputComponents;
+ uint32_t maxFragmentInputComponents;
+ uint32_t maxFragmentOutputAttachments;
+ uint32_t maxFragmentDualSrcAttachments;
+ uint32_t maxFragmentCombinedOutputResources;
+ uint32_t maxComputeSharedMemorySize;
+ uint32_t maxComputeWorkGroupCount[3];
+ uint32_t maxComputeWorkGroupInvocations;
+ uint32_t maxComputeWorkGroupSize[3];
+ uint32_t subPixelPrecisionBits;
+ uint32_t subTexelPrecisionBits;
+ uint32_t mipmapPrecisionBits;
+ uint32_t maxDrawIndexedIndexValue;
+ uint32_t maxDrawIndirectCount;
+ float maxSamplerLodBias;
+ float maxSamplerAnisotropy;
+ uint32_t maxViewports;
+ uint32_t maxViewportDimensions[2];
+ float viewportBoundsRange[2];
+ uint32_t viewportSubPixelBits;
+ size_t minMemoryMapAlignment;
+ VkDeviceSize WINE_VK_ALIGN(8) minTexelBufferOffsetAlignment;
+ VkDeviceSize WINE_VK_ALIGN(8) minUniformBufferOffsetAlignment;
+ VkDeviceSize WINE_VK_ALIGN(8) minStorageBufferOffsetAlignment;
+ int32_t minTexelOffset;
+ uint32_t maxTexelOffset;
+ int32_t minTexelGatherOffset;
+ uint32_t maxTexelGatherOffset;
+ float minInterpolationOffset;
+ float maxInterpolationOffset;
+ uint32_t subPixelInterpolationOffsetBits;
+ uint32_t maxFramebufferWidth;
+ uint32_t maxFramebufferHeight;
+ uint32_t maxFramebufferLayers;
+ VkSampleCountFlags framebufferColorSampleCounts;
+ VkSampleCountFlags framebufferDepthSampleCounts;
+ VkSampleCountFlags framebufferStencilSampleCounts;
+ VkSampleCountFlags framebufferNoAttachmentsSampleCounts;
+ uint32_t maxColorAttachments;
+ VkSampleCountFlags sampledImageColorSampleCounts;
+ VkSampleCountFlags sampledImageIntegerSampleCounts;
+ VkSampleCountFlags sampledImageDepthSampleCounts;
+ VkSampleCountFlags sampledImageStencilSampleCounts;
+ VkSampleCountFlags storageImageSampleCounts;
+ uint32_t maxSampleMaskWords;
+ VkBool32 timestampComputeAndGraphics;
+ float timestampPeriod;
+ uint32_t maxClipDistances;
+ uint32_t maxCullDistances;
+ uint32_t maxCombinedClipAndCullDistances;
+ uint32_t discreteQueuePriorities;
+ float pointSizeRange[2];
+ float lineWidthRange[2];
+ float pointSizeGranularity;
+ float lineWidthGranularity;
+ VkBool32 strictLines;
+ VkBool32 standardSampleLocations;
+ VkDeviceSize WINE_VK_ALIGN(8) optimalBufferCopyOffsetAlignment;
+ VkDeviceSize WINE_VK_ALIGN(8) optimalBufferCopyRowPitchAlignment;
+ VkDeviceSize WINE_VK_ALIGN(8) nonCoherentAtomSize;
+} VkPhysicalDeviceLimits;
+
+typedef struct VkPhysicalDeviceProperties
+{
+ uint32_t apiVersion;
+ uint32_t driverVersion;
+ uint32_t vendorID;
+ uint32_t deviceID;
+ VkPhysicalDeviceType deviceType;
+ char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
+ uint8_t pipelineCacheUUID[VK_UUID_SIZE];
+ VkPhysicalDeviceLimits WINE_VK_ALIGN(8) limits;
+ VkPhysicalDeviceSparseProperties sparseProperties;
+} VkPhysicalDeviceProperties;
+
+typedef struct VkPipelineDepthStencilStateCreateInfo
{
VkStructureType sType;
- void *pNext;
- VkPhysicalDeviceFeatures features;
-} VkPhysicalDeviceFeatures2KHR;
+ const void *pNext;
+ VkPipelineDepthStencilStateCreateFlags flags;
+ VkBool32 depthTestEnable;
+ VkBool32 depthWriteEnable;
+ VkCompareOp depthCompareOp;
+ VkBool32 depthBoundsTestEnable;
+ VkBool32 stencilTestEnable;
+ VkStencilOpState front;
+ VkStencilOpState back;
+ float minDepthBounds;
+ float maxDepthBounds;
+} VkPipelineDepthStencilStateCreateInfo;
-typedef struct VkPipelineShaderStageCreateInfo
+typedef struct VkPipelineVertexInputStateCreateInfo
{
VkStructureType sType;
const void *pNext;
- VkPipelineShaderStageCreateFlags flags;
- VkShaderStageFlagBits stage;
- VkShaderModule WINE_VK_ALIGN(8) module;
- const char *pName;
- const VkSpecializationInfo *pSpecializationInfo;
-} VkPipelineShaderStageCreateInfo;
+ VkPipelineVertexInputStateCreateFlags flags;
+ uint32_t vertexBindingDescriptionCount;
+ const VkVertexInputBindingDescription *pVertexBindingDescriptions;
+ uint32_t vertexAttributeDescriptionCount;
+ const VkVertexInputAttributeDescription *pVertexAttributeDescriptions;
+} VkPipelineVertexInputStateCreateInfo;
typedef struct VkQueueFamilyProperties2KHR
{
@@ -2071,54 +2281,20 @@ typedef struct VkShaderModuleCreateInfo
const uint32_t *pCode;
} VkShaderModuleCreateInfo;
-typedef struct VkSparseImageOpaqueMemoryBindInfo
+typedef struct VkSparseImageMemoryBindInfo
{
VkImage WINE_VK_ALIGN(8) image;
uint32_t bindCount;
- const VkSparseMemoryBind *pBinds;
-} VkSparseImageOpaqueMemoryBindInfo;
-
-typedef struct VkSubpassDescription
-{
- VkSubpassDescriptionFlags flags;
- VkPipelineBindPoint pipelineBindPoint;
- uint32_t inputAttachmentCount;
- const VkAttachmentReference *pInputAttachments;
- uint32_t colorAttachmentCount;
- const VkAttachmentReference *pColorAttachments;
- const VkAttachmentReference *pResolveAttachments;
- const VkAttachmentReference *pDepthStencilAttachment;
- uint32_t preserveAttachmentCount;
- const uint32_t *pPreserveAttachments;
-} VkSubpassDescription;
-
-typedef struct VkSwapchainCreateInfoKHR
-{
- VkStructureType sType;
- const void *pNext;
- VkSwapchainCreateFlagsKHR flags;
- VkSurfaceKHR WINE_VK_ALIGN(8) surface;
- uint32_t minImageCount;
- VkFormat imageFormat;
- VkColorSpaceKHR imageColorSpace;
- VkExtent2D imageExtent;
- uint32_t imageArrayLayers;
- VkImageUsageFlags imageUsage;
- VkSharingMode imageSharingMode;
- uint32_t queueFamilyIndexCount;
- const uint32_t *pQueueFamilyIndices;
- VkSurfaceTransformFlagBitsKHR preTransform;
- VkCompositeAlphaFlagBitsKHR compositeAlpha;
- VkPresentModeKHR presentMode;
- VkBool32 clipped;
- VkSwapchainKHR WINE_VK_ALIGN(8) oldSwapchain;
-} VkSwapchainCreateInfoKHR;
+ const VkSparseImageMemoryBind *pBinds;
+} VkSparseImageMemoryBindInfo;
-typedef struct VkViewportWScalingNV
+typedef struct VkSpecializationInfo
{
- float xcoeff;
- float ycoeff;
-} VkViewportWScalingNV;
+ uint32_t mapEntryCount;
+ const VkSpecializationMapEntry *pMapEntries;
+ size_t dataSize;
+ const void *pData;
+} VkSpecializationInfo;
typedef struct VkClearAttachment
{
@@ -2149,6 +2325,22 @@ typedef struct VkDeviceCreateInfo
const VkPhysicalDeviceFeatures *pEnabledFeatures;
} VkDeviceCreateInfo;
+typedef struct VkDisplayModeCreateInfoKHR
+{
+ VkStructureType sType;
+ const void *pNext;
+ VkDisplayModeCreateFlagsKHR flags;
+ VkDisplayModeParametersKHR parameters;
+} VkDisplayModeCreateInfoKHR;
+
+typedef struct VkDrawIndirectCommand
+{
+ uint32_t vertexCount;
+ uint32_t instanceCount;
+ uint32_t firstVertex;
+ uint32_t firstInstance;
+} VkDrawIndirectCommand;
+
typedef struct VkImageCopy
{
VkImageSubresourceLayers srcSubresource;
@@ -2158,11 +2350,11 @@ typedef struct VkImageCopy
VkExtent3D extent;
} VkImageCopy;
-typedef struct VkMemoryHeap
+typedef struct VkOffset2D
{
- VkDeviceSize WINE_VK_ALIGN(8) size;
- VkMemoryHeapFlags flags;
-} VkMemoryHeap;
+ int32_t x;
+ int32_t y;
+} VkOffset2D;
typedef struct VkPhysicalDeviceMemoryProperties
{
@@ -2172,17 +2364,23 @@ typedef struct VkPhysicalDeviceMemoryProperties
VkMemoryHeap WINE_VK_ALIGN(8) memoryHeaps[VK_MAX_MEMORY_HEAPS];
} VkPhysicalDeviceMemoryProperties;
-typedef struct VkPipelineColorBlendStateCreateInfo
+typedef struct VkPhysicalDeviceProperties2KHR
+{
+ VkStructureType sType;
+ void *pNext;
+ VkPhysicalDeviceProperties WINE_VK_ALIGN(8) properties;
+} VkPhysicalDeviceProperties2KHR;
+
+typedef struct VkPipelineShaderStageCreateInfo
{
VkStructureType sType;
const void *pNext;
- VkPipelineColorBlendStateCreateFlags flags;
- VkBool32 logicOpEnable;
- VkLogicOp logicOp;
- uint32_t attachmentCount;
- const VkPipelineColorBlendAttachmentState *pAttachments;
- float blendConstants[4];
-} VkPipelineColorBlendStateCreateInfo;
+ VkPipelineShaderStageCreateFlags flags;
+ VkShaderStageFlagBits stage;
+ VkShaderModule WINE_VK_ALIGN(8) module;
+ const char *pName;
+ const VkSpecializationInfo *pSpecializationInfo;
+} VkPipelineShaderStageCreateInfo;
typedef struct VkPushConstantRange
{
@@ -2191,36 +2389,41 @@ typedef struct VkPushConstantRange
uint32_t size;
} VkPushConstantRange;
-typedef struct VkRenderPassCreateInfo
+typedef struct VkSparseImageFormatProperties
{
- 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;
+ VkImageAspectFlags aspectMask;
+ VkExtent3D imageGranularity;
+ VkSparseImageFormatFlags flags;
+} VkSparseImageFormatProperties;
-typedef struct VkStencilOpState
+typedef struct VkSparseImageMemoryRequirements
{
- VkStencilOp failOp;
- VkStencilOp passOp;
- VkStencilOp depthFailOp;
- VkCompareOp compareOp;
- uint32_t compareMask;
- uint32_t writeMask;
- uint32_t reference;
-} VkStencilOpState;
+ VkSparseImageFormatProperties formatProperties;
+ uint32_t imageMipTailFirstLod;
+ VkDeviceSize WINE_VK_ALIGN(8) imageMipTailSize;
+ VkDeviceSize WINE_VK_ALIGN(8) imageMipTailOffset;
+ VkDeviceSize WINE_VK_ALIGN(8) imageMipTailStride;
+} VkSparseImageMemoryRequirements;
-typedef struct VkVertexInputBindingDescription
+typedef struct VkSurfaceFormatKHR
{
- uint32_t binding;
- uint32_t stride;
- VkVertexInputRate inputRate;
-} VkVertexInputBindingDescription;
+ 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
{
@@ -2249,48 +2452,36 @@ typedef struct VkComputePipelineCreateInfo
int32_t basePipelineIndex;
} VkComputePipelineCreateInfo;
-typedef struct VkImageResolve
+typedef struct VkExtensionProperties
{
- VkImageSubresourceLayers srcSubresource;
- VkOffset3D srcOffset;
- VkImageSubresourceLayers dstSubresource;
- VkOffset3D dstOffset;
- VkExtent3D extent;
-} VkImageResolve;
+ char extensionName[VK_MAX_EXTENSION_NAME_SIZE];
+ uint32_t specVersion;
+} VkExtensionProperties;
-typedef struct VkPhysicalDeviceMemoryProperties2KHR
+typedef struct VkImageFormatProperties2KHR
{
VkStructureType sType;
void *pNext;
- VkPhysicalDeviceMemoryProperties WINE_VK_ALIGN(8) memoryProperties;
-} VkPhysicalDeviceMemoryProperties2KHR;
+ VkImageFormatProperties WINE_VK_ALIGN(8) imageFormatProperties;
+} VkImageFormatProperties2KHR;
-typedef struct VkPipelineDepthStencilStateCreateInfo
+typedef struct VkPhysicalDeviceMemoryProperties2KHR
{
VkStructureType sType;
- const void *pNext;
- VkPipelineDepthStencilStateCreateFlags flags;
- VkBool32 depthTestEnable;
- VkBool32 depthWriteEnable;
- VkCompareOp depthCompareOp;
- VkBool32 depthBoundsTestEnable;
- VkBool32 stencilTestEnable;
- VkStencilOpState front;
- VkStencilOpState back;
- float minDepthBounds;
- float maxDepthBounds;
-} VkPipelineDepthStencilStateCreateInfo;
+ void *pNext;
+ VkPhysicalDeviceMemoryProperties WINE_VK_ALIGN(8) memoryProperties;
+} VkPhysicalDeviceMemoryProperties2KHR;
-typedef struct VkPipelineVertexInputStateCreateInfo
+typedef struct VkPipelineLayoutCreateInfo
{
VkStructureType sType;
const void *pNext;
- VkPipelineVertexInputStateCreateFlags flags;
- uint32_t vertexBindingDescriptionCount;
- const VkVertexInputBindingDescription *pVertexBindingDescriptions;
- uint32_t vertexAttributeDescriptionCount;
- const VkVertexInputAttributeDescription *pVertexAttributeDescriptions;
-} VkPipelineVertexInputStateCreateInfo;
+ VkPipelineLayoutCreateFlags flags;
+ uint32_t setLayoutCount;
+ const VkDescriptorSetLayout *pSetLayouts;
+ uint32_t pushConstantRangeCount;
+ const VkPushConstantRange *pPushConstantRanges;
+} VkPipelineLayoutCreateInfo;
typedef struct VkRect2D
{
@@ -2305,14 +2496,15 @@ typedef struct VkSparseImageFormatProperties2KHR
VkSparseImageFormatProperties properties;
} VkSparseImageFormatProperties2KHR;
-typedef struct VkWin32SurfaceCreateInfoKHR
+typedef struct VkViewport
{
- VkStructureType sType;
- const void *pNext;
- VkWin32SurfaceCreateFlagsKHR flags;
- HINSTANCE hinstance;
- HWND hwnd;
-} VkWin32SurfaceCreateInfoKHR;
+ float x;
+ float y;
+ float width;
+ float height;
+ float minDepth;
+ float maxDepth;
+} VkViewport;
typedef struct VkClearRect
{
@@ -2321,37 +2513,30 @@ typedef struct VkClearRect
uint32_t layerCount;
} VkClearRect;
-typedef struct VkDrawIndexedIndirectCommand
-{
- uint32_t indexCount;
- uint32_t instanceCount;
- uint32_t firstIndex;
- int32_t vertexOffset;
- uint32_t firstInstance;
-} VkDrawIndexedIndirectCommand;
-
-typedef struct VkInstanceCreateInfo
+typedef struct VkDisplayPlaneCapabilitiesKHR
{
- 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;
+ VkDisplayPlaneAlphaFlagsKHR supportedAlpha;
+ VkOffset2D minSrcPosition;
+ VkOffset2D maxSrcPosition;
+ VkExtent2D minSrcExtent;
+ VkExtent2D maxSrcExtent;
+ VkOffset2D minDstPosition;
+ VkOffset2D maxDstPosition;
+ VkExtent2D minDstExtent;
+ VkExtent2D maxDstExtent;
+} VkDisplayPlaneCapabilitiesKHR;
-typedef struct VkPipelineLayoutCreateInfo
+typedef struct VkPipelineColorBlendStateCreateInfo
{
VkStructureType sType;
const void *pNext;
- VkPipelineLayoutCreateFlags flags;
- uint32_t setLayoutCount;
- const VkDescriptorSetLayout *pSetLayouts;
- uint32_t pushConstantRangeCount;
- const VkPushConstantRange *pPushConstantRanges;
-} VkPipelineLayoutCreateInfo;
+ VkPipelineColorBlendStateCreateFlags flags;
+ VkBool32 logicOpEnable;
+ VkLogicOp logicOp;
+ uint32_t attachmentCount;
+ const VkPipelineColorBlendAttachmentState *pAttachments;
+ float blendConstants[4];
+} VkPipelineColorBlendStateCreateInfo;
typedef struct VkRenderPassBeginInfo
{
@@ -2364,6 +2549,17 @@ typedef struct VkRenderPassBeginInfo
const VkClearValue *pClearValues;
} VkRenderPassBeginInfo;
+typedef struct VkSubpassDependency
+{
+ uint32_t srcSubpass;
+ uint32_t dstSubpass;
+ VkPipelineStageFlags srcStageMask;
+ VkPipelineStageFlags dstStageMask;
+ VkAccessFlags srcAccessMask;
+ VkAccessFlags dstAccessMask;
+ VkDependencyFlags dependencyFlags;
+} VkSubpassDependency;
+
typedef struct VkDescriptorSetLayoutCreateInfo
{
VkStructureType sType;
@@ -2373,115 +2569,32 @@ typedef struct VkDescriptorSetLayoutCreateInfo
const VkDescriptorSetLayoutBinding *pBindings;
} VkDescriptorSetLayoutCreateInfo;
-typedef struct VkPhysicalDeviceLimits
+typedef struct VkPhysicalDeviceFeatures2KHR
{
- uint32_t maxImageDimension1D;
- uint32_t maxImageDimension2D;
- uint32_t maxImageDimension3D;
- uint32_t maxImageDimensionCube;
- uint32_t maxImageArrayLayers;
- uint32_t maxTexelBufferElements;
- uint32_t maxUniformBufferRange;
- uint32_t maxStorageBufferRange;
- uint32_t maxPushConstantsSize;
- uint32_t maxMemoryAllocationCount;
- uint32_t maxSamplerAllocationCount;
- VkDeviceSize WINE_VK_ALIGN(8) bufferImageGranularity;
- VkDeviceSize WINE_VK_ALIGN(8) sparseAddressSpaceSize;
- uint32_t maxBoundDescriptorSets;
- uint32_t maxPerStageDescriptorSamplers;
- uint32_t maxPerStageDescriptorUniformBuffers;
- uint32_t maxPerStageDescriptorStorageBuffers;
- uint32_t maxPerStageDescriptorSampledImages;
- uint32_t maxPerStageDescriptorStorageImages;
- uint32_t maxPerStageDescriptorInputAttachments;
- uint32_t maxPerStageResources;
- uint32_t maxDescriptorSetSamplers;
- uint32_t maxDescriptorSetUniformBuffers;
- uint32_t maxDescriptorSetUniformBuffersDynamic;
- uint32_t maxDescriptorSetStorageBuffers;
- uint32_t maxDescriptorSetStorageBuffersDynamic;
- uint32_t maxDescriptorSetSampledImages;
- uint32_t maxDescriptorSetStorageImages;
- uint32_t maxDescriptorSetInputAttachments;
- uint32_t maxVertexInputAttributes;
- uint32_t maxVertexInputBindings;
- uint32_t maxVertexInputAttributeOffset;
- uint32_t maxVertexInputBindingStride;
- uint32_t maxVertexOutputComponents;
- uint32_t maxTessellationGenerationLevel;
- uint32_t maxTessellationPatchSize;
- uint32_t maxTessellationControlPerVertexInputComponents;
- uint32_t maxTessellationControlPerVertexOutputComponents;
- uint32_t maxTessellationControlPerPatchOutputComponents;
- uint32_t maxTessellationControlTotalOutputComponents;
- uint32_t maxTessellationEvaluationInputComponents;
- uint32_t maxTessellationEvaluationOutputComponents;
- uint32_t maxGeometryShaderInvocations;
- uint32_t maxGeometryInputComponents;
- uint32_t maxGeometryOutputComponents;
- uint32_t maxGeometryOutputVertices;
- uint32_t maxGeometryTotalOutputComponents;
- uint32_t maxFragmentInputComponents;
- uint32_t maxFragmentOutputAttachments;
- uint32_t maxFragmentDualSrcAttachments;
- uint32_t maxFragmentCombinedOutputResources;
- uint32_t maxComputeSharedMemorySize;
- uint32_t maxComputeWorkGroupCount[3];
- uint32_t maxComputeWorkGroupInvocations;
- uint32_t maxComputeWorkGroupSize[3];
- uint32_t subPixelPrecisionBits;
- uint32_t subTexelPrecisionBits;
- uint32_t mipmapPrecisionBits;
- uint32_t maxDrawIndexedIndexValue;
- uint32_t maxDrawIndirectCount;
- float maxSamplerLodBias;
- float maxSamplerAnisotropy;
- uint32_t maxViewports;
- uint32_t maxViewportDimensions[2];
- float viewportBoundsRange[2];
- uint32_t viewportSubPixelBits;
- size_t minMemoryMapAlignment;
- VkDeviceSize WINE_VK_ALIGN(8) minTexelBufferOffsetAlignment;
- VkDeviceSize WINE_VK_ALIGN(8) minUniformBufferOffsetAlignment;
- VkDeviceSize WINE_VK_ALIGN(8) minStorageBufferOffsetAlignment;
- int32_t minTexelOffset;
- uint32_t maxTexelOffset;
- int32_t minTexelGatherOffset;
- uint32_t maxTexelGatherOffset;
- float minInterpolationOffset;
- float maxInterpolationOffset;
- uint32_t subPixelInterpolationOffsetBits;
- uint32_t maxFramebufferWidth;
- uint32_t maxFramebufferHeight;
- uint32_t maxFramebufferLayers;
- VkSampleCountFlags framebufferColorSampleCounts;
- VkSampleCountFlags framebufferDepthSampleCounts;
- VkSampleCountFlags framebufferStencilSampleCounts;
- VkSampleCountFlags framebufferNoAttachmentsSampleCounts;
- uint32_t maxColorAttachments;
- VkSampleCountFlags sampledImageColorSampleCounts;
- VkSampleCountFlags sampledImageIntegerSampleCounts;
- VkSampleCountFlags sampledImageDepthSampleCounts;
- VkSampleCountFlags sampledImageStencilSampleCounts;
- VkSampleCountFlags storageImageSampleCounts;
- uint32_t maxSampleMaskWords;
- VkBool32 timestampComputeAndGraphics;
- float timestampPeriod;
- uint32_t maxClipDistances;
- uint32_t maxCullDistances;
- uint32_t maxCombinedClipAndCullDistances;
- uint32_t discreteQueuePriorities;
- float pointSizeRange[2];
- float lineWidthRange[2];
- float pointSizeGranularity;
- float lineWidthGranularity;
- VkBool32 strictLines;
- VkBool32 standardSampleLocations;
- VkDeviceSize WINE_VK_ALIGN(8) optimalBufferCopyOffsetAlignment;
- VkDeviceSize WINE_VK_ALIGN(8) optimalBufferCopyRowPitchAlignment;
- VkDeviceSize WINE_VK_ALIGN(8) nonCoherentAtomSize;
-} VkPhysicalDeviceLimits;
+ VkStructureType sType;
+ void *pNext;
+ VkPhysicalDeviceFeatures features;
+} VkPhysicalDeviceFeatures2KHR;
+
+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 VkFormatProperties2KHR
+{
+ VkStructureType sType;
+ void *pNext;
+ VkFormatProperties formatProperties;
+} VkFormatProperties2KHR;
typedef struct VkPipelineViewportStateCreateInfo
{
@@ -2517,40 +2630,6 @@ typedef struct VkGraphicsPipelineCreateInfo
int32_t basePipelineIndex;
} VkGraphicsPipelineCreateInfo;
-typedef struct VkSurfaceCapabilitiesKHR
-{
- uint32_t minImageCount;
- uint32_t maxImageCount;
- VkExtent2D currentExtent;
- VkExtent2D minImageExtent;
- VkExtent2D maxImageExtent;
- uint32_t maxImageArrayLayers;
- VkSurfaceTransformFlagsKHR supportedTransforms;
- VkSurfaceTransformFlagBitsKHR currentTransform;
- VkCompositeAlphaFlagsKHR supportedCompositeAlpha;
- VkImageUsageFlags supportedUsageFlags;
-} VkSurfaceCapabilitiesKHR;
-
-typedef struct VkPhysicalDeviceProperties
-{
- uint32_t apiVersion;
- uint32_t driverVersion;
- uint32_t vendorID;
- uint32_t deviceID;
- VkPhysicalDeviceType deviceType;
- char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
- uint8_t pipelineCacheUUID[VK_UUID_SIZE];
- VkPhysicalDeviceLimits WINE_VK_ALIGN(8) limits;
- VkPhysicalDeviceSparseProperties sparseProperties;
-} VkPhysicalDeviceProperties;
-
-typedef struct VkPhysicalDeviceProperties2KHR
-{
- VkStructureType sType;
- void *pNext;
- VkPhysicalDeviceProperties WINE_VK_ALIGN(8) properties;
-} VkPhysicalDeviceProperties2KHR;
-
VkResult VKAPI_CALL vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex);
VkResult VKAPI_CALL vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo *pAllocateInfo, VkCommandBuffer *pCommandBuffers);
VkResult VKAPI_CALL vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo, VkDescriptorSet *pDescriptorSets);
@@ -2616,6 +2695,8 @@ VkResult VKAPI_CALL vkCreateDescriptorPool(VkDevice device, const VkDescriptorPo
VkResult VKAPI_CALL vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorSetLayout *pSetLayout);
VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplateKHR(VkDevice device, const VkDescriptorUpdateTemplateCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplateKHR *pDescriptorUpdateTemplate);
VkResult VKAPI_CALL vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDevice *pDevice);
+VkResult VKAPI_CALL vkCreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDisplayModeKHR *pMode);
+VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface);
VkResult VKAPI_CALL vkCreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkEvent *pEvent);
VkResult VKAPI_CALL vkCreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence);
VkResult VKAPI_CALL vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFramebuffer *pFramebuffer);
@@ -2670,12 +2751,17 @@ void VKAPI_CALL vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer,
void VKAPI_CALL vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize *pCommittedMemoryInBytes);
PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkDevice device, const char *pName);
void VKAPI_CALL vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue);
+VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t *pPropertyCount, VkDisplayModePropertiesKHR *pProperties);
+VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR *pCapabilities);
+VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t *pDisplayCount, VkDisplayKHR *pDisplays);
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 vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements *pSparseMemoryRequirements);
void VKAPI_CALL vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource *pSubresource, VkSubresourceLayout *pLayout);
PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(VkInstance instance, const char *pName);
+VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPlanePropertiesKHR *pProperties);
+VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPropertiesKHR *pProperties);
void VKAPI_CALL vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures);
void VKAPI_CALL vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2KHR *pFeatures);
void VKAPI_CALL vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties *pFormatProperties);
diff --git a/include/wine/vulkan_driver.h b/include/wine/vulkan_driver.h
index 60d16dd52a..d130d2f11b 100644
--- a/include/wine/vulkan_driver.h
+++ b/include/wine/vulkan_driver.h
@@ -4,7 +4,7 @@
#define __WINE_VULKAN_DRIVER_H
/* Wine internal vulkan driver version, needs to be bumped upon vulkan_funcs changes. */
-#define WINE_VULKAN_DRIVER_VERSION 3
+#define WINE_VULKAN_DRIVER_VERSION 4
struct vulkan_funcs
{
@@ -13,6 +13,8 @@ struct vulkan_funcs
* tables part of dispatchable Vulkan objects such as VkInstance or vkDevice.
*/
VkResult (*p_vkAcquireNextImageKHR)(VkDevice, VkSwapchainKHR, uint64_t, VkSemaphore, VkFence, uint32_t *);
+ VkResult (*p_vkCreateDisplayModeKHR)(VkPhysicalDevice, VkDisplayKHR, const VkDisplayModeCreateInfoKHR *, const VkAllocationCallbacks *, VkDisplayModeKHR *);
+ VkResult (*p_vkCreateDisplayPlaneSurfaceKHR)(VkInstance, const VkDisplaySurfaceCreateInfoKHR *, const VkAllocationCallbacks *, VkSurfaceKHR *);
VkResult (*p_vkCreateInstance)(const VkInstanceCreateInfo *, const VkAllocationCallbacks *, VkInstance *);
VkResult (*p_vkCreateSwapchainKHR)(VkDevice, const VkSwapchainCreateInfoKHR *, const VkAllocationCallbacks *, VkSwapchainKHR *);
VkResult (*p_vkCreateWin32SurfaceKHR)(VkInstance, const VkWin32SurfaceCreateInfoKHR *, const VkAllocationCallbacks *, VkSurfaceKHR *);
@@ -21,7 +23,12 @@ struct vulkan_funcs
void (*p_vkDestroySwapchainKHR)(VkDevice, VkSwapchainKHR, const VkAllocationCallbacks *);
VkResult (*p_vkEnumerateInstanceExtensionProperties)(const char *, uint32_t *, VkExtensionProperties *);
void * (*p_vkGetDeviceProcAddr)(VkDevice, const char *);
+ VkResult (*p_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice, VkDisplayKHR, uint32_t *, VkDisplayModePropertiesKHR *);
+ VkResult (*p_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice, VkDisplayModeKHR, uint32_t, VkDisplayPlaneCapabilitiesKHR *);
+ VkResult (*p_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice, uint32_t, uint32_t *, VkDisplayKHR *);
void * (*p_vkGetInstanceProcAddr)(VkInstance, const char *);
+ VkResult (*p_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice, uint32_t *, VkDisplayPlanePropertiesKHR *);
+ VkResult (*p_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice, uint32_t *, VkDisplayPropertiesKHR *);
VkResult (*p_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice, VkSurfaceKHR, VkSurfaceCapabilitiesKHR *);
VkResult (*p_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice, VkSurfaceKHR, uint32_t *, VkSurfaceFormatKHR *);
VkResult (*p_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice, VkSurfaceKHR, uint32_t *, VkPresentModeKHR *);
--
2.14.3
More information about the wine-devel
mailing list