2015-09-02 01:00:10 +01:00
|
|
|
/*
|
|
|
|
* Copyright © 2015 Intel Corporation
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
|
|
* to deal in the Software without restriction, including without limitation
|
|
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice (including the next
|
|
|
|
* paragraph) shall be included in all copies or substantial portions of the
|
|
|
|
* Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS 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 SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
|
|
* IN THE SOFTWARE.
|
|
|
|
*/
|
|
|
|
|
2015-09-02 02:59:06 +01:00
|
|
|
#include "anv_wsi.h"
|
2016-10-14 01:34:10 +01:00
|
|
|
#include "vk_format_info.h"
|
2015-09-04 19:14:45 +01:00
|
|
|
VkResult
|
2016-05-16 06:21:24 +01:00
|
|
|
anv_init_wsi(struct anv_physical_device *physical_device)
|
2015-09-04 19:14:45 +01:00
|
|
|
{
|
2015-09-05 01:50:32 +01:00
|
|
|
VkResult result;
|
|
|
|
|
2016-10-13 05:14:52 +01:00
|
|
|
memset(physical_device->wsi_device.wsi, 0, sizeof(physical_device->wsi_device.wsi));
|
2016-05-16 06:21:24 +01:00
|
|
|
|
2016-04-20 19:15:18 +01:00
|
|
|
#ifdef VK_USE_PLATFORM_XCB_KHR
|
2016-10-13 05:18:34 +01:00
|
|
|
result = anv_x11_init_wsi(&physical_device->wsi_device, &physical_device->instance->alloc);
|
2015-09-05 01:50:32 +01:00
|
|
|
if (result != VK_SUCCESS)
|
|
|
|
return result;
|
2016-04-20 19:15:18 +01:00
|
|
|
#endif
|
2015-09-05 01:50:32 +01:00
|
|
|
|
2016-04-20 19:01:00 +01:00
|
|
|
#ifdef VK_USE_PLATFORM_WAYLAND_KHR
|
2016-10-14 03:09:02 +01:00
|
|
|
result = anv_wl_init_wsi(&physical_device->wsi_device, &physical_device->instance->alloc,
|
|
|
|
anv_physical_device_to_handle(physical_device));
|
2015-09-05 01:50:32 +01:00
|
|
|
if (result != VK_SUCCESS) {
|
2016-05-28 19:49:37 +01:00
|
|
|
#ifdef VK_USE_PLATFORM_XCB_KHR
|
2016-10-13 05:18:34 +01:00
|
|
|
anv_x11_finish_wsi(&physical_device->wsi_device, &physical_device->instance->alloc);
|
2016-05-28 19:49:37 +01:00
|
|
|
#endif
|
2015-09-05 01:50:32 +01:00
|
|
|
return result;
|
|
|
|
}
|
2015-09-05 03:18:50 +01:00
|
|
|
#endif
|
2015-09-05 01:50:32 +01:00
|
|
|
|
|
|
|
return VK_SUCCESS;
|
2015-09-04 19:14:45 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2016-05-16 06:21:24 +01:00
|
|
|
anv_finish_wsi(struct anv_physical_device *physical_device)
|
2015-09-04 19:14:45 +01:00
|
|
|
{
|
2016-04-20 19:01:00 +01:00
|
|
|
#ifdef VK_USE_PLATFORM_WAYLAND_KHR
|
2016-10-14 03:09:02 +01:00
|
|
|
anv_wl_finish_wsi(&physical_device->wsi_device, &physical_device->instance->alloc);
|
2015-09-05 03:18:50 +01:00
|
|
|
#endif
|
2016-04-20 19:15:18 +01:00
|
|
|
#ifdef VK_USE_PLATFORM_XCB_KHR
|
2016-10-13 05:18:34 +01:00
|
|
|
anv_x11_finish_wsi(&physical_device->wsi_device, &physical_device->instance->alloc);
|
2016-04-20 19:15:18 +01:00
|
|
|
#endif
|
2015-09-04 19:14:45 +01:00
|
|
|
}
|
|
|
|
|
2015-12-03 00:28:36 +00:00
|
|
|
void anv_DestroySurfaceKHR(
|
2016-01-28 23:34:22 +00:00
|
|
|
VkInstance _instance,
|
2015-12-03 00:28:36 +00:00
|
|
|
VkSurfaceKHR _surface,
|
|
|
|
const VkAllocationCallbacks* pAllocator)
|
2015-09-02 01:00:10 +01:00
|
|
|
{
|
2016-01-28 23:34:22 +00:00
|
|
|
ANV_FROM_HANDLE(anv_instance, instance, _instance);
|
|
|
|
ANV_FROM_HANDLE(_VkIcdSurfaceBase, surface, _surface);
|
2015-09-02 01:00:10 +01:00
|
|
|
|
2016-10-14 04:31:35 +01:00
|
|
|
vk_free2(&instance->alloc, pAllocator, surface);
|
2015-09-02 01:00:10 +01:00
|
|
|
}
|
2015-09-02 02:59:06 +01:00
|
|
|
|
2015-12-03 00:28:36 +00:00
|
|
|
VkResult anv_GetPhysicalDeviceSurfaceSupportKHR(
|
|
|
|
VkPhysicalDevice physicalDevice,
|
|
|
|
uint32_t queueFamilyIndex,
|
|
|
|
VkSurfaceKHR _surface,
|
|
|
|
VkBool32* pSupported)
|
2015-09-02 02:59:06 +01:00
|
|
|
{
|
2015-12-03 00:28:36 +00:00
|
|
|
ANV_FROM_HANDLE(anv_physical_device, device, physicalDevice);
|
2016-01-28 23:34:22 +00:00
|
|
|
ANV_FROM_HANDLE(_VkIcdSurfaceBase, surface, _surface);
|
2016-10-13 05:14:52 +01:00
|
|
|
struct anv_wsi_interface *iface = device->wsi_device.wsi[surface->platform];
|
2015-09-04 19:14:45 +01:00
|
|
|
|
2016-10-13 05:26:03 +01:00
|
|
|
return iface->get_support(surface, &device->wsi_device,
|
|
|
|
&device->instance->alloc,
|
|
|
|
queueFamilyIndex, pSupported);
|
2015-09-02 02:59:06 +01:00
|
|
|
}
|
|
|
|
|
2015-12-03 00:28:36 +00:00
|
|
|
VkResult anv_GetPhysicalDeviceSurfaceCapabilitiesKHR(
|
|
|
|
VkPhysicalDevice physicalDevice,
|
|
|
|
VkSurfaceKHR _surface,
|
|
|
|
VkSurfaceCapabilitiesKHR* pSurfaceCapabilities)
|
2015-09-02 02:59:06 +01:00
|
|
|
{
|
2015-12-03 00:28:36 +00:00
|
|
|
ANV_FROM_HANDLE(anv_physical_device, device, physicalDevice);
|
2016-01-28 23:34:22 +00:00
|
|
|
ANV_FROM_HANDLE(_VkIcdSurfaceBase, surface, _surface);
|
2016-10-13 05:14:52 +01:00
|
|
|
struct anv_wsi_interface *iface = device->wsi_device.wsi[surface->platform];
|
2015-10-07 22:13:55 +01:00
|
|
|
|
2016-10-13 05:27:56 +01:00
|
|
|
return iface->get_capabilities(surface, pSurfaceCapabilities);
|
2015-10-07 22:13:55 +01:00
|
|
|
}
|
|
|
|
|
2015-12-03 00:28:36 +00:00
|
|
|
VkResult anv_GetPhysicalDeviceSurfaceFormatsKHR(
|
|
|
|
VkPhysicalDevice physicalDevice,
|
|
|
|
VkSurfaceKHR _surface,
|
|
|
|
uint32_t* pSurfaceFormatCount,
|
|
|
|
VkSurfaceFormatKHR* pSurfaceFormats)
|
2015-10-13 19:45:58 +01:00
|
|
|
{
|
2015-12-03 00:28:36 +00:00
|
|
|
ANV_FROM_HANDLE(anv_physical_device, device, physicalDevice);
|
2016-01-28 23:34:22 +00:00
|
|
|
ANV_FROM_HANDLE(_VkIcdSurfaceBase, surface, _surface);
|
2016-10-13 05:14:52 +01:00
|
|
|
struct anv_wsi_interface *iface = device->wsi_device.wsi[surface->platform];
|
2015-10-13 19:45:58 +01:00
|
|
|
|
2016-10-13 05:32:41 +01:00
|
|
|
return iface->get_formats(surface, &device->wsi_device, pSurfaceFormatCount,
|
2016-01-28 23:34:22 +00:00
|
|
|
pSurfaceFormats);
|
2015-12-03 00:28:36 +00:00
|
|
|
}
|
2015-10-13 19:45:58 +01:00
|
|
|
|
2015-12-03 00:28:36 +00:00
|
|
|
VkResult anv_GetPhysicalDeviceSurfacePresentModesKHR(
|
|
|
|
VkPhysicalDevice physicalDevice,
|
|
|
|
VkSurfaceKHR _surface,
|
|
|
|
uint32_t* pPresentModeCount,
|
|
|
|
VkPresentModeKHR* pPresentModes)
|
|
|
|
{
|
|
|
|
ANV_FROM_HANDLE(anv_physical_device, device, physicalDevice);
|
2016-01-28 23:34:22 +00:00
|
|
|
ANV_FROM_HANDLE(_VkIcdSurfaceBase, surface, _surface);
|
2016-10-13 05:14:52 +01:00
|
|
|
struct anv_wsi_interface *iface = device->wsi_device.wsi[surface->platform];
|
2015-10-13 19:45:58 +01:00
|
|
|
|
2016-10-13 05:33:28 +01:00
|
|
|
return iface->get_present_modes(surface, pPresentModeCount,
|
2016-01-28 23:34:22 +00:00
|
|
|
pPresentModes);
|
2015-10-13 19:45:58 +01:00
|
|
|
}
|
|
|
|
|
2016-10-14 01:34:10 +01:00
|
|
|
|
|
|
|
static VkResult
|
|
|
|
x11_anv_wsi_image_create(VkDevice device_h,
|
|
|
|
const VkSwapchainCreateInfoKHR *pCreateInfo,
|
|
|
|
const VkAllocationCallbacks* pAllocator,
|
|
|
|
VkImage *image_p,
|
|
|
|
VkDeviceMemory *memory_p,
|
|
|
|
uint32_t *size,
|
|
|
|
uint32_t *offset,
|
|
|
|
uint32_t *row_pitch, int *fd_p)
|
|
|
|
{
|
|
|
|
struct anv_device *device = anv_device_from_handle(device_h);
|
|
|
|
VkImage image_h;
|
|
|
|
struct anv_image *image;
|
|
|
|
|
|
|
|
VkResult result;
|
|
|
|
result = anv_image_create(anv_device_to_handle(device),
|
|
|
|
&(struct anv_image_create_info) {
|
|
|
|
.isl_tiling_flags = ISL_TILING_X_BIT,
|
|
|
|
.stride = 0,
|
|
|
|
.vk_info =
|
|
|
|
&(VkImageCreateInfo) {
|
|
|
|
.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
|
|
|
|
.imageType = VK_IMAGE_TYPE_2D,
|
|
|
|
.format = pCreateInfo->imageFormat,
|
|
|
|
.extent = {
|
|
|
|
.width = pCreateInfo->imageExtent.width,
|
|
|
|
.height = pCreateInfo->imageExtent.height,
|
|
|
|
.depth = 1
|
|
|
|
},
|
|
|
|
.mipLevels = 1,
|
|
|
|
.arrayLayers = 1,
|
|
|
|
.samples = 1,
|
|
|
|
/* FIXME: Need a way to use X tiling to allow scanout */
|
|
|
|
.tiling = VK_IMAGE_TILING_OPTIMAL,
|
|
|
|
.usage = (pCreateInfo->imageUsage |
|
|
|
|
VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT),
|
|
|
|
.flags = 0,
|
|
|
|
}},
|
|
|
|
NULL,
|
|
|
|
&image_h);
|
|
|
|
if (result != VK_SUCCESS)
|
|
|
|
return result;
|
|
|
|
|
|
|
|
image = anv_image_from_handle(image_h);
|
|
|
|
assert(vk_format_is_color(image->vk_format));
|
|
|
|
|
|
|
|
VkDeviceMemory memory_h;
|
|
|
|
struct anv_device_memory *memory;
|
|
|
|
result = anv_AllocateMemory(anv_device_to_handle(device),
|
|
|
|
&(VkMemoryAllocateInfo) {
|
|
|
|
.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
|
|
|
|
.allocationSize = image->size,
|
|
|
|
.memoryTypeIndex = 0,
|
|
|
|
},
|
|
|
|
NULL /* XXX: pAllocator */,
|
|
|
|
&memory_h);
|
|
|
|
if (result != VK_SUCCESS)
|
|
|
|
goto fail_create_image;
|
|
|
|
|
|
|
|
memory = anv_device_memory_from_handle(memory_h);
|
|
|
|
memory->bo.is_winsys_bo = true;
|
|
|
|
|
|
|
|
anv_BindImageMemory(VK_NULL_HANDLE, image_h, memory_h, 0);
|
|
|
|
|
|
|
|
struct anv_surface *surface = &image->color_surface;
|
|
|
|
assert(surface->isl.tiling == ISL_TILING_X);
|
|
|
|
|
|
|
|
*row_pitch = surface->isl.row_pitch;
|
|
|
|
int ret = anv_gem_set_tiling(device, memory->bo.gem_handle,
|
|
|
|
surface->isl.row_pitch, I915_TILING_X);
|
|
|
|
if (ret) {
|
|
|
|
/* FINISHME: Choose a better error. */
|
|
|
|
result = vk_errorf(VK_ERROR_OUT_OF_DEVICE_MEMORY,
|
|
|
|
"set_tiling failed: %m");
|
|
|
|
goto fail_alloc_memory;
|
|
|
|
}
|
|
|
|
|
|
|
|
int fd = anv_gem_handle_to_fd(device, memory->bo.gem_handle);
|
|
|
|
if (fd == -1) {
|
|
|
|
/* FINISHME: Choose a better error. */
|
|
|
|
result = vk_errorf(VK_ERROR_OUT_OF_DEVICE_MEMORY,
|
|
|
|
"handle_to_fd failed: %m");
|
|
|
|
goto fail_alloc_memory;
|
|
|
|
}
|
|
|
|
|
|
|
|
*image_p = image_h;
|
|
|
|
*memory_p = memory_h;
|
|
|
|
*fd_p = fd;
|
|
|
|
*size = image->size;
|
|
|
|
*offset = image->offset;
|
|
|
|
return VK_SUCCESS;
|
|
|
|
fail_alloc_memory:
|
|
|
|
anv_FreeMemory(device_h, memory_h, pAllocator);
|
|
|
|
|
|
|
|
fail_create_image:
|
|
|
|
anv_DestroyImage(device_h, image_h, pAllocator);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
x11_anv_wsi_image_free(VkDevice device,
|
|
|
|
const VkAllocationCallbacks* pAllocator,
|
|
|
|
VkImage image_h,
|
|
|
|
VkDeviceMemory memory_h)
|
|
|
|
{
|
|
|
|
anv_DestroyImage(device, image_h, pAllocator);
|
|
|
|
|
|
|
|
anv_FreeMemory(device, memory_h, pAllocator);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct anv_wsi_image_fns anv_wsi_image_fns = {
|
|
|
|
.create_wsi_image = x11_anv_wsi_image_create,
|
|
|
|
.free_wsi_image = x11_anv_wsi_image_free,
|
|
|
|
};
|
|
|
|
|
2015-12-03 00:28:36 +00:00
|
|
|
VkResult anv_CreateSwapchainKHR(
|
|
|
|
VkDevice _device,
|
|
|
|
const VkSwapchainCreateInfoKHR* pCreateInfo,
|
|
|
|
const VkAllocationCallbacks* pAllocator,
|
|
|
|
VkSwapchainKHR* pSwapchain)
|
2015-10-07 22:13:55 +01:00
|
|
|
{
|
|
|
|
ANV_FROM_HANDLE(anv_device, device, _device);
|
2016-01-28 23:34:22 +00:00
|
|
|
ANV_FROM_HANDLE(_VkIcdSurfaceBase, surface, pCreateInfo->surface);
|
2016-05-16 06:21:24 +01:00
|
|
|
struct anv_wsi_interface *iface =
|
2016-10-13 05:14:52 +01:00
|
|
|
device->instance->physicalDevice.wsi_device.wsi[surface->platform];
|
2015-10-07 22:13:55 +01:00
|
|
|
struct anv_swapchain *swapchain;
|
2016-10-14 02:38:49 +01:00
|
|
|
const VkAllocationCallbacks *alloc;
|
2015-09-02 02:59:06 +01:00
|
|
|
|
2016-10-14 02:38:49 +01:00
|
|
|
if (pAllocator)
|
|
|
|
alloc = pAllocator;
|
|
|
|
else
|
|
|
|
alloc = &device->alloc;
|
|
|
|
VkResult result = iface->create_swapchain(surface, _device,
|
|
|
|
&device->instance->physicalDevice.wsi_device,
|
|
|
|
pCreateInfo,
|
|
|
|
alloc, &anv_wsi_image_fns,
|
2016-10-14 01:34:10 +01:00
|
|
|
&swapchain);
|
2015-12-03 00:28:36 +00:00
|
|
|
if (result != VK_SUCCESS)
|
|
|
|
return result;
|
2015-09-02 02:59:06 +01:00
|
|
|
|
2016-10-14 02:38:49 +01:00
|
|
|
swapchain->alloc = *alloc;
|
2016-03-11 02:35:00 +00:00
|
|
|
|
|
|
|
for (unsigned i = 0; i < ARRAY_SIZE(swapchain->fences); i++)
|
|
|
|
swapchain->fences[i] = VK_NULL_HANDLE;
|
|
|
|
|
2015-12-03 00:28:36 +00:00
|
|
|
*pSwapchain = anv_swapchain_to_handle(swapchain);
|
2015-09-02 02:59:06 +01:00
|
|
|
|
2015-12-03 00:28:36 +00:00
|
|
|
return VK_SUCCESS;
|
2015-09-02 02:59:06 +01:00
|
|
|
}
|
|
|
|
|
2015-12-03 00:28:36 +00:00
|
|
|
void anv_DestroySwapchainKHR(
|
2016-10-14 02:38:49 +01:00
|
|
|
VkDevice _device,
|
2015-12-03 00:28:36 +00:00
|
|
|
VkSwapchainKHR _swapchain,
|
|
|
|
const VkAllocationCallbacks* pAllocator)
|
2015-09-02 02:59:06 +01:00
|
|
|
{
|
2016-10-14 02:38:49 +01:00
|
|
|
ANV_FROM_HANDLE(anv_device, device, _device);
|
2015-12-03 00:28:36 +00:00
|
|
|
ANV_FROM_HANDLE(anv_swapchain, swapchain, _swapchain);
|
2016-10-14 02:38:49 +01:00
|
|
|
const VkAllocationCallbacks *alloc;
|
2015-09-02 02:59:06 +01:00
|
|
|
|
2016-10-14 02:38:49 +01:00
|
|
|
if (pAllocator)
|
|
|
|
alloc = pAllocator;
|
|
|
|
else
|
|
|
|
alloc = &device->alloc;
|
2016-03-11 02:35:00 +00:00
|
|
|
for (unsigned i = 0; i < ARRAY_SIZE(swapchain->fences); i++) {
|
|
|
|
if (swapchain->fences[i] != VK_NULL_HANDLE)
|
2016-10-14 02:38:49 +01:00
|
|
|
anv_DestroyFence(_device, swapchain->fences[i], pAllocator);
|
2016-03-11 02:35:00 +00:00
|
|
|
}
|
|
|
|
|
2016-10-14 02:38:49 +01:00
|
|
|
swapchain->destroy(swapchain, alloc);
|
2015-09-02 02:59:06 +01:00
|
|
|
}
|
|
|
|
|
2015-12-03 00:28:36 +00:00
|
|
|
VkResult anv_GetSwapchainImagesKHR(
|
|
|
|
VkDevice device,
|
|
|
|
VkSwapchainKHR _swapchain,
|
|
|
|
uint32_t* pSwapchainImageCount,
|
|
|
|
VkImage* pSwapchainImages)
|
2015-09-02 02:59:06 +01:00
|
|
|
{
|
2015-10-07 22:13:55 +01:00
|
|
|
ANV_FROM_HANDLE(anv_swapchain, swapchain, _swapchain);
|
2015-09-02 02:59:06 +01:00
|
|
|
|
2015-12-03 00:28:36 +00:00
|
|
|
return swapchain->get_images(swapchain, pSwapchainImageCount,
|
|
|
|
pSwapchainImages);
|
2015-09-02 02:59:06 +01:00
|
|
|
}
|
|
|
|
|
2015-12-03 00:28:36 +00:00
|
|
|
VkResult anv_AcquireNextImageKHR(
|
|
|
|
VkDevice device,
|
|
|
|
VkSwapchainKHR _swapchain,
|
|
|
|
uint64_t timeout,
|
|
|
|
VkSemaphore semaphore,
|
|
|
|
VkFence fence,
|
|
|
|
uint32_t* pImageIndex)
|
2015-09-02 02:59:06 +01:00
|
|
|
{
|
2015-10-07 22:13:55 +01:00
|
|
|
ANV_FROM_HANDLE(anv_swapchain, swapchain, _swapchain);
|
2015-09-02 02:59:06 +01:00
|
|
|
|
2015-12-03 00:28:36 +00:00
|
|
|
return swapchain->acquire_next_image(swapchain, timeout, semaphore,
|
|
|
|
pImageIndex);
|
2015-09-02 02:59:06 +01:00
|
|
|
}
|
|
|
|
|
2015-12-03 00:28:36 +00:00
|
|
|
VkResult anv_QueuePresentKHR(
|
2015-09-02 02:59:06 +01:00
|
|
|
VkQueue _queue,
|
2015-12-03 00:28:36 +00:00
|
|
|
const VkPresentInfoKHR* pPresentInfo)
|
2015-09-02 02:59:06 +01:00
|
|
|
{
|
|
|
|
ANV_FROM_HANDLE(anv_queue, queue, _queue);
|
|
|
|
VkResult result;
|
|
|
|
|
2015-10-07 22:13:55 +01:00
|
|
|
for (uint32_t i = 0; i < pPresentInfo->swapchainCount; i++) {
|
2015-12-03 00:28:36 +00:00
|
|
|
ANV_FROM_HANDLE(anv_swapchain, swapchain, pPresentInfo->pSwapchains[i]);
|
2015-09-02 02:59:06 +01:00
|
|
|
|
2016-10-14 00:42:56 +01:00
|
|
|
assert(anv_device_from_handle(swapchain->device) == queue->device);
|
2015-09-02 02:59:06 +01:00
|
|
|
|
2016-03-11 02:35:00 +00:00
|
|
|
if (swapchain->fences[0] == VK_NULL_HANDLE) {
|
|
|
|
result = anv_CreateFence(anv_device_to_handle(queue->device),
|
|
|
|
&(VkFenceCreateInfo) {
|
|
|
|
.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
|
|
|
|
.flags = 0,
|
|
|
|
}, &swapchain->alloc, &swapchain->fences[0]);
|
|
|
|
if (result != VK_SUCCESS)
|
|
|
|
return result;
|
|
|
|
} else {
|
|
|
|
anv_ResetFences(anv_device_to_handle(queue->device),
|
|
|
|
1, &swapchain->fences[0]);
|
|
|
|
}
|
|
|
|
|
|
|
|
anv_QueueSubmit(_queue, 0, NULL, swapchain->fences[0]);
|
|
|
|
|
2016-10-13 04:43:27 +01:00
|
|
|
result = swapchain->queue_present(swapchain,
|
2015-12-03 00:28:36 +00:00
|
|
|
pPresentInfo->pImageIndices[i]);
|
2015-09-04 18:28:26 +01:00
|
|
|
/* TODO: What if one of them returns OUT_OF_DATE? */
|
|
|
|
if (result != VK_SUCCESS)
|
|
|
|
return result;
|
2016-03-11 02:35:00 +00:00
|
|
|
|
|
|
|
VkFence last = swapchain->fences[2];
|
|
|
|
swapchain->fences[2] = swapchain->fences[1];
|
|
|
|
swapchain->fences[1] = swapchain->fences[0];
|
|
|
|
swapchain->fences[0] = last;
|
|
|
|
|
|
|
|
if (last != VK_NULL_HANDLE) {
|
|
|
|
anv_WaitForFences(anv_device_to_handle(queue->device),
|
|
|
|
1, &last, true, 1);
|
|
|
|
}
|
2015-09-02 02:59:06 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return VK_SUCCESS;
|
|
|
|
}
|