wined3d: Implement swapchains for the Vulkan adapter.

dlls/wined3d/adapter_vk.c

@@ -421,6 +421,7 @@ vulkan_device_extensions[] =
     {VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME,    ~0u},
     {VK_KHR_MAINTENANCE1_EXTENSION_NAME,                VK_API_VERSION_1_1},
     {VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME,      VK_API_VERSION_1_1},
+    {VK_KHR_SWAPCHAIN_EXTENSION_NAME,                   ~0u},
 };
 
 static bool enable_vulkan_device_extensions(VkPhysicalDevice physical_device, uint32_t *extension_count,
@@ -1180,7 +1181,7 @@ static void adapter_vk_copy_bo_address(struct wined3d_context *context,
 static HRESULT adapter_vk_create_swapchain(struct wined3d_device *device, struct wined3d_swapchain_desc *desc,
         void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_swapchain **swapchain)
 {
-    struct wined3d_swapchain *swapchain_vk;
+    struct wined3d_swapchain_vk *swapchain_vk;
     HRESULT hr;
 
     TRACE("device %p, desc %p, parent %p, parent_ops %p, swapchain %p.\n",
@@ -1197,15 +1198,17 @@ static HRESULT adapter_vk_create_swapchain(struct wined3d_device *device, struct
     }
 
     TRACE("Created swapchain %p.\n", swapchain_vk);
-    *swapchain = swapchain_vk;
+    *swapchain = &swapchain_vk->s;
 
     return hr;
 }
 
 static void adapter_vk_destroy_swapchain(struct wined3d_swapchain *swapchain)
 {
-    wined3d_swapchain_cleanup(swapchain);
-    heap_free(swapchain);
+    struct wined3d_swapchain_vk *swapchain_vk = wined3d_swapchain_vk(swapchain);
+
+    wined3d_swapchain_vk_cleanup(swapchain_vk);
+    heap_free(swapchain_vk);
 }
 
 unsigned int wined3d_adapter_vk_get_memory_type_index(const struct wined3d_adapter_vk *adapter_vk,
@@ -1827,6 +1830,8 @@ static const struct
 vulkan_instance_extensions[] =
 {
     {VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, VK_API_VERSION_1_1, FALSE},
+    {VK_KHR_SURFACE_EXTENSION_NAME,                          ~0u,                TRUE},
+    {VK_KHR_WIN32_SURFACE_EXTENSION_NAME,                    ~0u,                TRUE},
 };
 
 static BOOL enable_vulkan_instance_extensions(uint32_t *extension_count,

dlls/wined3d/swapchain.c

@@ -113,6 +113,45 @@ void wined3d_swapchain_gl_cleanup(struct wined3d_swapchain_gl *swapchain_gl)
     }
 }
 
+static void wined3d_swapchain_vk_destroy_vulkan_swapchain(struct wined3d_swapchain_vk *swapchain_vk)
+{
+    struct wined3d_device_vk *device_vk = wined3d_device_vk(swapchain_vk->s.device);
+    const struct wined3d_vk_info *vk_info;
+    unsigned int i;
+    VkResult vr;
+
+    TRACE("swapchain_vk %p.\n", swapchain_vk);
+
+    vk_info = &wined3d_adapter_vk(device_vk->d.adapter)->vk_info;
+
+    if ((vr = VK_CALL(vkQueueWaitIdle(device_vk->vk_queue))) < 0)
+        ERR("Failed to wait on queue, vr %s.\n", wined3d_debug_vkresult(vr));
+    heap_free(swapchain_vk->vk_images);
+    for (i = 0; i < swapchain_vk->image_count; ++i)
+    {
+        VK_CALL(vkDestroySemaphore(device_vk->vk_device, swapchain_vk->vk_semaphores[i].available, NULL));
+        VK_CALL(vkDestroySemaphore(device_vk->vk_device, swapchain_vk->vk_semaphores[i].presentable, NULL));
+    }
+    heap_free(swapchain_vk->vk_semaphores);
+    VK_CALL(vkDestroySwapchainKHR(device_vk->vk_device, swapchain_vk->vk_swapchain, NULL));
+    VK_CALL(vkDestroySurfaceKHR(vk_info->instance, swapchain_vk->vk_surface, NULL));
+}
+
+static void wined3d_swapchain_vk_destroy_object(void *object)
+{
+    wined3d_swapchain_vk_destroy_vulkan_swapchain(object);
+}
+
+void wined3d_swapchain_vk_cleanup(struct wined3d_swapchain_vk *swapchain_vk)
+{
+    struct wined3d_cs *cs = swapchain_vk->s.device->cs;
+
+    wined3d_cs_destroy_object(cs, wined3d_swapchain_vk_destroy_object, swapchain_vk);
+    wined3d_cs_finish(cs, WINED3D_CS_QUEUE_DEFAULT);
+
+    wined3d_swapchain_cleanup(&swapchain_vk->s);
+}
+
 ULONG CDECL wined3d_swapchain_incref(struct wined3d_swapchain *swapchain)
 {
     ULONG refcount = InterlockedIncrement(&swapchain->ref);
@@ -551,10 +590,561 @@ static const struct wined3d_swapchain_ops swapchain_gl_ops =
     swapchain_frontbuffer_updated,
 };
 
+static bool wined3d_swapchain_vk_present_mode_supported(struct wined3d_swapchain_vk *swapchain_vk,
+        VkPresentModeKHR vk_present_mode)
+{
+    struct wined3d_device_vk *device_vk = wined3d_device_vk(swapchain_vk->s.device);
+    const struct wined3d_vk_info *vk_info;
+    struct wined3d_adapter_vk *adapter_vk;
+    VkPhysicalDevice vk_physical_device;
+    VkPresentModeKHR *vk_modes;
+    bool supported = false;
+    uint32_t count, i;
+    VkResult vr;
+
+    adapter_vk = wined3d_adapter_vk(device_vk->d.adapter);
+    vk_physical_device = adapter_vk->physical_device;
+    vk_info = &adapter_vk->vk_info;
+
+    if ((vr = VK_CALL(vkGetPhysicalDeviceSurfacePresentModesKHR(vk_physical_device,
+            swapchain_vk->vk_surface, &count, NULL))) < 0)
+    {
+        ERR("Failed to get supported present mode count, vr %s.\n", wined3d_debug_vkresult(vr));
+        return false;
+    }
+
+    if (!(vk_modes = heap_calloc(count, sizeof(*vk_modes))))
+        return false;
+
+    if ((vr = VK_CALL(vkGetPhysicalDeviceSurfacePresentModesKHR(vk_physical_device,
+            swapchain_vk->vk_surface, &count, vk_modes))) < 0)
+    {
+        ERR("Failed to get supported present modes, vr %s.\n", wined3d_debug_vkresult(vr));
+        goto done;
+    }
+
+    for (i = 0; i < count; ++i)
+    {
+        if (vk_modes[i] == vk_present_mode)
+        {
+            supported = true;
+            goto done;
+        }
+    }
+
+done:
+    heap_free(vk_modes);
+    return supported;
+}
+
+static VkFormat wined3d_swapchain_vk_select_vk_format(struct wined3d_swapchain_vk *swapchain_vk,
+        VkSurfaceKHR vk_surface)
+{
+    struct wined3d_device_vk *device_vk = wined3d_device_vk(swapchain_vk->s.device);
+    const struct wined3d_swapchain_desc *desc = &swapchain_vk->s.state.desc;
+    const struct wined3d_vk_info *vk_info;
+    struct wined3d_adapter_vk *adapter_vk;
+    const struct wined3d_format *format;
+    VkPhysicalDevice vk_physical_device;
+    VkSurfaceFormatKHR *vk_formats;
+    uint32_t format_count, i;
+    VkFormat vk_format;
+    VkResult vr;
+
+    adapter_vk = wined3d_adapter_vk(device_vk->d.adapter);
+    vk_physical_device = adapter_vk->physical_device;
+    vk_info = &adapter_vk->vk_info;
+
+    if ((format = wined3d_get_format(&adapter_vk->a, desc->backbuffer_format, WINED3D_BIND_RENDER_TARGET)))
+        vk_format = wined3d_format_vk(format)->vk_format;
+    else
+        vk_format = VK_FORMAT_B8G8R8A8_UNORM;
+
+    vr = VK_CALL(vkGetPhysicalDeviceSurfaceFormatsKHR(vk_physical_device, vk_surface, &format_count, NULL));
+    if (vr < 0 || !format_count)
+    {
+        WARN("Failed to get supported surface format count, vr %s.\n", wined3d_debug_vkresult(vr));
+        return VK_FORMAT_UNDEFINED;
+    }
+
+    if (!(vk_formats = heap_calloc(format_count, sizeof(*vk_formats))))
+        return VK_FORMAT_UNDEFINED;
+
+    if ((vr = VK_CALL(vkGetPhysicalDeviceSurfaceFormatsKHR(vk_physical_device,
+            vk_surface, &format_count, vk_formats))) < 0)
+    {
+        WARN("Failed to get supported surface formats, vr %s.\n", wined3d_debug_vkresult(vr));
+        heap_free(vk_formats);
+        return VK_FORMAT_UNDEFINED;
+    }
+
+    for (i = 0; i < format_count; ++i)
+    {
+        if (vk_formats[i].format == vk_format && vk_formats[i].colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR)
+            break;
+    }
+    if (i == format_count)
+    {
+        /* Try to create a swapchain with format conversion. */
+        vk_format = VK_FORMAT_B8G8R8A8_UNORM;
+        WARN("Failed to find Vulkan swapchain format for %s.\n", debug_d3dformat(desc->backbuffer_format));
+        for (i = 0; i < format_count; ++i)
+        {
+            if (vk_formats[i].format == vk_format && vk_formats[i].colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR)
+                break;
+        }
+    }
+    heap_free(vk_formats);
+    if (i == format_count)
+    {
+        FIXME("Failed to find Vulkan swapchain format for %s.\n", debug_d3dformat(desc->backbuffer_format));
+        return VK_FORMAT_UNDEFINED;
+    }
+
+    TRACE("Using Vulkan swapchain format %#x.\n", vk_format);
+
+    return vk_format;
+}
+
+static bool wined3d_swapchain_vk_create_vulkan_swapchain_images(struct wined3d_swapchain_vk *swapchain_vk,
+        VkSwapchainKHR vk_swapchain)
+{
+    struct wined3d_device_vk *device_vk = wined3d_device_vk(swapchain_vk->s.device);
+    const struct wined3d_vk_info *vk_info;
+    VkSemaphoreCreateInfo semaphore_info;
+    uint32_t image_count, i;
+    VkResult vr;
+
+    vk_info = &wined3d_adapter_vk(device_vk->d.adapter)->vk_info;
+
+    if ((vr = VK_CALL(vkGetSwapchainImagesKHR(device_vk->vk_device, vk_swapchain, &image_count, NULL))) < 0)
+    {
+        ERR("Failed to get image count, vr %s\n", wined3d_debug_vkresult(vr));
+        return false;
+    }
+
+    if (!(swapchain_vk->vk_images = heap_calloc(image_count, sizeof(*swapchain_vk->vk_images))))
+    {
+        ERR("Failed to allocate images array.\n");
+        return false;
+    }
+
+    if ((vr = VK_CALL(vkGetSwapchainImagesKHR(device_vk->vk_device,
+            vk_swapchain, &image_count, swapchain_vk->vk_images))) < 0)
+    {
+        ERR("Failed to get swapchain images, vr %s.\n", wined3d_debug_vkresult(vr));
+        heap_free(swapchain_vk->vk_images);
+        return false;
+    }
+
+    if (!(swapchain_vk->vk_semaphores = heap_calloc(image_count, sizeof(*swapchain_vk->vk_semaphores))))
+    {
+        ERR("Failed to allocate semaphores array.\n");
+        heap_free(swapchain_vk->vk_images);
+        return false;
+    }
+
+    semaphore_info.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
+    semaphore_info.pNext = NULL;
+    semaphore_info.flags = 0;
+    for (i = 0; i < image_count; ++i)
+    {
+        if ((vr = VK_CALL(vkCreateSemaphore(device_vk->vk_device,
+                &semaphore_info, NULL, &swapchain_vk->vk_semaphores[i].available))) < 0)
+        {
+            ERR("Failed to create semaphore, vr %s.\n", wined3d_debug_vkresult(vr));
+            goto fail;
+        }
+
+        if ((vr = VK_CALL(vkCreateSemaphore(device_vk->vk_device,
+                &semaphore_info, NULL, &swapchain_vk->vk_semaphores[i].presentable))) < 0)
+        {
+            ERR("Failed to create semaphore, vr %s.\n", wined3d_debug_vkresult(vr));
+            goto fail;
+        }
+    }
+    swapchain_vk->image_count = image_count;
+
+    return true;
+
+fail:
+    for (i = 0; i < image_count; ++i)
+    {
+        if (swapchain_vk->vk_semaphores[i].available)
+            VK_CALL(vkDestroySemaphore(device_vk->vk_device, swapchain_vk->vk_semaphores[i].available, NULL));
+        if (swapchain_vk->vk_semaphores[i].presentable)
+            VK_CALL(vkDestroySemaphore(device_vk->vk_device, swapchain_vk->vk_semaphores[i].presentable, NULL));
+    }
+    heap_free(swapchain_vk->vk_semaphores);
+    heap_free(swapchain_vk->vk_images);
+    return false;
+}
+
+static HRESULT wined3d_swapchain_vk_create_vulkan_swapchain(struct wined3d_swapchain_vk *swapchain_vk)
+{
+    struct wined3d_device_vk *device_vk = wined3d_device_vk(swapchain_vk->s.device);
+    const struct wined3d_swapchain_desc *desc = &swapchain_vk->s.state.desc;
+    VkSwapchainCreateInfoKHR vk_swapchain_desc;
+    VkWin32SurfaceCreateInfoKHR surface_desc;
+    unsigned int width, height, image_count;
+    const struct wined3d_vk_info *vk_info;
+    VkSurfaceCapabilitiesKHR surface_caps;
+    struct wined3d_adapter_vk *adapter_vk;
+    VkPresentModeKHR vk_present_mode;
+    VkSwapchainKHR vk_swapchain;
+    VkImageUsageFlags usage;
+    VkSurfaceKHR vk_surface;
+    VkBool32 supported;
+    VkFormat vk_format;
+    VkResult vr;
+
+    adapter_vk = wined3d_adapter_vk(device_vk->d.adapter);
+    vk_info = &adapter_vk->vk_info;
+
+    surface_desc.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
+    surface_desc.pNext = NULL;
+    surface_desc.flags = 0;
+    surface_desc.hinstance = (HINSTANCE)GetWindowLongPtrW(swapchain_vk->s.win_handle, GWLP_HINSTANCE);
+    surface_desc.hwnd = swapchain_vk->s.win_handle;
+    if ((vr = VK_CALL(vkCreateWin32SurfaceKHR(vk_info->instance, &surface_desc, NULL, &vk_surface))) < 0)
+    {
+        ERR("Failed to create Vulkan surface, vr %s.\n", wined3d_debug_vkresult(vr));
+        return E_FAIL;
+    }
+    swapchain_vk->vk_surface = vk_surface;
+
+    if ((vr = VK_CALL(vkGetPhysicalDeviceSurfaceSupportKHR(adapter_vk->physical_device,
+            device_vk->vk_queue_family_index, vk_surface, &supported))) < 0 || !supported)
+    {
+        ERR("Queue family does not support presentation on this surface, vr %s.\n", wined3d_debug_vkresult(vr));
+        goto fail;
+    }
+
+    if ((vk_format = wined3d_swapchain_vk_select_vk_format(swapchain_vk, vk_surface)) == VK_FORMAT_UNDEFINED)
+    {
+        ERR("Failed to select swapchain format.\n");
+        goto fail;
+    }
+
+    if ((vr = VK_CALL(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(adapter_vk->physical_device,
+            swapchain_vk->vk_surface, &surface_caps))) < 0)
+    {
+        ERR("Failed to get surface capabilities, vr %s.\n", wined3d_debug_vkresult(vr));
+        goto fail;
+    }
+
+    image_count = desc->backbuffer_count;
+    if (image_count < surface_caps.minImageCount)
+        image_count = surface_caps.minImageCount;
+    else if (surface_caps.maxImageCount && image_count > surface_caps.maxImageCount)
+        image_count = surface_caps.maxImageCount;
+
+    if (image_count != desc->backbuffer_count)
+        WARN("Image count %u is not supported (%u-%u).\n", desc->backbuffer_count,
+                surface_caps.minImageCount, surface_caps.maxImageCount);
+
+    width = desc->backbuffer_width;
+    if (width < surface_caps.minImageExtent.width)
+        width = surface_caps.minImageExtent.width;
+    else if (width > surface_caps.maxImageExtent.width)
+        width = surface_caps.maxImageExtent.width;
+
+    height = desc->backbuffer_height;
+    if (height < surface_caps.minImageExtent.height)
+        height = surface_caps.minImageExtent.height;
+    else if (height > surface_caps.maxImageExtent.height)
+        height = surface_caps.maxImageExtent.height;
+
+    if (width != desc->backbuffer_width || height != desc->backbuffer_height)
+        WARN("Swapchain dimensions %ux%u are not supported (%u-%u x %u-%u).\n",
+                desc->backbuffer_width, desc->backbuffer_height,
+                surface_caps.minImageExtent.width, surface_caps.maxImageExtent.width,
+                surface_caps.minImageExtent.height, surface_caps.maxImageExtent.height);
+
+    usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+    usage |= surface_caps.supportedUsageFlags & VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
+    usage |= surface_caps.supportedUsageFlags & VK_IMAGE_USAGE_TRANSFER_DST_BIT;
+    if (!(usage & VK_IMAGE_USAGE_TRANSFER_SRC_BIT) || !(usage & VK_IMAGE_USAGE_TRANSFER_DST_BIT))
+        WARN("Transfer not supported for swapchain images.\n");
+
+    if (!(surface_caps.supportedCompositeAlpha & VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR))
+    {
+        FIXME("Unsupported alpha mode, %#x.\n", surface_caps.supportedCompositeAlpha);
+        goto fail;
+    }
+
+    vk_present_mode = VK_PRESENT_MODE_FIFO_KHR;
+    if (!swapchain_vk->s.swap_interval)
+    {
+        if (wined3d_swapchain_vk_present_mode_supported(swapchain_vk, VK_PRESENT_MODE_IMMEDIATE_KHR))
+            vk_present_mode = VK_PRESENT_MODE_IMMEDIATE_KHR;
+        else
+            FIXME("Unsupported swap interval %u.\n", swapchain_vk->s.swap_interval);
+    }
+
+    vk_swapchain_desc.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
+    vk_swapchain_desc.pNext = NULL;
+    vk_swapchain_desc.flags = 0;
+    vk_swapchain_desc.surface = vk_surface;
+    vk_swapchain_desc.minImageCount = image_count;
+    vk_swapchain_desc.imageFormat = vk_format;
+    vk_swapchain_desc.imageColorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR;
+    vk_swapchain_desc.imageExtent.width = width;
+    vk_swapchain_desc.imageExtent.height = height;
+    vk_swapchain_desc.imageArrayLayers = 1;
+    vk_swapchain_desc.imageUsage = usage;
+    vk_swapchain_desc.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
+    vk_swapchain_desc.queueFamilyIndexCount = 0;
+    vk_swapchain_desc.pQueueFamilyIndices = NULL;
+    vk_swapchain_desc.preTransform = surface_caps.currentTransform;
+    vk_swapchain_desc.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
+    vk_swapchain_desc.presentMode = vk_present_mode;
+    vk_swapchain_desc.clipped = VK_TRUE;
+    vk_swapchain_desc.oldSwapchain = VK_NULL_HANDLE;
+    if ((vr = VK_CALL(vkCreateSwapchainKHR(device_vk->vk_device, &vk_swapchain_desc, NULL, &vk_swapchain))) < 0)
+    {
+        ERR("Failed to create Vulkan swapchain, vr %s.\n", wined3d_debug_vkresult(vr));
+        goto fail;
+    }
+    swapchain_vk->vk_swapchain = vk_swapchain;
+
+    if (!wined3d_swapchain_vk_create_vulkan_swapchain_images(swapchain_vk, vk_swapchain))
+    {
+        VK_CALL(vkDestroySwapchainKHR(device_vk->vk_device, vk_swapchain, NULL));
+        goto fail;
+    }
+
+    return WINED3D_OK;
+
+fail:
+    VK_CALL(vkDestroySurfaceKHR(vk_info->instance, vk_surface, NULL));
+    return E_FAIL;
+}
+
+static HRESULT wined3d_swapchain_vk_recreate(struct wined3d_swapchain_vk *swapchain_vk)
+{
+    TRACE("swapchain_vk %p.\n", swapchain_vk);
+
+    wined3d_swapchain_vk_destroy_vulkan_swapchain(swapchain_vk);
+
+    return wined3d_swapchain_vk_create_vulkan_swapchain(swapchain_vk);
+}
+
+static void wined3d_swapchain_vk_set_swap_interval(struct wined3d_swapchain_vk *swapchain_vk,
+        unsigned int swap_interval)
+{
+    if (swap_interval > 1)
+    {
+        if (swap_interval <= 4)
+            FIXME("Unsupported swap interval %u.\n", swap_interval);
+        swap_interval = 1;
+    }
+
+    if (swapchain_vk->s.swap_interval == swap_interval)
+        return;
+
+    swapchain_vk->s.swap_interval = swap_interval;
+    wined3d_swapchain_vk_recreate(swapchain_vk);
+}
+
+static void wined3d_swapchain_vk_blit(struct wined3d_swapchain_vk *swapchain_vk,
+        struct wined3d_context_vk *context_vk, const RECT *src_rect, const RECT *dst_rect, unsigned int swap_interval)
+{
+    struct wined3d_texture_vk *back_buffer_vk = wined3d_texture_vk(swapchain_vk->s.back_buffers[0]);
+    struct wined3d_device_vk *device_vk = wined3d_device_vk(swapchain_vk->s.device);
+    const struct wined3d_swapchain_desc *desc = &swapchain_vk->s.state.desc;
+    const struct wined3d_vk_info *vk_info = context_vk->vk_info;
+    VkCommandBuffer vk_command_buffer;
+    VkPresentInfoKHR present_desc;
+    unsigned int present_idx;
+    VkImageLayout vk_layout;
+    uint32_t image_idx;
+    VkImageBlit blit;
+    VkResult vr;
+    HRESULT hr;
+
+    static const VkPipelineStageFlags wait_stage = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+
+    wined3d_swapchain_vk_set_swap_interval(swapchain_vk, swap_interval);
+
+    present_idx = swapchain_vk->current++ % swapchain_vk->image_count;
+    wined3d_context_vk_wait_command_buffer(context_vk, swapchain_vk->vk_semaphores[present_idx].command_buffer_id);
+    vr = VK_CALL(vkAcquireNextImageKHR(device_vk->vk_device, swapchain_vk->vk_swapchain, UINT64_MAX,
+            swapchain_vk->vk_semaphores[present_idx].available, VK_NULL_HANDLE, &image_idx));
+    if (vr == VK_ERROR_OUT_OF_DATE_KHR)
+    {
+        if (FAILED(hr = wined3d_swapchain_vk_recreate(swapchain_vk)))
+        {
+            ERR("Failed to recreate swapchain, hr %#x.\n", hr);
+            return;
+        }
+        vr = VK_CALL(vkAcquireNextImageKHR(device_vk->vk_device, swapchain_vk->vk_swapchain, UINT64_MAX,
+                swapchain_vk->vk_semaphores[present_idx].available, VK_NULL_HANDLE, &image_idx));
+    }
+    if (vr < 0)
+    {
+        ERR("Failed to acquire next Vulkan image, vr %s.\n", wined3d_debug_vkresult(vr));
+        return;
+    }
+
+    vk_command_buffer = wined3d_context_vk_get_command_buffer(context_vk);
+
+    wined3d_context_vk_end_current_render_pass(context_vk);
+
+    wined3d_context_vk_image_barrier(context_vk, vk_command_buffer,
+            VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
+            vk_access_mask_from_bind_flags(back_buffer_vk->t.resource.bind_flags),
+            VK_ACCESS_TRANSFER_READ_BIT,
+            back_buffer_vk->layout, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
+            back_buffer_vk->vk_image, VK_IMAGE_ASPECT_COLOR_BIT);
+
+    wined3d_context_vk_image_barrier(context_vk, vk_command_buffer,
+            VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
+            0, VK_ACCESS_TRANSFER_WRITE_BIT,
+            VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+            swapchain_vk->vk_images[image_idx], VK_IMAGE_ASPECT_COLOR_BIT);
+
+    blit.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+    blit.srcSubresource.mipLevel = 0;
+    blit.srcSubresource.baseArrayLayer = 0;
+    blit.srcSubresource.layerCount = 1;
+    blit.srcOffsets[0].x = src_rect->left;
+    blit.srcOffsets[0].y = src_rect->top;
+    blit.srcOffsets[0].z = 0;
+    blit.srcOffsets[1].x = src_rect->right;
+    blit.srcOffsets[1].y = src_rect->bottom;
+    blit.srcOffsets[1].z = 1;
+    blit.dstSubresource = blit.srcSubresource;
+    blit.dstOffsets[0].x = dst_rect->left;
+    blit.dstOffsets[0].y = dst_rect->top;
+    blit.dstOffsets[0].z = 0;
+    blit.dstOffsets[1].x = dst_rect->right;
+    blit.dstOffsets[1].y = dst_rect->bottom;
+    blit.dstOffsets[1].z = 1;
+    VK_CALL(vkCmdBlitImage(vk_command_buffer,
+            back_buffer_vk->vk_image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
+            swapchain_vk->vk_images[image_idx], VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+            1, &blit, VK_FILTER_NEAREST));
+
+    wined3d_context_vk_image_barrier(context_vk, vk_command_buffer,
+            VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
+            VK_ACCESS_TRANSFER_WRITE_BIT, 0,
+            VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
+            swapchain_vk->vk_images[image_idx], VK_IMAGE_ASPECT_COLOR_BIT);
+
+    if (desc->swap_effect == WINED3D_SWAP_EFFECT_DISCARD || desc->swap_effect == WINED3D_SWAP_EFFECT_FLIP_DISCARD)
+        vk_layout = VK_IMAGE_LAYOUT_UNDEFINED;
+    else
+        vk_layout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
+    wined3d_context_vk_image_barrier(context_vk, vk_command_buffer,
+            VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
+            VK_ACCESS_TRANSFER_READ_BIT,
+            vk_access_mask_from_bind_flags(back_buffer_vk->t.resource.bind_flags),
+            vk_layout, back_buffer_vk->layout,
+            back_buffer_vk->vk_image, VK_IMAGE_ASPECT_COLOR_BIT);
+
+    swapchain_vk->vk_semaphores[present_idx].command_buffer_id = context_vk->current_command_buffer.id;
+    wined3d_context_vk_submit_command_buffer(context_vk,
+            1, &swapchain_vk->vk_semaphores[present_idx].available, &wait_stage,
+            1, &swapchain_vk->vk_semaphores[present_idx].presentable);
+
+    present_desc.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
+    present_desc.pNext = NULL;
+    present_desc.waitSemaphoreCount = 1;
+    present_desc.pWaitSemaphores = &swapchain_vk->vk_semaphores[present_idx].presentable;
+    present_desc.swapchainCount = 1;
+    present_desc.pSwapchains = &swapchain_vk->vk_swapchain;
+    present_desc.pImageIndices = &image_idx;
+    present_desc.pResults = NULL;
+    if ((vr = VK_CALL(vkQueuePresentKHR(device_vk->vk_queue, &present_desc))))
+        ERR("Present returned vr %s.\n", wined3d_debug_vkresult(vr));
+}
+
+static void wined3d_swapchain_vk_rotate(struct wined3d_swapchain *swapchain, struct wined3d_context_vk *context_vk)
+{
+    struct wined3d_texture_sub_resource *sub_resource;
+    struct wined3d_texture_vk *texture, *texture_prev;
+    struct wined3d_allocator_block *memory0;
+    VkDescriptorImageInfo vk_info0;
+    VkDeviceMemory vk_memory0;
+    VkImageLayout vk_layout0;
+    VkImage vk_image0;
+    DWORD locations0;
+    unsigned int i;
+    uint64_t id0;
+
+    static const DWORD supported_locations = WINED3D_LOCATION_TEXTURE_RGB | WINED3D_LOCATION_RB_MULTISAMPLE;
+
+    if (swapchain->state.desc.backbuffer_count < 2)
+        return;
+
+    texture_prev = wined3d_texture_vk(swapchain->back_buffers[0]);
+
+    /* Back buffer 0 is already in the draw binding. */
+    vk_image0 = texture_prev->vk_image;
+    memory0 = texture_prev->memory;
+    vk_memory0 = texture_prev->vk_memory;
+    vk_layout0 = texture_prev->layout;
+    id0 = texture_prev->command_buffer_id;
+    vk_info0 = texture_prev->default_image_info;
+    locations0 = texture_prev->t.sub_resources[0].locations;
+
+    for (i = 1; i < swapchain->state.desc.backbuffer_count; ++i)
+    {
+        texture = wined3d_texture_vk(swapchain->back_buffers[i]);
+        sub_resource = &texture->t.sub_resources[0];
+
+        if (!(sub_resource->locations & supported_locations))
+            wined3d_texture_load_location(&texture->t, 0, &context_vk->c, texture->t.resource.draw_binding);
+
+        texture_prev->vk_image = texture->vk_image;
+        texture_prev->memory = texture->memory;
+        texture_prev->vk_memory = texture->vk_memory;
+        texture_prev->layout = texture->layout;
+        texture_prev->command_buffer_id = texture->command_buffer_id;
+        texture_prev->default_image_info = texture->default_image_info;
+
+        wined3d_texture_validate_location(&texture_prev->t, 0, sub_resource->locations & supported_locations);
+        wined3d_texture_invalidate_location(&texture_prev->t, 0, ~(sub_resource->locations & supported_locations));
+
+        texture_prev = texture;
+    }
+
+    texture_prev->vk_image = vk_image0;
+    texture_prev->memory = memory0;
+    texture_prev->vk_memory = vk_memory0;
+    texture_prev->layout = vk_layout0;
+    texture_prev->command_buffer_id = id0;
+    texture_prev->default_image_info = vk_info0;
+
+    wined3d_texture_validate_location(&texture_prev->t, 0, locations0 & supported_locations);
+    wined3d_texture_invalidate_location(&texture_prev->t, 0, ~(locations0 & supported_locations));
+
+    device_invalidate_state(swapchain->device, STATE_FRAMEBUFFER);
+}
+
 static void swapchain_vk_present(struct wined3d_swapchain *swapchain, const RECT *src_rect,
         const RECT *dst_rect, unsigned int swap_interval, uint32_t flags)
 {
-    FIXME("Not implemented.\n");
+    struct wined3d_swapchain_vk *swapchain_vk = wined3d_swapchain_vk(swapchain);
+    struct wined3d_texture *back_buffer = swapchain->back_buffers[0];
+    struct wined3d_context_vk *context_vk;
+
+    context_vk = wined3d_context_vk(context_acquire(swapchain->device, back_buffer, 0));
+
+    wined3d_texture_load_location(back_buffer, 0, &context_vk->c, back_buffer->resource.draw_binding);
+
+    if (swapchain_vk->vk_swapchain)
+        wined3d_swapchain_vk_blit(swapchain_vk, context_vk, src_rect, dst_rect, swap_interval);
+
+    wined3d_swapchain_vk_rotate(swapchain, context_vk);
+
+    wined3d_texture_validate_location(swapchain->front_buffer, 0, WINED3D_LOCATION_DRAWABLE);
+    wined3d_texture_invalidate_location(swapchain->front_buffer, 0, ~WINED3D_LOCATION_DRAWABLE);
+
+    TRACE("Starting new frame.\n");
+
+    context_release(&context_vk->c);
 }
 
 static const struct wined3d_swapchain_ops swapchain_vk_ops =
@@ -994,13 +1584,30 @@ HRESULT wined3d_swapchain_gl_init(struct wined3d_swapchain_gl *swapchain_gl, str
     return hr;
 }
 
-HRESULT wined3d_swapchain_vk_init(struct wined3d_swapchain *swapchain_vk, struct wined3d_device *device,
+HRESULT wined3d_swapchain_vk_init(struct wined3d_swapchain_vk *swapchain_vk, struct wined3d_device *device,
         struct wined3d_swapchain_desc *desc, void *parent, const struct wined3d_parent_ops *parent_ops)
 {
+    HRESULT hr;
+
     TRACE("swapchain_vk %p, device %p, desc %p, parent %p, parent_ops %p.\n",
             swapchain_vk, device, desc, parent, parent_ops);
 
-    return wined3d_swapchain_init(swapchain_vk, device, desc, parent, parent_ops, &swapchain_vk_ops);
+    if (FAILED(hr = wined3d_swapchain_init(&swapchain_vk->s, device, desc, parent, parent_ops, &swapchain_vk_ops)))
+        return hr;
+
+    if (swapchain_vk->s.win_handle == GetDesktopWindow())
+    {
+        WARN("Creating a desktop window swapchain.\n");
+        return hr;
+    }
+
+    if (FAILED(hr = wined3d_swapchain_vk_create_vulkan_swapchain(swapchain_vk)))
+    {
+        wined3d_swapchain_cleanup(&swapchain_vk->s);
+        return hr;
+    }
+
+    return hr;
 }
 
 HRESULT CDECL wined3d_swapchain_create(struct wined3d_device *device, struct wined3d_swapchain_desc *desc,

dlls/wined3d/wined3d_private.h

@@ -5084,7 +5084,29 @@ HRESULT wined3d_swapchain_gl_init(struct wined3d_swapchain_gl *swapchain_gl,
         struct wined3d_device *device, struct wined3d_swapchain_desc *desc,
         void *parent, const struct wined3d_parent_ops *parent_ops) DECLSPEC_HIDDEN;
 
-HRESULT wined3d_swapchain_vk_init(struct wined3d_swapchain *swapchain_vk,
+struct wined3d_swapchain_vk
+{
+    struct wined3d_swapchain s;
+
+    VkSwapchainKHR vk_swapchain;
+    VkSurfaceKHR vk_surface;
+    VkImage *vk_images;
+    struct
+    {
+        VkSemaphore available;
+        VkSemaphore presentable;
+        uint64_t command_buffer_id;
+    } *vk_semaphores;
+    unsigned int current, image_count;
+};
+
+static inline struct wined3d_swapchain_vk *wined3d_swapchain_vk(struct wined3d_swapchain *swapchain)
+{
+    return CONTAINING_RECORD(swapchain, struct wined3d_swapchain_vk, s);
+}
+
+void wined3d_swapchain_vk_cleanup(struct wined3d_swapchain_vk *swapchain_vk) DECLSPEC_HIDDEN;
+HRESULT wined3d_swapchain_vk_init(struct wined3d_swapchain_vk *swapchain_vk,
         struct wined3d_device *device, struct wined3d_swapchain_desc *desc,
         void *parent, const struct wined3d_parent_ops *parent_ops) DECLSPEC_HIDDEN;
 

dlls/wined3d/wined3d_vk.h

@@ -41,7 +41,15 @@
     VK_INSTANCE_PFN(vkGetPhysicalDeviceSparseImageFormatProperties) \
     /* Vulkan 1.1 */ \
     VK_INSTANCE_EXT_PFN(vkGetPhysicalDeviceFeatures2) \
-    VK_INSTANCE_EXT_PFN(vkGetPhysicalDeviceProperties2)
+    VK_INSTANCE_EXT_PFN(vkGetPhysicalDeviceProperties2) \
+    /* VK_KHR_surface */ \
+    VK_INSTANCE_PFN(vkDestroySurfaceKHR) \
+    VK_INSTANCE_PFN(vkGetPhysicalDeviceSurfaceCapabilitiesKHR) \
+    VK_INSTANCE_PFN(vkGetPhysicalDeviceSurfaceFormatsKHR) \
+    VK_INSTANCE_PFN(vkGetPhysicalDeviceSurfacePresentModesKHR) \
+    VK_INSTANCE_PFN(vkGetPhysicalDeviceSurfaceSupportKHR) \
+    /* VK_KHR_win32_surface */ \
+    VK_INSTANCE_PFN(vkCreateWin32SurfaceKHR)
 
 #define VK_DEVICE_FUNCS() \
     VK_DEVICE_PFN(vkAllocateCommandBuffers) \
@@ -163,7 +171,13 @@
     VK_DEVICE_PFN(vkSetEvent) \
     VK_DEVICE_PFN(vkUnmapMemory) \
     VK_DEVICE_PFN(vkUpdateDescriptorSets) \
-    VK_DEVICE_PFN(vkWaitForFences)
+    VK_DEVICE_PFN(vkWaitForFences) \
+    /* VK_KHR_swapchain */ \
+    VK_DEVICE_PFN(vkAcquireNextImageKHR) \
+    VK_DEVICE_PFN(vkCreateSwapchainKHR) \
+    VK_DEVICE_PFN(vkDestroySwapchainKHR) \
+    VK_DEVICE_PFN(vkGetSwapchainImagesKHR) \
+    VK_DEVICE_PFN(vkQueuePresentKHR)
 
 #define DECLARE_VK_PFN(name) PFN_##name name;