From: Jason Ekstrand Date: Wed, 7 Oct 2015 21:13:55 +0000 (-0700) Subject: vk/0.170.2: Update to the new VK_EXT_KHR_swapchain extensions X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=89845598921afbef35b0adefee6e2eb9446ef327;p=mesa.git vk/0.170.2: Update to the new VK_EXT_KHR_swapchain extensions --- diff --git a/include/vulkan/vk_ext_khr_device_swapchain.h b/include/vulkan/vk_ext_khr_device_swapchain.h new file mode 100644 index 00000000000..3bf73c84a96 --- /dev/null +++ b/include/vulkan/vk_ext_khr_device_swapchain.h @@ -0,0 +1,210 @@ +// +// File: vk_ext_khr_device_swapchain.h +// +/* +** Copyright (c) 2015 The Khronos Group Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and/or associated documentation files (the +** "Materials"), to deal in the Materials without restriction, including +** without limitation the rights to use, copy, modify, merge, publish, +** distribute, sublicense, and/or sell copies of the Materials, and to +** permit persons to whom the Materials are furnished to do so, subject to +** the following conditions: +** +** The above copyright notice and this permission notice shall be included +** in all copies or substantial portions of the Materials. +** +** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. +*/ + +#ifndef __VK_EXT_KHR_DEVICE_SWAPCHAIN_H__ +#define __VK_EXT_KHR_DEVICE_SWAPCHAIN_H__ + +#include "vulkan.h" + +#define VK_EXT_KHR_DEVICE_SWAPCHAIN_REVISION 53 +#define VK_EXT_KHR_DEVICE_SWAPCHAIN_EXTENSION_NUMBER 2 +#define VK_EXT_KHR_DEVICE_SWAPCHAIN_EXTENSION_NAME "VK_EXT_KHR_device_swapchain" + +#ifdef __cplusplus +extern "C" +{ +#endif // __cplusplus + +// ------------------------------------------------------------------------------------------------ +// Objects + +VK_DEFINE_NONDISP_HANDLE(VkSwapchainKHR); + +// ------------------------------------------------------------------------------------------------ +// Enumeration constants + +#define VK_EXT_KHR_DEVICE_SWAPCHAIN_ENUM(type,id) ((type)((int)0xc0000000 - VK_EXT_KHR_DEVICE_SWAPCHAIN_EXTENSION_NUMBER * -1024 + (id))) +#define VK_EXT_KHR_DEVICE_SWAPCHAIN_ENUM_POSITIVE(type,id) ((type)((int)0x40000000 + (VK_EXT_KHR_DEVICE_SWAPCHAIN_EXTENSION_NUMBER - 1) * 1024 + (id))) + +// Extend VkStructureType enum with extension specific constants +#define VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR VK_EXT_KHR_DEVICE_SWAPCHAIN_ENUM(VkStructureType, 0) +#define VK_STRUCTURE_TYPE_PRESENT_INFO_KHR VK_EXT_KHR_DEVICE_SWAPCHAIN_ENUM(VkStructureType, 1) + +// Extend VkImageLayout enum with extension specific constants +#define VK_IMAGE_LAYOUT_PRESENT_SOURCE_KHR VK_EXT_KHR_DEVICE_SWAPCHAIN_ENUM(VkImageLayout, 2) + +// Extend VkResult enum with extension specific constants +// Return codes for successful operation execution +#define VK_SUBOPTIMAL_KHR VK_EXT_KHR_DEVICE_SWAPCHAIN_ENUM_POSITIVE(VkResult, 3) +// Error codes +#define VK_ERROR_OUT_OF_DATE_KHR VK_EXT_KHR_DEVICE_SWAPCHAIN_ENUM(VkResult, 4) + +// ------------------------------------------------------------------------------------------------ +// Enumerations + +typedef enum { + VK_PRESENT_MODE_IMMEDIATE_KHR = 0, + VK_PRESENT_MODE_MAILBOX_KHR = 1, + VK_PRESENT_MODE_FIFO_KHR = 2, + VK_PRESENT_MODE_BEGIN_RANGE_KHR = VK_PRESENT_MODE_IMMEDIATE_KHR, + VK_PRESENT_MODE_END_RANGE_KHR = VK_PRESENT_MODE_FIFO_KHR, + VK_PRESENT_MODE_NUM = (VK_PRESENT_MODE_FIFO_KHR - VK_PRESENT_MODE_IMMEDIATE_KHR + 1), + VK_PRESENT_MODE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkPresentModeKHR; + +typedef enum { + VK_COLORSPACE_SRGB_NONLINEAR_KHR = 0x00000000, + VK_COLORSPACE_NUM = (VK_COLORSPACE_SRGB_NONLINEAR_KHR - VK_COLORSPACE_SRGB_NONLINEAR_KHR + 1), + VK_COLORSPACE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkColorSpaceKHR; + +// ------------------------------------------------------------------------------------------------ +// Flags + +// ------------------------------------------------------------------------------------------------ +// Structures + +typedef struct { + uint32_t minImageCount; // Supported minimum number of images for the surface + uint32_t maxImageCount; // Supported maximum number of images for the surface, 0 for unlimited + + VkExtent2D currentExtent; // Current image width and height for the surface, (-1, -1) if undefined + VkExtent2D minImageExtent; // Supported minimum image width and height for the surface + VkExtent2D maxImageExtent; // Supported maximum image width and height for the surface + + VkSurfaceTransformFlagsKHR supportedTransforms;// 1 or more bits representing the transforms supported + VkSurfaceTransformKHR currentTransform; // The surface's current transform relative to the device's natural orientation + + uint32_t maxImageArraySize; // Supported maximum number of image layers for the surface + + VkImageUsageFlags supportedUsageFlags;// Supported image usage flags for the surface +} VkSurfacePropertiesKHR; + +typedef struct { + VkFormat format; // Supported pair of rendering format + VkColorSpaceKHR colorSpace; // and colorspace for the surface +} VkSurfaceFormatKHR; + +typedef struct { + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR + const void* pNext; // Pointer to next structure + + const VkSurfaceDescriptionKHR* pSurfaceDescription;// describes the swap chain's target surface + + uint32_t minImageCount; // Minimum number of presentation images the application needs + VkFormat imageFormat; // Format of the presentation images + VkColorSpaceKHR imageColorSpace; // Colorspace of the presentation images + VkExtent2D imageExtent; // Dimensions of the presentation images + VkImageUsageFlags imageUsageFlags; // Bits indicating how the presentation images will be used + VkSurfaceTransformKHR preTransform; // The transform, relative to the device's natural orientation, applied to the image content prior to presentation + uint32_t imageArraySize; // Determines the number of views for multiview/stereo presentation + + VkSharingMode sharingMode; // Sharing mode used for the presentation images + uint32_t queueFamilyCount; // Number of queue families having access to the images in case of concurrent sharing mode + const uint32_t* pQueueFamilyIndices; // Array of queue family indices having access to the images in case of concurrent sharing mode + + VkPresentModeKHR presentMode; // Which presentation mode to use for presents on this swap chain + + VkSwapchainKHR oldSwapchain; // Existing swap chain to replace, if any + + VkBool32 clipped; // Specifies whether presentable images may be affected by window clip regions +} VkSwapchainCreateInfoKHR; + +typedef struct { + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_PRESENT_INFO_KHR + const void* pNext; // Pointer to next structure + uint32_t swapchainCount; // Number of swap chains to present in this call + const VkSwapchainKHR* swapchains; // Swap chains to present an image from + const uint32_t* imageIndices; // Indices of which swapchain images to present +} VkPresentInfoKHR; + +// ------------------------------------------------------------------------------------------------ +// Function types + +typedef VkResult (VKAPI *PFN_vkGetSurfacePropertiesKHR)(VkDevice device, const VkSurfaceDescriptionKHR* pSurfaceDescription, VkSurfacePropertiesKHR* pSurfaceProperties); +typedef VkResult (VKAPI *PFN_vkGetSurfaceFormatsKHR)(VkDevice device, const VkSurfaceDescriptionKHR* pSurfaceDescription, uint32_t* pCount, VkSurfaceFormatKHR* pSurfaceFormats); +typedef VkResult (VKAPI *PFN_vkGetSurfacePresentModesKHR)(VkDevice device, const VkSurfaceDescriptionKHR* pSurfaceDescription, uint32_t* pCount, VkPresentModeKHR* pPresentModes); +typedef VkResult (VKAPI *PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, VkSwapchainKHR* pSwapchain); +typedef VkResult (VKAPI *PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain); +typedef VkResult (VKAPI *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pCount, VkImage* pSwapchainImages); +typedef VkResult (VKAPI *PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, uint32_t* pImageIndex); +typedef VkResult (VKAPI *PFN_vkQueuePresentKHR)(VkQueue queue, VkPresentInfoKHR* pPresentInfo); + +// ------------------------------------------------------------------------------------------------ +// Function prototypes + +#ifdef VK_PROTOTYPES + +VkResult VKAPI vkGetSurfacePropertiesKHR( + VkDevice device, + const VkSurfaceDescriptionKHR* pSurfaceDescription, + VkSurfacePropertiesKHR* pSurfaceProperties); + +VkResult VKAPI vkGetSurfaceFormatsKHR( + VkDevice device, + const VkSurfaceDescriptionKHR* pSurfaceDescription, + uint32_t* pCount, + VkSurfaceFormatKHR* pSurfaceFormats); + +VkResult VKAPI vkGetSurfacePresentModesKHR( + VkDevice device, + const VkSurfaceDescriptionKHR* pSurfaceDescription, + uint32_t* pCount, + VkPresentModeKHR* pPresentModes); + +VkResult VKAPI vkCreateSwapchainKHR( + VkDevice device, + const VkSwapchainCreateInfoKHR* pCreateInfo, + VkSwapchainKHR* pSwapchain); + +VkResult VKAPI vkDestroySwapchainKHR( + VkDevice device, + VkSwapchainKHR swapchain); + +VkResult VKAPI vkGetSwapchainImagesKHR( + VkDevice device, + VkSwapchainKHR swapchain, + uint32_t* pCount, + VkImage* pSwapchainImages); + +VkResult VKAPI vkAcquireNextImageKHR( + VkDevice device, + VkSwapchainKHR swapchain, + uint64_t timeout, + VkSemaphore semaphore, + uint32_t* pImageIndex); + +VkResult VKAPI vkQueuePresentKHR( + VkQueue queue, + VkPresentInfoKHR* pPresentInfo); + +#endif // VK_PROTOTYPES + +#ifdef __cplusplus +} // extern "C" +#endif // __cplusplus + +#endif // __VK_EXT_KHR_SWAPCHAIN_H__ diff --git a/include/vulkan/vk_ext_khr_swapchain.h b/include/vulkan/vk_ext_khr_swapchain.h new file mode 100644 index 00000000000..862b4d5e741 --- /dev/null +++ b/include/vulkan/vk_ext_khr_swapchain.h @@ -0,0 +1,153 @@ +// +// File: vk_ext_khr_swapchain.h +// +/* +** Copyright (c) 2015 The Khronos Group Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and/or associated documentation files (the +** "Materials"), to deal in the Materials without restriction, including +** without limitation the rights to use, copy, modify, merge, publish, +** distribute, sublicense, and/or sell copies of the Materials, and to +** permit persons to whom the Materials are furnished to do so, subject to +** the following conditions: +** +** The above copyright notice and this permission notice shall be included +** in all copies or substantial portions of the Materials. +** +** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. +*/ + +#ifndef __VK_EXT_KHR_SWAPCHAIN_H__ +#define __VK_EXT_KHR_SWAPCHAIN_H__ + +#include "vulkan.h" + +#define VK_EXT_KHR_SWAPCHAIN_REVISION 17 +#define VK_EXT_KHR_SWAPCHAIN_EXTENSION_NUMBER 1 +#define VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME "VK_EXT_KHR_swapchain" + +#ifdef __cplusplus +extern "C" +{ +#endif // __cplusplus + +// ------------------------------------------------------------------------------------------------ +// Objects + +// ------------------------------------------------------------------------------------------------ +// Enumeration constants + +#define VK_EXT_KHR_SWAPCHAIN_ENUM(type,id) ((type)((int)0xc0000000 - VK_EXT_KHR_SWAPCHAIN_EXTENSION_NUMBER * -1024 + (id))) +#define VK_EXT_KHR_SWAPCHAIN_ENUM_POSITIVE(type,id) ((type)((int)0x40000000 + (VK_EXT_KHR_SWAPCHAIN_EXTENSION_NUMBER - 1) * 1024 + (id))) + +// Extend VkStructureType enum with extension specific constants +#define VK_STRUCTURE_TYPE_SURFACE_DESCRIPTION_WINDOW_KHR VK_EXT_KHR_SWAPCHAIN_ENUM(VkStructureType, 0) + +// ------------------------------------------------------------------------------------------------ +// Enumerations + +typedef enum { + VK_SURFACE_TRANSFORM_NONE_KHR = 0, + VK_SURFACE_TRANSFORM_ROT90_KHR = 1, + VK_SURFACE_TRANSFORM_ROT180_KHR = 2, + VK_SURFACE_TRANSFORM_ROT270_KHR = 3, + VK_SURFACE_TRANSFORM_HMIRROR_KHR = 4, + VK_SURFACE_TRANSFORM_HMIRROR_ROT90_KHR = 5, + VK_SURFACE_TRANSFORM_HMIRROR_ROT180_KHR = 6, + VK_SURFACE_TRANSFORM_HMIRROR_ROT270_KHR = 7, + VK_SURFACE_TRANSFORM_INHERIT_KHR = 8, +} VkSurfaceTransformKHR; + +typedef enum { + VK_SURFACE_TRANSFORM_NONE_BIT_KHR = 0x00000001, + VK_SURFACE_TRANSFORM_ROT90_BIT_KHR = 0x00000002, + VK_SURFACE_TRANSFORM_ROT180_BIT_KHR = 0x00000004, + VK_SURFACE_TRANSFORM_ROT270_BIT_KHR = 0x00000008, + VK_SURFACE_TRANSFORM_HMIRROR_BIT_KHR = 0x00000010, + VK_SURFACE_TRANSFORM_HMIRROR_ROT90_BIT_KHR = 0x00000020, + VK_SURFACE_TRANSFORM_HMIRROR_ROT180_BIT_KHR = 0x00000040, + VK_SURFACE_TRANSFORM_HMIRROR_ROT270_BIT_KHR = 0x00000080, + VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100, +} VkSurfaceTransformFlagBitsKHR; +typedef VkFlags VkSurfaceTransformFlagsKHR; + +typedef enum { + VK_PLATFORM_WIN32_KHR = 0, + VK_PLATFORM_X11_KHR = 1, + VK_PLATFORM_XCB_KHR = 2, + VK_PLATFORM_ANDROID_KHR = 3, + VK_PLATFORM_WAYLAND_KHR = 4, + VK_PLATFORM_MIR_KHR = 5, + VK_PLATFORM_BEGIN_RANGE_KHR = VK_PLATFORM_WIN32_KHR, + VK_PLATFORM_END_RANGE_KHR = VK_PLATFORM_MIR_KHR, + VK_PLATFORM_NUM_KHR = (VK_PLATFORM_MIR_KHR - VK_PLATFORM_WIN32_KHR + 1), + VK_PLATFORM_MAX_ENUM_KHR = 0x7FFFFFFF +} VkPlatformKHR; + +// ------------------------------------------------------------------------------------------------ +// Flags + +// ------------------------------------------------------------------------------------------------ +// Structures + +// Placeholder structure header for the different types of surface description structures +typedef struct { + VkStructureType sType; // Can be any of the VK_STRUCTURE_TYPE_SURFACE_DESCRIPTION_XXX_KHR constants + const void* pNext; // Pointer to next structure +} VkSurfaceDescriptionKHR; + +// Surface description structure for a native platform window surface +typedef struct { + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_SURFACE_DESCRIPTION_WINDOW_KHR + const void* pNext; // Pointer to next structure + VkPlatformKHR platform; // e.g. VK_PLATFORM_*_KHR + void* pPlatformHandle; + void* pPlatformWindow; +} VkSurfaceDescriptionWindowKHR; + +// pPlatformHandle points to this struct when platform is VK_PLATFORM_X11_KHR +#ifdef _X11_XLIB_H_ +typedef struct { + Display* dpy; // Display connection to an X server + Window root; // To identify the X screen +} VkPlatformHandleX11KHR; +#endif /* _X11_XLIB_H_ */ + +// pPlatformHandle points to this struct when platform is VK_PLATFORM_XCB_KHR +#ifdef __XCB_H__ +typedef struct { + xcb_connection_t* connection; // XCB connection to an X server + xcb_window_t root; // To identify the X screen +} VkPlatformHandleXcbKHR; +#endif /* __XCB_H__ */ + +// ------------------------------------------------------------------------------------------------ +// Function types + +typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, const VkSurfaceDescriptionKHR* pSurfaceDescription, VkBool32* pSupported); + +// ------------------------------------------------------------------------------------------------ +// Function prototypes + +#ifdef VK_PROTOTYPES + +VkResult VKAPI vkGetPhysicalDeviceSurfaceSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + const VkSurfaceDescriptionKHR* pSurfaceDescription, + VkBool32* pSupported); + +#endif // VK_PROTOTYPES + +#ifdef __cplusplus +} // extern "C" +#endif // __cplusplus + +#endif // __VK_EXT_KHR_SWAPCHAIN_H__ diff --git a/include/vulkan/vk_wsi_device_swapchain.h b/include/vulkan/vk_wsi_device_swapchain.h deleted file mode 100644 index c6e4db27815..00000000000 --- a/include/vulkan/vk_wsi_device_swapchain.h +++ /dev/null @@ -1,249 +0,0 @@ -// -// File: vk_wsi_device_swapchain.h -// -/* -** Copyright (c) 2014 The Khronos Group Inc. -** -** Permission is hereby granted, free of charge, to any person obtaining a -** copy of this software and/or associated documentation files (the -** "Materials"), to deal in the Materials without restriction, including -** without limitation the rights to use, copy, modify, merge, publish, -** distribute, sublicense, and/or sell copies of the Materials, and to -** permit persons to whom the Materials are furnished to do so, subject to -** the following conditions: -** -** The above copyright notice and this permission notice shall be included -** in all copies or substantial portions of the Materials. -** -** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, -** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF -** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. -** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY -** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, -** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE -** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. -*/ - -#ifndef __VK_WSI_DEVICE_SWAPCHAIN_H__ -#define __VK_WSI_DEVICE_SWAPCHAIN_H__ - -#include "vulkan.h" - -#define VK_WSI_DEVICE_SWAPCHAIN_REVISION 40 -#define VK_WSI_DEVICE_SWAPCHAIN_EXTENSION_NUMBER 2 -#define VK_WSI_DEVICE_SWAPCHAIN_EXTENSION_NAME "VK_WSI_device_swapchain" - -#ifdef __cplusplus -extern "C" -{ -#endif // __cplusplus - -// ------------------------------------------------------------------------------------------------ -// Objects - -VK_DEFINE_NONDISP_HANDLE(VkSwapChainWSI); - -// ------------------------------------------------------------------------------------------------ -// Enumeration constants - -#define VK_WSI_DEVICE_SWAPCHAIN_ENUM(type,id) ((type)((int)0xc0000000 - VK_WSI_DEVICE_SWAPCHAIN_EXTENSION_NUMBER * -1024 + (id))) -#define VK_WSI_DEVICE_SWAPCHAIN_ENUM_POSITIVE(type,id) ((type)((int)0x40000000 + (VK_WSI_DEVICE_SWAPCHAIN_EXTENSION_NUMBER - 1) * 1024 + (id))) - -// Extend VkStructureType enum with extension specific constants -#define VK_STRUCTURE_TYPE_SWAP_CHAIN_CREATE_INFO_WSI VK_WSI_DEVICE_SWAPCHAIN_ENUM(VkStructureType, 0) -#define VK_STRUCTURE_TYPE_QUEUE_PRESENT_INFO_WSI VK_WSI_DEVICE_SWAPCHAIN_ENUM(VkStructureType, 1) - -// Extend VkImageLayout enum with extension specific constants -#define VK_IMAGE_LAYOUT_PRESENT_SOURCE_WSI VK_WSI_DEVICE_SWAPCHAIN_ENUM(VkImageLayout, 2) - -// Extend VkResult enum with extension specific constants -// Return codes for successful operation execution -#define VK_SUBOPTIMAL_WSI VK_WSI_DEVICE_SWAPCHAIN_ENUM_POSITIVE(VkResult, 3) -// Error codes -#define VK_ERROR_OUT_OF_DATE_WSI VK_WSI_DEVICE_SWAPCHAIN_ENUM(VkResult, 4) - -// ------------------------------------------------------------------------------------------------ -// Enumerations - -typedef enum VkSurfaceTransformWSI_ -{ - VK_SURFACE_TRANSFORM_NONE_WSI = 0, - VK_SURFACE_TRANSFORM_ROT90_WSI = 1, - VK_SURFACE_TRANSFORM_ROT180_WSI = 2, - VK_SURFACE_TRANSFORM_ROT270_WSI = 3, - VK_SURFACE_TRANSFORM_HMIRROR_WSI = 4, - VK_SURFACE_TRANSFORM_HMIRROR_ROT90_WSI = 5, - VK_SURFACE_TRANSFORM_HMIRROR_ROT180_WSI = 6, - VK_SURFACE_TRANSFORM_HMIRROR_ROT270_WSI = 7, - VK_SURFACE_TRANSFORM_INHERIT_WSI = 8, -} VkSurfaceTransformWSI; - -typedef enum VkSurfaceTransformFlagBitsWSI_ -{ - VK_SURFACE_TRANSFORM_NONE_BIT_WSI = 0x00000001, - VK_SURFACE_TRANSFORM_ROT90_BIT_WSI = 0x00000002, - VK_SURFACE_TRANSFORM_ROT180_BIT_WSI = 0x00000004, - VK_SURFACE_TRANSFORM_ROT270_BIT_WSI = 0x00000008, - VK_SURFACE_TRANSFORM_HMIRROR_BIT_WSI = 0x00000010, - VK_SURFACE_TRANSFORM_HMIRROR_ROT90_BIT_WSI = 0x00000020, - VK_SURFACE_TRANSFORM_HMIRROR_ROT180_BIT_WSI = 0x00000040, - VK_SURFACE_TRANSFORM_HMIRROR_ROT270_BIT_WSI = 0x00000080, - VK_SURFACE_TRANSFORM_INHERIT_BIT_WSI = 0x00000100, -} VkSurfaceTransformFlagBitsWSI; -typedef VkFlags VkSurfaceTransformFlagsWSI; - -typedef enum VkSurfaceInfoTypeWSI_ -{ - VK_SURFACE_INFO_TYPE_PROPERTIES_WSI = 0, - VK_SURFACE_INFO_TYPE_FORMATS_WSI = 1, - VK_SURFACE_INFO_TYPE_PRESENT_MODES_WSI = 2, - VK_SURFACE_INFO_TYPE_BEGIN_RANGE_WSI = VK_SURFACE_INFO_TYPE_PROPERTIES_WSI, - VK_SURFACE_INFO_TYPE_END_RANGE_WSI = VK_SURFACE_INFO_TYPE_PRESENT_MODES_WSI, - VK_SURFACE_INFO_TYPE_NUM_WSI = (VK_SURFACE_INFO_TYPE_PRESENT_MODES_WSI - VK_SURFACE_INFO_TYPE_PROPERTIES_WSI + 1), - VK_SURFACE_INFO_TYPE_MAX_ENUM_WSI = 0x7FFFFFFF -} VkSurfaceInfoTypeWSI; - -typedef enum VkSwapChainInfoTypeWSI_ -{ - VK_SWAP_CHAIN_INFO_TYPE_IMAGES_WSI = 0, - VK_SWAP_CHAIN_INFO_TYPE_BEGIN_RANGE_WSI = VK_SWAP_CHAIN_INFO_TYPE_IMAGES_WSI, - VK_SWAP_CHAIN_INFO_TYPE_END_RANGE_WSI = VK_SWAP_CHAIN_INFO_TYPE_IMAGES_WSI, - VK_SWAP_CHAIN_INFO_TYPE_NUM_WSI = (VK_SWAP_CHAIN_INFO_TYPE_IMAGES_WSI - VK_SWAP_CHAIN_INFO_TYPE_IMAGES_WSI + 1), - VK_SWAP_CHAIN_INFO_TYPE_MAX_ENUM_WSI = 0x7FFFFFFF -} VkSwapChainInfoTypeWSI; - -typedef enum VkPresentModeWSI_ -{ - VK_PRESENT_MODE_IMMEDIATE_WSI = 0, - VK_PRESENT_MODE_MAILBOX_WSI = 1, - VK_PRESENT_MODE_FIFO_WSI = 2, - VK_PRESENT_MODE_BEGIN_RANGE_WSI = VK_PRESENT_MODE_IMMEDIATE_WSI, - VK_PRESENT_MODE_END_RANGE_WSI = VK_PRESENT_MODE_FIFO_WSI, - VK_PRESENT_MODE_NUM = (VK_PRESENT_MODE_FIFO_WSI - VK_PRESENT_MODE_IMMEDIATE_WSI + 1), - VK_PRESENT_MODE_MAX_ENUM_WSI = 0x7FFFFFFF -} VkPresentModeWSI; - -// ------------------------------------------------------------------------------------------------ -// Flags - -// ------------------------------------------------------------------------------------------------ -// Structures - -typedef struct VkSurfacePropertiesWSI_ -{ - uint32_t minImageCount; // Supported minimum number of images for the surface - uint32_t maxImageCount; // Supported maximum number of images for the surface, 0 for unlimited - - VkExtent2D currentExtent; // Current image width and height for the surface, (-1, -1) if undefined. - VkExtent2D minImageExtent; // Supported minimum image width and height for the surface - VkExtent2D maxImageExtent; // Supported maximum image width and height for the surface - - VkSurfaceTransformFlagsWSI supportedTransforms;// 1 or more bits representing the transforms supported - VkSurfaceTransformWSI currentTransform; // The surface's current transform relative to the device's natural orientation. - - uint32_t maxImageArraySize; // Supported maximum number of image layers for the surface - - VkImageUsageFlags supportedUsageFlags;// Supported image usage flags for the surface -} VkSurfacePropertiesWSI; - -typedef struct VkSurfaceFormatPropertiesWSI_ -{ - VkFormat format; // Supported rendering format for the surface -} VkSurfaceFormatPropertiesWSI; - -typedef struct VkSurfacePresentModePropertiesWSI_ -{ - VkPresentModeWSI presentMode; // Supported presention mode for the surface -} VkSurfacePresentModePropertiesWSI; - -typedef struct VkSwapChainCreateInfoWSI_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_SWAP_CHAIN_CREATE_INFO_WSI - const void* pNext; // Pointer to next structure - - const VkSurfaceDescriptionWSI* pSurfaceDescription;// describes the swap chain's target surface - - uint32_t minImageCount; // Minimum number of presentation images the application needs - VkFormat imageFormat; // Format of the presentation images - VkExtent2D imageExtent; // Dimensions of the presentation images - VkImageUsageFlags imageUsageFlags; // Bits indicating how the presentation images will be used - VkSurfaceTransformWSI preTransform; // The transform, relative to the device's natural orientation, applied to the image content prior to presentation - uint32_t imageArraySize; // Determines the number of views for multiview/stereo presentation - - VkPresentModeWSI presentMode; // Which presentation mode to use for presents on this swap chain. - - VkSwapChainWSI oldSwapChain; // Existing swap chain to replace, if any. - - VkBool32 clipped; // Specifies whether presentable images may be affected by window clip regions. -} VkSwapChainCreateInfoWSI; - -typedef struct VkSwapChainImagePropertiesWSI_ -{ - VkImage image; // Persistent swap chain image handle -} VkSwapChainImagePropertiesWSI; - -typedef struct VkPresentInfoWSI_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_QUEUE_PRESENT_INFO_WSI - const void* pNext; // Pointer to next structure - uint32_t swapChainCount; // Number of swap chains to present in this call - const VkSwapChainWSI* swapChains; // Swap chains to present an image from. - const uint32_t* imageIndices; // Indices of which swapChain images to present -} VkPresentInfoWSI; - -// ------------------------------------------------------------------------------------------------ -// Function types - -typedef VkResult (VKAPI *PFN_vkGetSurfaceInfoWSI)(VkDevice device, const VkSurfaceDescriptionWSI* pSurfaceDescription, VkSurfaceInfoTypeWSI infoType, size_t* pDataSize, void* pData); -typedef VkResult (VKAPI *PFN_vkCreateSwapChainWSI)(VkDevice device, const VkSwapChainCreateInfoWSI* pCreateInfo, VkSwapChainWSI* pSwapChain); -typedef VkResult (VKAPI *PFN_vkDestroySwapChainWSI)(VkDevice device, VkSwapChainWSI swapChain); -typedef VkResult (VKAPI *PFN_vkGetSwapChainInfoWSI)(VkDevice device, VkSwapChainWSI swapChain, VkSwapChainInfoTypeWSI infoType, size_t* pDataSize, void* pData); -typedef VkResult (VKAPI *PFN_vkAcquireNextImageWSI)(VkDevice device, VkSwapChainWSI swapChain, uint64_t timeout, VkSemaphore semaphore, uint32_t* pImageIndex); -typedef VkResult (VKAPI *PFN_vkQueuePresentWSI)(VkQueue queue, VkPresentInfoWSI* pPresentInfo); - -// ------------------------------------------------------------------------------------------------ -// Function prototypes - -#ifdef VK_PROTOTYPES - -VkResult VKAPI vkGetSurfaceInfoWSI( - VkDevice device, - const VkSurfaceDescriptionWSI* pSurfaceDescription, - VkSurfaceInfoTypeWSI infoType, - size_t* pDataSize, - void* pData); - -VkResult VKAPI vkCreateSwapChainWSI( - VkDevice device, - const VkSwapChainCreateInfoWSI* pCreateInfo, - VkSwapChainWSI* pSwapChain); - -VkResult VKAPI vkDestroySwapChainWSI( - VkDevice device, - VkSwapChainWSI swapChain); - -VkResult VKAPI vkGetSwapChainInfoWSI( - VkDevice device, - VkSwapChainWSI swapChain, - VkSwapChainInfoTypeWSI infoType, - size_t* pDataSize, - void* pData); - -VkResult VKAPI vkAcquireNextImageWSI( - VkDevice device, - VkSwapChainWSI swapChain, - uint64_t timeout, - VkSemaphore semaphore, - uint32_t* pImageIndex); - -VkResult VKAPI vkQueuePresentWSI( - VkQueue queue, - VkPresentInfoWSI* pPresentInfo); - -#endif // VK_PROTOTYPES - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus - -#endif // __VK_WSI_SWAPCHAIN_H__ diff --git a/include/vulkan/vk_wsi_swapchain.h b/include/vulkan/vk_wsi_swapchain.h deleted file mode 100644 index 64704d47318..00000000000 --- a/include/vulkan/vk_wsi_swapchain.h +++ /dev/null @@ -1,133 +0,0 @@ -// -// File: vk_wsi_swapchain.h -// -/* -** Copyright (c) 2014 The Khronos Group Inc. -** -** Permission is hereby granted, free of charge, to any person obtaining a -** copy of this software and/or associated documentation files (the -** "Materials"), to deal in the Materials without restriction, including -** without limitation the rights to use, copy, modify, merge, publish, -** distribute, sublicense, and/or sell copies of the Materials, and to -** permit persons to whom the Materials are furnished to do so, subject to -** the following conditions: -** -** The above copyright notice and this permission notice shall be included -** in all copies or substantial portions of the Materials. -** -** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, -** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF -** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. -** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY -** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, -** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE -** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. -*/ - -#ifndef __VK_WSI_SWAPCHAIN_H__ -#define __VK_WSI_SWAPCHAIN_H__ - -#include "vulkan.h" - -#define VK_WSI_SWAPCHAIN_REVISION 12 -#define VK_WSI_SWAPCHAIN_EXTENSION_NUMBER 1 -#define VK_WSI_SWAPCHAIN_EXTENSION_NAME "VK_WSI_swapchain" - -#ifdef __cplusplus -extern "C" -{ -#endif // __cplusplus - -// ------------------------------------------------------------------------------------------------ -// Objects - -// ------------------------------------------------------------------------------------------------ -// Enumeration constants - -#define VK_WSI_SWAPCHAIN_ENUM(type,id) ((type)((int)0xc0000000 - VK_WSI_SWAPCHAIN_EXTENSION_NUMBER * -1024 + (id))) -#define VK_WSI_SWAPCHAIN_ENUM_POSITIVE(type,id) ((type)((int)0x40000000 + (VK_WSI_SWAPCHAIN_EXTENSION_NUMBER - 1) * 1024 + (id))) - -// Extend VkStructureType enum with extension specific constants -#define VK_STRUCTURE_TYPE_SURFACE_DESCRIPTION_WINDOW_WSI VK_WSI_SWAPCHAIN_ENUM(VkStructureType, 0) - -// ------------------------------------------------------------------------------------------------ -// Enumerations - -typedef enum VkPlatformWSI_ -{ - VK_PLATFORM_WIN32_WSI = 0, - VK_PLATFORM_X11_WSI = 1, - VK_PLATFORM_XCB_WSI = 2, - VK_PLATFORM_ANDROID_WSI = 3, - VK_PLATFORM_WAYLAND_WSI = 4, - VK_PLATFORM_MIR_WSI = 5, - VK_PLATFORM_BEGIN_RANGE_WSI = VK_PLATFORM_WIN32_WSI, - VK_PLATFORM_END_RANGE_WSI = VK_PLATFORM_MIR_WSI, - VK_PLATFORM_NUM_WSI = (VK_PLATFORM_MIR_WSI - VK_PLATFORM_WIN32_WSI + 1), - VK_PLATFORM_MAX_ENUM_WSI = 0x7FFFFFFF -} VkPlatformWSI; - -// ------------------------------------------------------------------------------------------------ -// Flags - -// ------------------------------------------------------------------------------------------------ -// Structures - -// pPlatformHandle points to this struct when platform is VK_PLATFORM_X11_WSI -#ifdef _X11_XLIB_H_ -typedef struct VkPlatformHandleX11WSI_ -{ - Display* dpy; // Display connection to an X server - Window root; // To identify the X screen -} VkPlatformHandleX11WSI; -#endif /* _X11_XLIB_H_ */ - -// pPlatformHandle points to this struct when platform is VK_PLATFORM_XCB_WSI -#ifdef __XCB_H__ -typedef struct VkPlatformHandleXcbWSI_ -{ - xcb_connection_t* connection; // XCB connection to an X server - xcb_window_t root; // To identify the X screen -} VkPlatformHandleXcbWSI; -#endif /* __XCB_H__ */ - -// Placeholder structure header for the different types of surface description structures -typedef struct VkSurfaceDescriptionWSI_ -{ - VkStructureType sType; // Can be any of the VK_STRUCTURE_TYPE_SURFACE_DESCRIPTION_XXX_WSI constants - const void* pNext; // Pointer to next structure -} VkSurfaceDescriptionWSI; - -// Surface description structure for a native platform window surface -typedef struct VkSurfaceDescriptionWindowWSI_ -{ - VkStructureType sType; // Must be VK_STRUCTURE_TYPE_SURFACE_DESCRIPTION_WINDOW_WSI - const void* pNext; // Pointer to next structure - VkPlatformWSI platform; // e.g. VK_PLATFORM_*_WSI - void* pPlatformHandle; - void* pPlatformWindow; -} VkSurfaceDescriptionWindowWSI; - -// ------------------------------------------------------------------------------------------------ -// Function types - -typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceSurfaceSupportWSI)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, const VkSurfaceDescriptionWSI* pSurfaceDescription, VkBool32* pSupported); - -// ------------------------------------------------------------------------------------------------ -// Function prototypes - -#ifdef VK_PROTOTYPES - -VkResult VKAPI vkGetPhysicalDeviceSurfaceSupportWSI( - VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - const VkSurfaceDescriptionWSI* pSurfaceDescription, - VkBool32* pSupported); - -#endif // VK_PROTOTYPES - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus - -#endif // __VK_WSI_SWAPCHAIN_H__ diff --git a/src/vulkan/Makefile.am b/src/vulkan/Makefile.am index 0d0abd27300..c5a076d2ba3 100644 --- a/src/vulkan/Makefile.am +++ b/src/vulkan/Makefile.am @@ -27,8 +27,8 @@ vulkan_include_HEADERS = \ $(top_srcdir)/include/vulkan/vk_platform.h \ $(top_srcdir)/include/vulkan/vulkan.h \ $(top_srcdir)/include/vulkan/vulkan_intel.h \ - $(top_srcdir)/include/vulkan/vk_wsi_swapchain.h \ - $(top_srcdir)/include/vulkan/vk_wsi_device_swapchain.h + $(top_srcdir)/include/vulkan/vk_ext_khr_swapchain.h \ + $(top_srcdir)/include/vulkan/vk_ext_khr_device_swapchain.h lib_LTLIBRARIES = libvulkan.la diff --git a/src/vulkan/anv_device.c b/src/vulkan/anv_device.c index 4e677054afe..295aea9e434 100644 --- a/src/vulkan/anv_device.c +++ b/src/vulkan/anv_device.c @@ -122,15 +122,15 @@ static const VkAllocCallbacks default_alloc_callbacks = { static const VkExtensionProperties global_extensions[] = { { - .extName = "VK_WSI_swapchain", - .specVersion = 12 + .extName = VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME, + .specVersion = 17, }, }; static const VkExtensionProperties device_extensions[] = { { - .extName = "VK_WSI_device_swapchain", - .specVersion = 12 + .extName = VK_EXT_KHR_DEVICE_SWAPCHAIN_EXTENSION_NAME, + .specVersion = 53, }, }; diff --git a/src/vulkan/anv_private.h b/src/vulkan/anv_private.h index 0d1998d659c..dc5a2350e86 100644 --- a/src/vulkan/anv_private.h +++ b/src/vulkan/anv_private.h @@ -46,8 +46,8 @@ #define VK_PROTOTYPES #include #include -#include -#include +#include +#include #include "anv_entrypoints.h" @@ -429,7 +429,7 @@ struct anv_instance { uint32_t physicalDeviceCount; struct anv_physical_device physicalDevice; - struct anv_wsi_implementation * wsi_impl[VK_PLATFORM_NUM_WSI]; + struct anv_wsi_implementation * wsi_impl[VK_PLATFORM_NUM_KHR]; }; VkResult anv_init_wsi(struct anv_instance *instance); diff --git a/src/vulkan/anv_util.c b/src/vulkan/anv_util.c index 628e399cb3e..22fd01c9495 100644 --- a/src/vulkan/anv_util.c +++ b/src/vulkan/anv_util.c @@ -104,7 +104,7 @@ __vk_errorf(VkResult error, const char *file, int line, const char *format, ...) ERROR_CASE(VK_ERROR_INCOMPATIBLE_DRIVER) /* Extension errors */ - ERROR_CASE(VK_ERROR_OUT_OF_DATE_WSI) + ERROR_CASE(VK_ERROR_OUT_OF_DATE_KHR) default: assert(!"Unknown error"); diff --git a/src/vulkan/anv_wsi.c b/src/vulkan/anv_wsi.c index 21e01fc61f2..241481b9895 100644 --- a/src/vulkan/anv_wsi.c +++ b/src/vulkan/anv_wsi.c @@ -55,18 +55,18 @@ anv_finish_wsi(struct anv_instance *instance) } VkResult -anv_GetPhysicalDeviceSurfaceSupportWSI( +anv_GetPhysicalDeviceSurfaceSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, - const VkSurfaceDescriptionWSI* pSurfaceDescription, + const VkSurfaceDescriptionKHR* pSurfaceDescription, VkBool32* pSupported) { ANV_FROM_HANDLE(anv_physical_device, physical_device, physicalDevice); assert(pSurfaceDescription->sType == - VK_STRUCTURE_TYPE_SURFACE_DESCRIPTION_WINDOW_WSI); + VK_STRUCTURE_TYPE_SURFACE_DESCRIPTION_WINDOW_KHR); - VkSurfaceDescriptionWindowWSI *window = (void *)pSurfaceDescription; + VkSurfaceDescriptionWindowKHR *window = (void *)pSurfaceDescription; struct anv_wsi_implementation *impl = physical_device->instance->wsi_impl[window->platform]; @@ -81,116 +81,135 @@ anv_GetPhysicalDeviceSurfaceSupportWSI( } VkResult -anv_GetSurfaceInfoWSI( +anv_GetSurfacePropertiesKHR( VkDevice _device, - const VkSurfaceDescriptionWSI* pSurfaceDescription, - VkSurfaceInfoTypeWSI infoType, - size_t* pDataSize, - void* pData) + const VkSurfaceDescriptionKHR* pSurfaceDescription, + VkSurfacePropertiesKHR* pSurfaceProperties) { ANV_FROM_HANDLE(anv_device, device, _device); assert(pSurfaceDescription->sType == - VK_STRUCTURE_TYPE_SURFACE_DESCRIPTION_WINDOW_WSI); - VkSurfaceDescriptionWindowWSI *window = - (VkSurfaceDescriptionWindowWSI *)pSurfaceDescription; + VK_STRUCTURE_TYPE_SURFACE_DESCRIPTION_WINDOW_KHR); + VkSurfaceDescriptionWindowKHR *window = + (VkSurfaceDescriptionWindowKHR *)pSurfaceDescription; struct anv_wsi_implementation *impl = device->instance->wsi_impl[window->platform]; assert(impl); - return impl->get_surface_info(impl, device, window, infoType, - pDataSize, pData); + return impl->get_surface_properties(impl, device, window, + pSurfaceProperties); } VkResult -anv_CreateSwapChainWSI( +anv_GetSurfaceFormatsKHR( VkDevice _device, - const VkSwapChainCreateInfoWSI* pCreateInfo, - VkSwapChainWSI* pSwapChain) + const VkSurfaceDescriptionKHR* pSurfaceDescription, + uint32_t* pCount, + VkSurfaceFormatKHR* pSurfaceFormats) { ANV_FROM_HANDLE(anv_device, device, _device); - struct anv_swap_chain *swap_chain; + + assert(pSurfaceDescription->sType == + VK_STRUCTURE_TYPE_SURFACE_DESCRIPTION_WINDOW_KHR); + VkSurfaceDescriptionWindowKHR *window = + (VkSurfaceDescriptionWindowKHR *)pSurfaceDescription; + + struct anv_wsi_implementation *impl = + device->instance->wsi_impl[window->platform]; + + assert(impl); + + return impl->get_surface_formats(impl, device, window, + pCount, pSurfaceFormats); +} + +VkResult +anv_CreateSwapchainKHR( + VkDevice _device, + const VkSwapchainCreateInfoKHR* pCreateInfo, + VkSwapchainKHR* pSwapchain) +{ + ANV_FROM_HANDLE(anv_device, device, _device); + struct anv_swapchain *swapchain; VkResult result; assert(pCreateInfo->pSurfaceDescription->sType == - VK_STRUCTURE_TYPE_SURFACE_DESCRIPTION_WINDOW_WSI); - VkSurfaceDescriptionWindowWSI *window = - (VkSurfaceDescriptionWindowWSI *)pCreateInfo->pSurfaceDescription; + VK_STRUCTURE_TYPE_SURFACE_DESCRIPTION_WINDOW_KHR); + VkSurfaceDescriptionWindowKHR *window = + (VkSurfaceDescriptionWindowKHR *)pCreateInfo->pSurfaceDescription; struct anv_wsi_implementation *impl = device->instance->wsi_impl[window->platform]; assert(impl); - result = impl->create_swap_chain(impl, device, pCreateInfo, &swap_chain); + result = impl->create_swapchain(impl, device, pCreateInfo, &swapchain); if (result == VK_SUCCESS) - *pSwapChain = anv_swap_chain_to_handle(swap_chain); + *pSwapchain = anv_swapchain_to_handle(swapchain); return result; } VkResult -anv_DestroySwapChainWSI( +anv_DestroySwapchainKHR( VkDevice device, - VkSwapChainWSI swapChain) + VkSwapchainKHR swapChain) { - ANV_FROM_HANDLE(anv_swap_chain, swap_chain, swapChain); + ANV_FROM_HANDLE(anv_swapchain, swapchain, swapChain); - assert(swap_chain->device == anv_device_from_handle(device)); + assert(swapchain->device == anv_device_from_handle(device)); - return swap_chain->destroy(swap_chain); + return swapchain->destroy(swapchain); } VkResult -anv_GetSwapChainInfoWSI( +anv_GetSwapchainImagesKHR( VkDevice device, - VkSwapChainWSI swapChain, - VkSwapChainInfoTypeWSI infoType, - size_t* pDataSize, - void* pData) + VkSwapchainKHR _swapchain, + uint32_t* pCount, + VkImage* pSwapchainImages) { - ANV_FROM_HANDLE(anv_swap_chain, swap_chain, swapChain); + ANV_FROM_HANDLE(anv_swapchain, swapchain, _swapchain); - assert(swap_chain->device == anv_device_from_handle(device)); + assert(swapchain->device == anv_device_from_handle(device)); - return swap_chain->get_swap_chain_info(swap_chain, infoType, - pDataSize, pData); + return swapchain->get_images(swapchain, pCount, pSwapchainImages); } VkResult -anv_AcquireNextImageWSI( +anv_AcquireNextImageKHR( VkDevice device, - VkSwapChainWSI swapChain, + VkSwapchainKHR _swapchain, uint64_t timeout, VkSemaphore semaphore, uint32_t* pImageIndex) { - ANV_FROM_HANDLE(anv_swap_chain, swap_chain, swapChain); + ANV_FROM_HANDLE(anv_swapchain, swapchain, _swapchain); - assert(swap_chain->device == anv_device_from_handle(device)); + assert(swapchain->device == anv_device_from_handle(device)); - return swap_chain->acquire_next_image(swap_chain, - timeout, semaphore, pImageIndex); + return swapchain->acquire_next_image(swapchain, + timeout, semaphore, pImageIndex); } VkResult -anv_QueuePresentWSI( +anv_QueuePresentKHR( VkQueue _queue, - VkPresentInfoWSI* pPresentInfo) + VkPresentInfoKHR* pPresentInfo) { ANV_FROM_HANDLE(anv_queue, queue, _queue); VkResult result; - for (uint32_t i = 0; i < pPresentInfo->swapChainCount; i++) { - ANV_FROM_HANDLE(anv_swap_chain, swap_chain, pPresentInfo->swapChains[i]); + for (uint32_t i = 0; i < pPresentInfo->swapchainCount; i++) { + ANV_FROM_HANDLE(anv_swapchain, swapchain, pPresentInfo->swapchains[i]); - assert(swap_chain->device == queue->device); + assert(swapchain->device == queue->device); - result = swap_chain->queue_present(swap_chain, queue, - pPresentInfo->imageIndices[i]); + result = swapchain->queue_present(swapchain, queue, + pPresentInfo->imageIndices[i]); /* TODO: What if one of them returns OUT_OF_DATE? */ if (result != VK_SUCCESS) return result; diff --git a/src/vulkan/anv_wsi.h b/src/vulkan/anv_wsi.h index cbff854c2fc..280049b0e86 100644 --- a/src/vulkan/anv_wsi.h +++ b/src/vulkan/anv_wsi.h @@ -25,37 +25,45 @@ #include "anv_private.h" -struct anv_swap_chain { +struct anv_swapchain { struct anv_device * device; - VkResult (*destroy)(struct anv_swap_chain *swap_chain); - VkResult (*get_swap_chain_info)(struct anv_swap_chain *swap_chain, - VkSwapChainInfoTypeWSI infoType, - size_t *pDataSize, void *pData); - VkResult (*acquire_next_image)(struct anv_swap_chain *swap_chain, + VkResult (*destroy)(struct anv_swapchain *swapchain); + VkResult (*get_images)(struct anv_swapchain *swapchain, + uint32_t *pCount, VkImage *pSwapchainImages); + VkResult (*acquire_next_image)(struct anv_swapchain *swap_chain, uint64_t timeout, VkSemaphore semaphore, uint32_t *image_index); - VkResult (*queue_present)(struct anv_swap_chain *swap_chain, + VkResult (*queue_present)(struct anv_swapchain *swap_chain, struct anv_queue *queue, uint32_t image_index); }; -ANV_DEFINE_NONDISP_HANDLE_CASTS(anv_swap_chain, VkSwapChainWSI) +ANV_DEFINE_NONDISP_HANDLE_CASTS(anv_swapchain, VkSwapchainKHR) struct anv_wsi_implementation { VkResult (*get_window_supported)(struct anv_wsi_implementation *impl, struct anv_physical_device *physical_device, - const VkSurfaceDescriptionWindowWSI *window, + const VkSurfaceDescriptionWindowKHR *window, VkBool32 *pSupported); - VkResult (*get_surface_info)(struct anv_wsi_implementation *impl, + VkResult (*get_surface_properties)(struct anv_wsi_implementation *impl, + struct anv_device *device, + const VkSurfaceDescriptionWindowKHR *window, + VkSurfacePropertiesKHR *properties); + VkResult (*get_surface_formats)(struct anv_wsi_implementation *impl, + struct anv_device *device, + const VkSurfaceDescriptionWindowKHR *window, + uint32_t *pCount, + VkSurfaceFormatKHR *pSurfaceFormats); + VkResult (*get_surface_present_modes)(struct anv_wsi_implementation *impl, + struct anv_device *device, + const VkSurfaceDescriptionWindowKHR *window, + uint32_t *pCount, + VkPresentModeKHR *pPresentModes); + VkResult (*create_swapchain)(struct anv_wsi_implementation *impl, struct anv_device *device, - VkSurfaceDescriptionWindowWSI *window, - VkSurfaceInfoTypeWSI infoType, - size_t* pDataSize, void* pData); - VkResult (*create_swap_chain)(struct anv_wsi_implementation *impl, - struct anv_device *device, - const VkSwapChainCreateInfoWSI *pCreateInfo, - struct anv_swap_chain **swap_chain); + const VkSwapchainCreateInfoKHR *pCreateInfo, + struct anv_swapchain **swapchain); }; VkResult anv_x11_init_wsi(struct anv_instance *instance); diff --git a/src/vulkan/anv_wsi_wayland.c b/src/vulkan/anv_wsi_wayland.c index ba3ce8a2c65..f87f3ffef19 100644 --- a/src/vulkan/anv_wsi_wayland.c +++ b/src/vulkan/anv_wsi_wayland.c @@ -298,7 +298,7 @@ wsi_wl_get_display(struct wsi_wayland *wsi, struct wl_display *wl_display) static VkResult wsi_wl_get_window_supported(struct anv_wsi_implementation *impl, struct anv_physical_device *physical_device, - const VkSurfaceDescriptionWindowWSI *window, + const VkSurfaceDescriptionWindowKHR *window, VkBool32 *pSupported) { struct wsi_wayland *wsi = (struct wsi_wayland *)impl; @@ -308,84 +308,82 @@ wsi_wl_get_window_supported(struct anv_wsi_implementation *impl, return VK_SUCCESS; } -static const VkSurfacePresentModePropertiesWSI present_modes[] = { - { VK_PRESENT_MODE_MAILBOX_WSI }, - { VK_PRESENT_MODE_FIFO_WSI }, +static const VkPresentModeKHR present_modes[] = { + VK_PRESENT_MODE_MAILBOX_KHR, + VK_PRESENT_MODE_FIFO_KHR, }; static VkResult -wsi_wl_get_surface_info(struct anv_wsi_implementation *impl, - struct anv_device *device, - VkSurfaceDescriptionWindowWSI *window, - VkSurfaceInfoTypeWSI infoType, - size_t* pDataSize, void* pData) +wsi_wl_get_surface_properties(struct anv_wsi_implementation *impl, + struct anv_device *device, + const VkSurfaceDescriptionWindowKHR *window, + VkSurfacePropertiesKHR *props) { - struct wsi_wayland *wsi = (struct wsi_wayland *)impl; - - assert(pDataSize != NULL); + props->minImageCount = MIN_NUM_IMAGES; + props->maxImageCount = 4; + props->currentExtent = (VkExtent2D) { -1, -1 }; + props->minImageExtent = (VkExtent2D) { 1, 1 }; + props->maxImageExtent = (VkExtent2D) { INT16_MAX, INT16_MAX }; + props->supportedTransforms = VK_SURFACE_TRANSFORM_NONE_BIT_KHR; + props->currentTransform = VK_SURFACE_TRANSFORM_NONE_KHR; + props->maxImageArraySize = 1; + props->supportedUsageFlags = + VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT | + VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; - switch (infoType) { - default: - unreachable("bad VkSurfaceInfoTypeWSI"); - case VK_SURFACE_INFO_TYPE_PROPERTIES_WSI: { - VkSurfacePropertiesWSI *props = pData; - - if (pData == NULL) { - *pDataSize = sizeof(*props); - return VK_SUCCESS; - } + return VK_SUCCESS; +} - assert(*pDataSize >= sizeof(*props)); +static VkResult +wsi_wl_get_surface_formats(struct anv_wsi_implementation *impl, + struct anv_device *device, + const VkSurfaceDescriptionWindowKHR *window, + uint32_t *pCount, + VkSurfaceFormatKHR *pSurfaceFormats) +{ + struct wsi_wayland *wsi = (struct wsi_wayland *)impl; + struct wsi_wl_display *display = + wsi_wl_get_display(wsi, window->pPlatformHandle); - props->minImageCount = MIN_NUM_IMAGES; - props->maxImageCount = 4; - props->currentExtent = (VkExtent2D) { -1, -1 }; - props->minImageExtent = (VkExtent2D) { 1, 1 }; - props->maxImageExtent = (VkExtent2D) { INT16_MAX, INT16_MAX }; - props->supportedTransforms = VK_SURFACE_TRANSFORM_NONE_BIT_WSI; - props->currentTransform = VK_SURFACE_TRANSFORM_NONE_WSI; - props->maxImageArraySize = 1; - props->supportedUsageFlags = - VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT | - VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; + uint32_t count = anv_vector_length(&display->formats); + if (pSurfaceFormats == NULL) { + *pCount = count; return VK_SUCCESS; } - case VK_SURFACE_INFO_TYPE_FORMATS_WSI: { - VkSurfaceFormatPropertiesWSI *formats = pData; - - struct wsi_wl_display *display = - wsi_wl_get_display(wsi, window->pPlatformHandle); - - uint32_t size = anv_vector_length(&display->formats) * sizeof(*formats); - - if (pData == NULL) { - *pDataSize = size; - return VK_SUCCESS; - } + assert(*pCount >= count); + *pCount = count; - assert(*pDataSize >= size); - *pDataSize = size; + VkFormat *f; + anv_vector_foreach(f, &display->formats) { + *(pSurfaceFormats++) = (VkSurfaceFormatKHR) { + .format = *f, + /* TODO: We should get this from the compositor somehow */ + .colorSpace = VK_COLORSPACE_SRGB_NONLINEAR_KHR, + }; + } - VkFormat *f; - anv_vector_foreach(f, &display->formats) - (formats++)->format = *f; + return VK_SUCCESS; +} +static VkResult +wsi_wl_get_surface_present_modes(struct anv_wsi_implementation *impl, + struct anv_device *device, + const VkSurfaceDescriptionWindowKHR *window, + uint32_t *pCount, + VkPresentModeKHR *pPresentModes) +{ + if (pPresentModes == NULL) { + *pCount = ARRAY_SIZE(present_modes); return VK_SUCCESS; } - case VK_SURFACE_INFO_TYPE_PRESENT_MODES_WSI: - if (pData == NULL) { - *pDataSize = sizeof(present_modes); - return VK_SUCCESS; - } + assert(*pCount >= ARRAY_SIZE(present_modes)); + typed_memcpy(pPresentModes, present_modes, *pCount); + *pCount = ARRAY_SIZE(present_modes); - assert(*pDataSize >= sizeof(present_modes)); - memcpy(pData, present_modes, *pDataSize); - - return VK_SUCCESS; - } + return VK_SUCCESS; } struct wsi_wl_image { @@ -395,8 +393,8 @@ struct wsi_wl_image { bool busy; }; -struct wsi_wl_swap_chain { - struct anv_swap_chain base; +struct wsi_wl_swapchain { + struct anv_swapchain base; struct wsi_wl_display * display; struct wl_event_queue * queue; @@ -406,7 +404,7 @@ struct wsi_wl_swap_chain { VkFormat vk_format; uint32_t drm_format; - VkPresentModeWSI present_mode; + VkPresentModeKHR present_mode; bool fifo_ready; uint32_t image_count; @@ -414,44 +412,32 @@ struct wsi_wl_swap_chain { }; static VkResult -wsi_wl_get_swap_chain_info(struct anv_swap_chain *anv_chain, - VkSwapChainInfoTypeWSI infoType, - size_t* pDataSize, void* pData) +wsi_wl_get_images(struct anv_swapchain *anv_chain, + uint32_t *pCount, VkImage *pSwapchainImages) { - struct wsi_wl_swap_chain *chain = (struct wsi_wl_swap_chain *)anv_chain; - size_t size; - - switch (infoType) { - default: - unreachable("bad VkSwapChainInfoTypeWSI"); - case VK_SWAP_CHAIN_INFO_TYPE_IMAGES_WSI: { - VkSwapChainImagePropertiesWSI *images = pData; + struct wsi_wl_swapchain *chain = (struct wsi_wl_swapchain *)anv_chain; - size = chain->image_count * sizeof(*images); - - if (pData == NULL) { - *pDataSize = size; - return VK_SUCCESS; - } + if (pSwapchainImages == NULL) { + *pCount = chain->image_count; + return VK_SUCCESS; + } - assert(size <= *pDataSize); - for (uint32_t i = 0; i < chain->image_count; i++) - images[i].image = anv_image_to_handle(chain->images[i].image); + assert(chain->image_count <= *pCount); + for (uint32_t i = 0; i < chain->image_count; i++) + pSwapchainImages[i] = anv_image_to_handle(chain->images[i].image); - *pDataSize = size; + *pCount = chain->image_count; - return VK_SUCCESS; - } - } + return VK_SUCCESS; } static VkResult -wsi_wl_acquire_next_image(struct anv_swap_chain *anv_chain, +wsi_wl_acquire_next_image(struct anv_swapchain *anv_chain, uint64_t timeout, VkSemaphore semaphore, uint32_t *image_index) { - struct wsi_wl_swap_chain *chain = (struct wsi_wl_swap_chain *)anv_chain; + struct wsi_wl_swapchain *chain = (struct wsi_wl_swapchain *)anv_chain; int ret = wl_display_dispatch_queue_pending(chain->display->display, chain->queue); @@ -460,7 +446,7 @@ wsi_wl_acquire_next_image(struct anv_swap_chain *anv_chain, * kicked by the server so this seems more-or-less correct. */ if (ret < 0) - return vk_error(VK_ERROR_OUT_OF_DATE_WSI); + return vk_error(VK_ERROR_OUT_OF_DATE_KHR); while (1) { for (uint32_t i = 0; i < chain->image_count; i++) { @@ -477,14 +463,14 @@ wsi_wl_acquire_next_image(struct anv_swap_chain *anv_chain, int ret = wl_display_dispatch_queue(chain->display->display, chain->queue); if (ret < 0) - return vk_error(VK_ERROR_OUT_OF_DATE_WSI); + return vk_error(VK_ERROR_OUT_OF_DATE_KHR); } } static void frame_handle_done(void *data, struct wl_callback *callback, uint32_t serial) { - struct wsi_wl_swap_chain *chain = data; + struct wsi_wl_swapchain *chain = data; chain->fifo_ready = true; @@ -496,18 +482,18 @@ static const struct wl_callback_listener frame_listener = { }; static VkResult -wsi_wl_queue_present(struct anv_swap_chain *anv_chain, +wsi_wl_queue_present(struct anv_swapchain *anv_chain, struct anv_queue *queue, uint32_t image_index) { - struct wsi_wl_swap_chain *chain = (struct wsi_wl_swap_chain *)anv_chain; + struct wsi_wl_swapchain *chain = (struct wsi_wl_swapchain *)anv_chain; - if (chain->present_mode == VK_PRESENT_MODE_FIFO_WSI) { + if (chain->present_mode == VK_PRESENT_MODE_FIFO_KHR) { while (!chain->fifo_ready) { int ret = wl_display_dispatch_queue(chain->display->display, chain->queue); if (ret < 0) - return vk_error(VK_ERROR_OUT_OF_DATE_WSI); + return vk_error(VK_ERROR_OUT_OF_DATE_KHR); } } @@ -515,7 +501,7 @@ wsi_wl_queue_present(struct anv_swap_chain *anv_chain, wl_surface_attach(chain->surface, chain->images[image_index].buffer, 0, 0); wl_surface_damage(chain->surface, 0, 0, INT32_MAX, INT32_MAX); - if (chain->present_mode == VK_PRESENT_MODE_FIFO_WSI) { + if (chain->present_mode == VK_PRESENT_MODE_FIFO_KHR) { struct wl_callback *frame = wl_surface_frame(chain->surface); wl_proxy_set_queue((struct wl_proxy *)frame, chain->queue); wl_callback_add_listener(frame, &frame_listener, chain); @@ -529,7 +515,7 @@ wsi_wl_queue_present(struct anv_swap_chain *anv_chain, } static void -wsi_wl_image_finish(struct wsi_wl_swap_chain *chain, struct wsi_wl_image *image) +wsi_wl_image_finish(struct wsi_wl_swapchain *chain, struct wsi_wl_image *image) { VkDevice vk_device = anv_device_to_handle(chain->base.device); anv_FreeMemory(vk_device, anv_device_memory_to_handle(image->memory)); @@ -551,7 +537,7 @@ static const struct wl_buffer_listener buffer_listener = { }; static VkResult -wsi_wl_image_init(struct wsi_wl_swap_chain *chain, struct wsi_wl_image *image) +wsi_wl_image_init(struct wsi_wl_swapchain *chain, struct wsi_wl_image *image) { VkDevice vk_device = anv_device_to_handle(chain->base.device); VkResult result; @@ -651,9 +637,9 @@ fail_image: } static VkResult -wsi_wl_destroy_swap_chain(struct anv_swap_chain *anv_chain) +wsi_wl_destroy_swapchain(struct anv_swapchain *anv_chain) { - struct wsi_wl_swap_chain *chain = (struct wsi_wl_swap_chain *)anv_chain; + struct wsi_wl_swapchain *chain = (struct wsi_wl_swapchain *)anv_chain; for (uint32_t i = 0; i < chain->image_count; i++) { if (chain->images[i].buffer) @@ -666,22 +652,22 @@ wsi_wl_destroy_swap_chain(struct anv_swap_chain *anv_chain) } static VkResult -wsi_wl_create_swap_chain(struct anv_wsi_implementation *impl, +wsi_wl_create_swapchain(struct anv_wsi_implementation *impl, struct anv_device *device, - const VkSwapChainCreateInfoWSI *pCreateInfo, - struct anv_swap_chain **swap_chain_out) + const VkSwapchainCreateInfoKHR *pCreateInfo, + struct anv_swapchain **swapchain_out) { struct wsi_wayland *wsi = (struct wsi_wayland *)impl; - struct wsi_wl_swap_chain *chain; + struct wsi_wl_swapchain *chain; VkResult result; - assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_SWAP_CHAIN_CREATE_INFO_WSI); + assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR); assert(pCreateInfo->pSurfaceDescription->sType == - VK_STRUCTURE_TYPE_SURFACE_DESCRIPTION_WINDOW_WSI); - VkSurfaceDescriptionWindowWSI *vk_window = - (VkSurfaceDescriptionWindowWSI *)pCreateInfo->pSurfaceDescription; - assert(vk_window->platform == VK_PLATFORM_WAYLAND_WSI); + VK_STRUCTURE_TYPE_SURFACE_DESCRIPTION_WINDOW_KHR); + VkSurfaceDescriptionWindowKHR *vk_window = + (VkSurfaceDescriptionWindowKHR *)pCreateInfo->pSurfaceDescription; + assert(vk_window->platform == VK_PLATFORM_WAYLAND_KHR); int num_images = pCreateInfo->minImageCount; @@ -693,7 +679,7 @@ wsi_wl_create_swap_chain(struct anv_wsi_implementation *impl, * 3) One to be currently held by the Wayland compositor * 4) One to render to */ - if (pCreateInfo->presentMode == VK_PRESENT_MODE_MAILBOX_WSI) + if (pCreateInfo->presentMode == VK_PRESENT_MODE_MAILBOX_KHR) num_images = MAX2(num_images, 4); size_t size = sizeof(*chain) + num_images * sizeof(chain->images[0]); @@ -703,8 +689,8 @@ wsi_wl_create_swap_chain(struct anv_wsi_implementation *impl, return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); chain->base.device = device; - chain->base.destroy = wsi_wl_destroy_swap_chain; - chain->base.get_swap_chain_info = wsi_wl_get_swap_chain_info; + chain->base.destroy = wsi_wl_destroy_swapchain; + chain->base.get_images = wsi_wl_get_images; chain->base.acquire_next_image = wsi_wl_acquire_next_image; chain->base.queue_present = wsi_wl_queue_present; @@ -740,12 +726,12 @@ wsi_wl_create_swap_chain(struct anv_wsi_implementation *impl, chain->images[i].busy = false; } - *swap_chain_out = &chain->base; + *swapchain_out = &chain->base; return VK_SUCCESS; fail: - wsi_wl_destroy_swap_chain(&chain->base); + wsi_wl_destroy_swapchain(&chain->base); return result; } @@ -762,8 +748,10 @@ anv_wl_init_wsi(struct anv_instance *instance) return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); wsi->base.get_window_supported = wsi_wl_get_window_supported; - wsi->base.get_surface_info = wsi_wl_get_surface_info; - wsi->base.create_swap_chain = wsi_wl_create_swap_chain; + wsi->base.get_surface_properties = wsi_wl_get_surface_properties; + wsi->base.get_surface_formats = wsi_wl_get_surface_formats; + wsi->base.get_surface_present_modes = wsi_wl_get_surface_present_modes; + wsi->base.create_swapchain = wsi_wl_create_swapchain; wsi->instance = instance; @@ -786,7 +774,7 @@ anv_wl_init_wsi(struct anv_instance *instance) goto fail_mutex; } - instance->wsi_impl[VK_PLATFORM_WAYLAND_WSI] = &wsi->base; + instance->wsi_impl[VK_PLATFORM_WAYLAND_KHR] = &wsi->base; return VK_SUCCESS; @@ -803,7 +791,7 @@ void anv_wl_finish_wsi(struct anv_instance *instance) { struct wsi_wayland *wsi = - (struct wsi_wayland *)instance->wsi_impl[VK_PLATFORM_WAYLAND_WSI]; + (struct wsi_wayland *)instance->wsi_impl[VK_PLATFORM_WAYLAND_KHR]; _mesa_hash_table_destroy(wsi->displays, NULL); diff --git a/src/vulkan/anv_wsi_x11.c b/src/vulkan/anv_wsi_x11.c index d226caf0eea..54e40918489 100644 --- a/src/vulkan/anv_wsi_x11.c +++ b/src/vulkan/anv_wsi_x11.c @@ -27,20 +27,20 @@ #include "anv_wsi.h" -static const VkFormat formats[] = { - VK_FORMAT_B5G6R5_UNORM, - VK_FORMAT_B8G8R8A8_UNORM, - VK_FORMAT_B8G8R8A8_SRGB, +static const VkSurfaceFormatKHR formats[] = { + { .format = VK_FORMAT_B5G6R5_UNORM, }, + { .format = VK_FORMAT_B8G8R8A8_UNORM, }, + { .format = VK_FORMAT_B8G8R8A8_SRGB, }, }; -static const VkSurfacePresentModePropertiesWSI present_modes[] = { - { VK_PRESENT_MODE_MAILBOX_WSI }, +static const VkPresentModeKHR present_modes[] = { + VK_PRESENT_MODE_MAILBOX_KHR, }; static VkResult x11_get_window_supported(struct anv_wsi_implementation *impl, struct anv_physical_device *physical_device, - const VkSurfaceDescriptionWindowWSI *window, + const VkSurfaceDescriptionWindowKHR *window, VkBool32 *pSupported) { *pSupported = true; @@ -48,80 +48,76 @@ x11_get_window_supported(struct anv_wsi_implementation *impl, } static VkResult -x11_get_surface_info(struct anv_wsi_implementation *impl, - struct anv_device *device, - VkSurfaceDescriptionWindowWSI *vk_window, - VkSurfaceInfoTypeWSI infoType, - size_t* pDataSize, void* pData) +x11_get_surface_properties(struct anv_wsi_implementation *impl, + struct anv_device *device, + const VkSurfaceDescriptionWindowKHR *vk_window, + VkSurfacePropertiesKHR *props) { - assert(pDataSize != NULL); - - switch (infoType) { - default: - unreachable("bad VkSurfaceInfoTypeWSI"); - case VK_SURFACE_INFO_TYPE_PROPERTIES_WSI: { - VkSurfacePropertiesWSI *props = pData; - - if (pData == NULL) { - *pDataSize = sizeof(*props); - return VK_SUCCESS; - } - - assert(*pDataSize >= sizeof(*props)); - - VkPlatformHandleXcbWSI *vk_xcb_handle = vk_window->pPlatformHandle; - xcb_connection_t *conn = vk_xcb_handle->connection; - xcb_window_t win = (xcb_window_t)(uintptr_t)vk_window->pPlatformWindow; - - xcb_get_geometry_cookie_t cookie = xcb_get_geometry(conn, win); - xcb_generic_error_t *err; - xcb_get_geometry_reply_t *geom = xcb_get_geometry_reply(conn, cookie, - &err); - if (!geom) { - /* FINISHME: Choose a more accurate error. */ - free(err); - return VK_ERROR_OUT_OF_DATE_WSI; - } + VkPlatformHandleXcbKHR *vk_xcb_handle = vk_window->pPlatformHandle; + xcb_connection_t *conn = vk_xcb_handle->connection; + xcb_window_t win = (xcb_window_t)(uintptr_t)vk_window->pPlatformWindow; + + xcb_get_geometry_cookie_t cookie = xcb_get_geometry(conn, win); + xcb_generic_error_t *err; + xcb_get_geometry_reply_t *geom = xcb_get_geometry_reply(conn, cookie, + &err); + if (!geom) { + free(err); + return vk_error(VK_ERROR_OUT_OF_DATE_KHR); + } - VkExtent2D extent = { geom->width, geom->height }; - free(geom); + VkExtent2D extent = { geom->width, geom->height }; + free(geom); + + props->minImageCount = 2; + props->maxImageCount = 4; + props->currentExtent = extent; + props->minImageExtent = extent; + props->maxImageExtent = extent; + props->supportedTransforms = VK_SURFACE_TRANSFORM_NONE_BIT_KHR; + props->currentTransform = VK_SURFACE_TRANSFORM_NONE_KHR; + props->maxImageArraySize = 1; + props->supportedUsageFlags = + VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT | + VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; - props->minImageCount = 2; - props->maxImageCount = 4; - props->currentExtent = extent; - props->minImageExtent = extent; - props->maxImageExtent = extent; - props->supportedTransforms = VK_SURFACE_TRANSFORM_NONE_BIT_WSI; - props->currentTransform = VK_SURFACE_TRANSFORM_NONE_WSI; - props->maxImageArraySize = 1; - props->supportedUsageFlags = - VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT | - VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; + return VK_SUCCESS; +} +static VkResult +x11_get_surface_formats(struct anv_wsi_implementation *impl, + struct anv_device *device, + const VkSurfaceDescriptionWindowKHR *vk_window, + uint32_t *pCount, VkSurfaceFormatKHR *pSurfaceFormats) +{ + if (pSurfaceFormats == NULL) { + *pCount = ARRAY_SIZE(formats); return VK_SUCCESS; } - case VK_SURFACE_INFO_TYPE_FORMATS_WSI: - if (pData == NULL) { - *pDataSize = sizeof(formats); - return VK_SUCCESS; - } + assert(*pCount >= ARRAY_SIZE(formats)); + typed_memcpy(pSurfaceFormats, formats, *pCount); + *pCount = ARRAY_SIZE(formats); - assert(*pDataSize >= sizeof(formats)); - memcpy(pData, formats, *pDataSize); + return VK_SUCCESS; +} +static VkResult +x11_get_surface_present_modes(struct anv_wsi_implementation *impl, + struct anv_device *device, + const VkSurfaceDescriptionWindowKHR *vk_window, + uint32_t *pCount, VkPresentModeKHR *pPresentModes) +{ + if (pPresentModes == NULL) { + *pCount = ARRAY_SIZE(present_modes); return VK_SUCCESS; + } - case VK_SURFACE_INFO_TYPE_PRESENT_MODES_WSI: - if (pData == NULL) { - *pDataSize = sizeof(present_modes); - return VK_SUCCESS; - } + assert(*pCount >= ARRAY_SIZE(present_modes)); + typed_memcpy(pPresentModes, present_modes, *pCount); + *pCount = ARRAY_SIZE(present_modes); - assert(*pDataSize >= sizeof(present_modes)); - memcpy(pData, present_modes, *pDataSize); - return VK_SUCCESS; - } + return VK_SUCCESS; } struct x11_image { @@ -132,8 +128,8 @@ struct x11_image { bool busy; }; -struct x11_swap_chain { - struct anv_swap_chain base; +struct x11_swapchain { + struct anv_swapchain base; xcb_connection_t * conn; xcb_window_t window; @@ -145,43 +141,32 @@ struct x11_swap_chain { }; static VkResult -x11_get_swap_chain_info(struct anv_swap_chain *anv_chain, - VkSwapChainInfoTypeWSI infoType, - size_t* pDataSize, void* pData) +x11_get_images(struct anv_swapchain *anv_chain, + uint32_t* pCount, VkImage *pSwapchainImages) { - struct x11_swap_chain *chain = (struct x11_swap_chain *)anv_chain; - size_t size; + struct x11_swapchain *chain = (struct x11_swapchain *)anv_chain; - switch (infoType) { - default: - unreachable("bad VkSwapChainInfoType"); - case VK_SWAP_CHAIN_INFO_TYPE_IMAGES_WSI: { - VkSwapChainImagePropertiesWSI *images = pData; - - size = chain->image_count * sizeof(*images); + if (pSwapchainImages == NULL) { + *pCount = chain->image_count; + return VK_SUCCESS; + } - if (pData == NULL) { - *pDataSize = size; - return VK_SUCCESS; - } + assert(chain->image_count <= *pCount); + for (uint32_t i = 0; i < chain->image_count; i++) + pSwapchainImages[i] = anv_image_to_handle(chain->images[i].image); - assert(size <= *pDataSize); - for (uint32_t i = 0; i < chain->image_count; i++) - images[i].image = anv_image_to_handle(chain->images[i].image); + *pCount = chain->image_count; - *pDataSize = size; - return VK_SUCCESS; - } - } + return VK_SUCCESS; } static VkResult -x11_acquire_next_image(struct anv_swap_chain *anv_chain, +x11_acquire_next_image(struct anv_swapchain *anv_chain, uint64_t timeout, VkSemaphore semaphore, uint32_t *image_index) { - struct x11_swap_chain *chain = (struct x11_swap_chain *)anv_chain; + struct x11_swapchain *chain = (struct x11_swapchain *)anv_chain; struct x11_image *image = &chain->images[chain->next_image]; if (image->busy) { @@ -189,15 +174,14 @@ x11_acquire_next_image(struct anv_swap_chain *anv_chain, xcb_get_geometry_reply_t *geom = xcb_get_geometry_reply(chain->conn, image->geom_cookie, &err); if (!geom) { - /* Probably the best thing to do if our drawable goes away */ free(err); - return vk_error(VK_ERROR_OUT_OF_DATE_WSI); + return vk_error(VK_ERROR_OUT_OF_DATE_KHR); } if (geom->width != chain->extent.width || geom->height != chain->extent.height) { free(geom); - return vk_error(VK_ERROR_OUT_OF_DATE_WSI); + return vk_error(VK_ERROR_OUT_OF_DATE_KHR); } free(geom); @@ -210,11 +194,11 @@ x11_acquire_next_image(struct anv_swap_chain *anv_chain, } static VkResult -x11_queue_present(struct anv_swap_chain *anv_chain, +x11_queue_present(struct anv_swapchain *anv_chain, struct anv_queue *queue, uint32_t image_index) { - struct x11_swap_chain *chain = (struct x11_swap_chain *)anv_chain; + struct x11_swapchain *chain = (struct x11_swapchain *)anv_chain; struct x11_image *image = &chain->images[image_index]; assert(image_index < chain->image_count); @@ -240,9 +224,9 @@ x11_queue_present(struct anv_swap_chain *anv_chain, } static VkResult -x11_destroy_swap_chain(struct anv_swap_chain *anv_chain) +x11_destroy_swapchain(struct anv_swapchain *anv_chain) { - struct x11_swap_chain *chain = (struct x11_swap_chain *)anv_chain; + struct x11_swapchain *chain = (struct x11_swapchain *)anv_chain; xcb_void_cookie_t cookie; for (uint32_t i = 0; i < chain->image_count; i++) { @@ -263,24 +247,24 @@ x11_destroy_swap_chain(struct anv_swap_chain *anv_chain) } static VkResult -x11_create_swap_chain(struct anv_wsi_implementation *impl, +x11_create_swapchain(struct anv_wsi_implementation *impl, struct anv_device *device, - const VkSwapChainCreateInfoWSI *pCreateInfo, - struct anv_swap_chain **swap_chain_out) + const VkSwapchainCreateInfoKHR *pCreateInfo, + struct anv_swapchain **swapchain_out) { - struct x11_swap_chain *chain; + struct x11_swapchain *chain; xcb_void_cookie_t cookie; VkResult result; assert(pCreateInfo->pSurfaceDescription->sType == - VK_STRUCTURE_TYPE_SURFACE_DESCRIPTION_WINDOW_WSI); - VkSurfaceDescriptionWindowWSI *vk_window = - (VkSurfaceDescriptionWindowWSI *)pCreateInfo->pSurfaceDescription; - assert(vk_window->platform == VK_PLATFORM_XCB_WSI); + VK_STRUCTURE_TYPE_SURFACE_DESCRIPTION_WINDOW_KHR); + VkSurfaceDescriptionWindowKHR *vk_window = + (VkSurfaceDescriptionWindowKHR *)pCreateInfo->pSurfaceDescription; + assert(vk_window->platform == VK_PLATFORM_XCB_KHR); int num_images = pCreateInfo->minImageCount; - assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_SWAP_CHAIN_CREATE_INFO_WSI); + assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR); size_t size = sizeof(*chain) + num_images * sizeof(chain->images[0]); chain = anv_device_alloc(device, size, 8, @@ -289,12 +273,12 @@ x11_create_swap_chain(struct anv_wsi_implementation *impl, return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); chain->base.device = device; - chain->base.destroy = x11_destroy_swap_chain; - chain->base.get_swap_chain_info = x11_get_swap_chain_info; + chain->base.destroy = x11_destroy_swapchain; + chain->base.get_images = x11_get_images; chain->base.acquire_next_image = x11_acquire_next_image; chain->base.queue_present = x11_queue_present; - VkPlatformHandleXcbWSI *vk_xcb_handle = vk_window->pPlatformHandle; + VkPlatformHandleXcbKHR *vk_xcb_handle = vk_window->pPlatformHandle; chain->conn = (xcb_connection_t *) vk_xcb_handle->connection; chain->window = (xcb_window_t) (uintptr_t)vk_window->pPlatformWindow; @@ -405,7 +389,7 @@ x11_create_swap_chain(struct anv_wsi_implementation *impl, (uint32_t []) { 0 }); xcb_discard_reply(chain->conn, cookie.sequence); - *swap_chain_out = &chain->base; + *swapchain_out = &chain->base; return VK_SUCCESS; @@ -424,10 +408,12 @@ anv_x11_init_wsi(struct anv_instance *instance) return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); impl->get_window_supported = x11_get_window_supported; - impl->get_surface_info = x11_get_surface_info; - impl->create_swap_chain = x11_create_swap_chain; + impl->get_surface_properties = x11_get_surface_properties; + impl->get_surface_formats = x11_get_surface_formats; + impl->get_surface_present_modes = x11_get_surface_present_modes; + impl->create_swapchain = x11_create_swapchain; - instance->wsi_impl[VK_PLATFORM_XCB_WSI] = impl; + instance->wsi_impl[VK_PLATFORM_XCB_KHR] = impl; return VK_SUCCESS; } @@ -435,5 +421,5 @@ anv_x11_init_wsi(struct anv_instance *instance) void anv_x11_finish_wsi(struct anv_instance *instance) { - anv_instance_free(instance, instance->wsi_impl[VK_PLATFORM_XCB_WSI]); + anv_instance_free(instance, instance->wsi_impl[VK_PLATFORM_XCB_KHR]); }