--- /dev/null
+//
+// 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__
--- /dev/null
+//
+// 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__
+++ /dev/null
-//
-// 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__
+++ /dev/null
-//
-// 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__
$(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
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,
},
};
#define VK_PROTOTYPES
#include <vulkan/vulkan.h>
#include <vulkan/vulkan_intel.h>
-#include <vulkan/vk_wsi_swapchain.h>
-#include <vulkan/vk_wsi_device_swapchain.h>
+#include <vulkan/vk_ext_khr_swapchain.h>
+#include <vulkan/vk_ext_khr_device_swapchain.h>
#include "anv_entrypoints.h"
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);
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");
}
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];
}
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;
#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);
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;
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 {
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;
VkFormat vk_format;
uint32_t drm_format;
- VkPresentModeWSI present_mode;
+ VkPresentModeKHR present_mode;
bool fifo_ready;
uint32_t image_count;
};
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);
* 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++) {
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;
};
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);
}
}
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);
}
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));
};
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;
}
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)
}
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;
* 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]);
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;
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;
}
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;
goto fail_mutex;
}
- instance->wsi_impl[VK_PLATFORM_WAYLAND_WSI] = &wsi->base;
+ instance->wsi_impl[VK_PLATFORM_WAYLAND_KHR] = &wsi->base;
return VK_SUCCESS;
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);
#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;
}
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 {
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;
};
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) {
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);
}
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);
}
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++) {
}
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,
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;
(uint32_t []) { 0 });
xcb_discard_reply(chain->conn, cookie.sequence);
- *swap_chain_out = &chain->base;
+ *swapchain_out = &chain->base;
return VK_SUCCESS;
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;
}
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]);
}
projects / mesa.git / commitdiff