dlls/dxgi/swapchain.c

   1 /*
   2  * Copyright 2008 Henri Verbeet for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  *
  18  */
  19
  20 #include "config.h"
  21 #include "wine/port.h"
  22
  23 #include "dxgi_private.h"
  24
  25 #ifdef SONAME_LIBVKD3D
  26 #define VK_NO_PROTOTYPES
  27 #define VKD3D_NO_PROTOTYPES
  28 #define VKD3D_NO_VULKAN_H
  29 #define VKD3D_NO_WIN32_TYPES
  30 #ifndef USE_WIN32_VULKAN
  31 #define WINE_VK_HOST
  32 #endif
  33 #include "wine/vulkan.h"
  34 #include "wine/vulkan_driver.h"
  35 #include <vkd3d.h>
  36 #endif
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(dxgi);
  39 WINE_DECLARE_DEBUG_CHANNEL(winediag);
  40
  41 static DXGI_SWAP_EFFECT dxgi_swap_effect_from_wined3d(enum wined3d_swap_effect swap_effect)
  42 {
  43     switch (swap_effect)
  44     {
  45         case WINED3D_SWAP_EFFECT_DISCARD:
  46             return DXGI_SWAP_EFFECT_DISCARD;
  47         case WINED3D_SWAP_EFFECT_SEQUENTIAL:
  48             return DXGI_SWAP_EFFECT_SEQUENTIAL;
  49         case WINED3D_SWAP_EFFECT_FLIP_DISCARD:
  50             return DXGI_SWAP_EFFECT_FLIP_DISCARD;
  51         case WINED3D_SWAP_EFFECT_FLIP_SEQUENTIAL:
  52             return DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
  53         default:
  54             FIXME("Invalid swap effect %#x.\n", swap_effect);
  55             return DXGI_SWAP_EFFECT_DISCARD;
  56     }
  57 }
  58
  59 static BOOL dxgi_validate_flip_swap_effect_format(DXGI_FORMAT format)
  60 {
  61     switch (format)
  62     {
  63         case DXGI_FORMAT_R16G16B16A16_FLOAT:
  64         case DXGI_FORMAT_R10G10B10A2_UNORM:
  65         case DXGI_FORMAT_R8G8B8A8_UNORM:
  66         case DXGI_FORMAT_B8G8R8A8_UNORM:
  67             return TRUE;
  68         default:
  69             WARN("Invalid swapchain format %#x for flip presentation model.\n", format);
  70             return FALSE;
  71     }
  72 }
  73
  74 BOOL dxgi_validate_swapchain_desc(const DXGI_SWAP_CHAIN_DESC1 *desc)
  75 {
  76     unsigned int min_buffer_count;
  77
  78     switch (desc->SwapEffect)
  79     {
  80         case DXGI_SWAP_EFFECT_DISCARD:
  81         case DXGI_SWAP_EFFECT_SEQUENTIAL:
  82             min_buffer_count = 1;
  83             break;
  84
  85         case DXGI_SWAP_EFFECT_FLIP_DISCARD:
  86         case DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL:
  87             min_buffer_count = 2;
  88
  89             if (desc->Format && !dxgi_validate_flip_swap_effect_format(desc->Format))
  90                 return FALSE;
  91
  92             if (desc->SampleDesc.Count != 1 || desc->SampleDesc.Quality)
  93             {
  94                 WARN("Invalid sample desc %u, %u for swap effect %#x.\n",
  95                         desc->SampleDesc.Count, desc->SampleDesc.Quality, desc->SwapEffect);
  96                 return FALSE;
  97             }
  98             break;
  99
 100         default:
 101             WARN("Invalid swap effect %u used.\n", desc->SwapEffect);
 102             return FALSE;
 103     }
 104
 105     if (desc->BufferCount < min_buffer_count || desc->BufferCount > DXGI_MAX_SWAP_CHAIN_BUFFERS)
 106     {
 107         WARN("BufferCount is %u.\n", desc->BufferCount);
 108         return FALSE;
 109     }
 110
 111     return TRUE;
 112 }
 113
 114 HRESULT dxgi_get_output_from_window(IWineDXGIFactory *factory, HWND window, IDXGIOutput **dxgi_output)
 115 {
 116     unsigned int adapter_idx, output_idx;
 117     DXGI_OUTPUT_DESC desc;
 118     IDXGIAdapter *adapter;
 119     IDXGIOutput *output;
 120     HMONITOR monitor;
 121     HRESULT hr;
 122
 123     if (!(monitor = MonitorFromWindow(window, MONITOR_DEFAULTTONEAREST)))
 124     {
 125         WARN("Failed to get monitor from window.\n");
 126         return DXGI_ERROR_INVALID_CALL;
 127     }
 128
 129     for (adapter_idx = 0; SUCCEEDED(hr = IWineDXGIFactory_EnumAdapters(factory, adapter_idx, &adapter));
 130             ++adapter_idx)
 131     {
 132         for (output_idx = 0; SUCCEEDED(hr = IDXGIAdapter_EnumOutputs(adapter, output_idx,
 133                 &output)); ++output_idx)
 134         {
 135             if (FAILED(hr = IDXGIOutput_GetDesc(output, &desc)))
 136             {
 137                 WARN("Adapter %u output %u: Failed to get output desc, hr %#x.\n", adapter_idx,
 138                         output_idx, hr);
 139                 IDXGIOutput_Release(output);
 140                 continue;
 141             }
 142
 143             if (desc.Monitor == monitor)
 144             {
 145                 *dxgi_output = output;
 146                 IDXGIAdapter_Release(adapter);
 147                 return S_OK;
 148             }
 149
 150             IDXGIOutput_Release(output);
 151         }
 152         IDXGIAdapter_Release(adapter);
 153     }
 154
 155     if (hr != DXGI_ERROR_NOT_FOUND)
 156         WARN("Failed to enumerate outputs, hr %#x.\n", hr);
 157
 158     WARN("Output could not be found.\n");
 159     return DXGI_ERROR_NOT_FOUND;
 160 }
 161
 162 static HRESULT dxgi_swapchain_resize_target(struct wined3d_swapchain_state *state,
 163         const DXGI_MODE_DESC *target_mode_desc)
 164 {
 165     struct wined3d_display_mode mode;
 166
 167     if (!target_mode_desc)
 168     {
 169         WARN("Invalid pointer.\n");
 170         return DXGI_ERROR_INVALID_CALL;
 171     }
 172
 173     TRACE("Mode: %s.\n", debug_dxgi_mode(target_mode_desc));
 174
 175     if (target_mode_desc->Scaling)
 176         FIXME("Ignoring scaling %#x.\n", target_mode_desc->Scaling);
 177
 178     wined3d_display_mode_from_dxgi(&mode, target_mode_desc);
 179
 180     return wined3d_swapchain_state_resize_target(state, &mode);
 181 }
 182
 183 static HWND d3d11_swapchain_get_hwnd(struct d3d11_swapchain *swapchain)
 184 {
 185     struct wined3d_swapchain_desc wined3d_desc;
 186
 187     wined3d_mutex_lock();
 188     wined3d_swapchain_get_desc(swapchain->wined3d_swapchain, &wined3d_desc);
 189     wined3d_mutex_unlock();
 190
 191     return wined3d_desc.device_window;
 192 }
 193
 194 static inline struct d3d11_swapchain *d3d11_swapchain_from_IDXGISwapChain1(IDXGISwapChain1 *iface)
 195 {
 196     return CONTAINING_RECORD(iface, struct d3d11_swapchain, IDXGISwapChain1_iface);
 197 }
 198
 199 /* IUnknown methods */
 200
 201 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_QueryInterface(IDXGISwapChain1 *iface, REFIID riid, void **object)
 202 {
 203     TRACE("iface %p, riid %s, object %p\n", iface, debugstr_guid(riid), object);
 204
 205     if (IsEqualGUID(riid, &IID_IUnknown)
 206             || IsEqualGUID(riid, &IID_IDXGIObject)
 207             || IsEqualGUID(riid, &IID_IDXGIDeviceSubObject)
 208             || IsEqualGUID(riid, &IID_IDXGISwapChain)
 209             || IsEqualGUID(riid, &IID_IDXGISwapChain1))
 210     {
 211         IUnknown_AddRef(iface);
 212         *object = iface;
 213         return S_OK;
 214     }
 215
 216     WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid));
 217
 218     *object = NULL;
 219     return E_NOINTERFACE;
 220 }
 221
 222 static ULONG STDMETHODCALLTYPE d3d11_swapchain_AddRef(IDXGISwapChain1 *iface)
 223 {
 224     struct d3d11_swapchain *swapchain = d3d11_swapchain_from_IDXGISwapChain1(iface);
 225     ULONG refcount = InterlockedIncrement(&swapchain->refcount);
 226
 227     TRACE("%p increasing refcount to %u.\n", swapchain, refcount);
 228
 229     if (refcount == 1)
 230         wined3d_swapchain_incref(swapchain->wined3d_swapchain);
 231
 232     return refcount;
 233 }
 234
 235 static ULONG STDMETHODCALLTYPE d3d11_swapchain_Release(IDXGISwapChain1 *iface)
 236 {
 237     struct d3d11_swapchain *swapchain = d3d11_swapchain_from_IDXGISwapChain1(iface);
 238     ULONG refcount = InterlockedDecrement(&swapchain->refcount);
 239
 240     TRACE("%p decreasing refcount to %u.\n", swapchain, refcount);
 241
 242     if (!refcount)
 243     {
 244         IWineDXGIDevice *device = swapchain->device;
 245         if (swapchain->target)
 246         {
 247             WARN("Releasing fullscreen swapchain.\n");
 248             IDXGIOutput_Release(swapchain->target);
 249         }
 250         if (swapchain->factory)
 251             IWineDXGIFactory_Release(swapchain->factory);
 252         wined3d_swapchain_decref(swapchain->wined3d_swapchain);
 253         if (device)
 254             IWineDXGIDevice_Release(device);
 255     }
 256
 257     return refcount;
 258 }
 259
 260 /* IDXGIObject methods */
 261
 262 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_SetPrivateData(IDXGISwapChain1 *iface,
 263         REFGUID guid, UINT data_size, const void *data)
 264 {
 265     struct d3d11_swapchain *swapchain = d3d11_swapchain_from_IDXGISwapChain1(iface);
 266
 267     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 268
 269     return dxgi_set_private_data(&swapchain->private_store, guid, data_size, data);
 270 }
 271
 272 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_SetPrivateDataInterface(IDXGISwapChain1 *iface,
 273         REFGUID guid, const IUnknown *object)
 274 {
 275     struct d3d11_swapchain *swapchain = d3d11_swapchain_from_IDXGISwapChain1(iface);
 276
 277     TRACE("iface %p, guid %s, object %p.\n", iface, debugstr_guid(guid), object);
 278
 279     return dxgi_set_private_data_interface(&swapchain->private_store, guid, object);
 280 }
 281
 282 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_GetPrivateData(IDXGISwapChain1 *iface,
 283         REFGUID guid, UINT *data_size, void *data)
 284 {
 285     struct d3d11_swapchain *swapchain = d3d11_swapchain_from_IDXGISwapChain1(iface);
 286
 287     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 288
 289     return dxgi_get_private_data(&swapchain->private_store, guid, data_size, data);
 290 }
 291
 292 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_GetParent(IDXGISwapChain1 *iface, REFIID riid, void **parent)
 293 {
 294     struct d3d11_swapchain *swapchain = d3d11_swapchain_from_IDXGISwapChain1(iface);
 295
 296     TRACE("iface %p, riid %s, parent %p.\n", iface, debugstr_guid(riid), parent);
 297
 298     if (!swapchain->factory)
 299     {
 300         ERR("Implicit swapchain does not store reference to parent.\n");
 301         *parent = NULL;
 302         return E_NOINTERFACE;
 303     }
 304
 305     return IWineDXGIFactory_QueryInterface(swapchain->factory, riid, parent);
 306 }
 307
 308 /* IDXGIDeviceSubObject methods */
 309
 310 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_GetDevice(IDXGISwapChain1 *iface, REFIID riid, void **device)
 311 {
 312     struct d3d11_swapchain *swapchain = d3d11_swapchain_from_IDXGISwapChain1(iface);
 313
 314     TRACE("iface %p, riid %s, device %p.\n", iface, debugstr_guid(riid), device);
 315
 316     if (!swapchain->device)
 317     {
 318         ERR("Implicit swapchain does not store reference to device.\n");
 319         *device = NULL;
 320         return E_NOINTERFACE;
 321     }
 322
 323     return IWineDXGIDevice_QueryInterface(swapchain->device, riid, device);
 324 }
 325
 326 /* IDXGISwapChain1 methods */
 327
 328 static HRESULT d3d11_swapchain_present(struct d3d11_swapchain *swapchain,
 329         unsigned int sync_interval, unsigned int flags)
 330 {
 331     HRESULT hr;
 332
 333     if (sync_interval > 4)
 334     {
 335         WARN("Invalid sync interval %u.\n", sync_interval);
 336         return DXGI_ERROR_INVALID_CALL;
 337     }
 338
 339     if (IsIconic(d3d11_swapchain_get_hwnd(swapchain)))
 340         return DXGI_STATUS_OCCLUDED;
 341
 342     if (flags & ~DXGI_PRESENT_TEST)
 343         FIXME("Unimplemented flags %#x.\n", flags);
 344     if (flags & DXGI_PRESENT_TEST)
 345     {
 346         WARN("Returning S_OK for DXGI_PRESENT_TEST.\n");
 347         return S_OK;
 348     }
 349
 350     if (SUCCEEDED(hr = wined3d_swapchain_present(swapchain->wined3d_swapchain, NULL, NULL, NULL, sync_interval, 0)))
 351         InterlockedIncrement(&swapchain->present_count);
 352     return hr;
 353 }
 354
 355 static HRESULT STDMETHODCALLTYPE DECLSPEC_HOTPATCH d3d11_swapchain_Present(IDXGISwapChain1 *iface, UINT sync_interval, UINT flags)
 356 {
 357     struct d3d11_swapchain *swapchain = d3d11_swapchain_from_IDXGISwapChain1(iface);
 358
 359     TRACE("iface %p, sync_interval %u, flags %#x.\n", iface, sync_interval, flags);
 360
 361     return d3d11_swapchain_present(swapchain, sync_interval, flags);
 362 }
 363
 364 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_GetBuffer(IDXGISwapChain1 *iface,
 365         UINT buffer_idx, REFIID riid, void **surface)
 366 {
 367     struct d3d11_swapchain *swapchain = d3d11_swapchain_from_IDXGISwapChain1(iface);
 368     struct wined3d_texture *texture;
 369     IUnknown *parent;
 370     HRESULT hr;
 371
 372     TRACE("iface %p, buffer_idx %u, riid %s, surface %p\n",
 373             iface, buffer_idx, debugstr_guid(riid), surface);
 374
 375     wined3d_mutex_lock();
 376
 377     if (!(texture = wined3d_swapchain_get_back_buffer(swapchain->wined3d_swapchain, buffer_idx)))
 378     {
 379         wined3d_mutex_unlock();
 380         return DXGI_ERROR_INVALID_CALL;
 381     }
 382
 383     parent = wined3d_texture_get_parent(texture);
 384     hr = IUnknown_QueryInterface(parent, riid, surface);
 385     wined3d_mutex_unlock();
 386
 387     return hr;
 388 }
 389
 390 static HRESULT STDMETHODCALLTYPE DECLSPEC_HOTPATCH d3d11_swapchain_SetFullscreenState(IDXGISwapChain1 *iface,
 391         BOOL fullscreen, IDXGIOutput *target)
 392 {
 393     struct d3d11_swapchain *swapchain = d3d11_swapchain_from_IDXGISwapChain1(iface);
 394     struct wined3d_swapchain_desc swapchain_desc;
 395     struct wined3d_swapchain_state *state;
 396     struct dxgi_output *dxgi_output;
 397     HRESULT hr;
 398
 399     TRACE("iface %p, fullscreen %#x, target %p.\n", iface, fullscreen, target);
 400
 401     if (!fullscreen && target)
 402     {
 403         WARN("Invalid call.\n");
 404         return DXGI_ERROR_INVALID_CALL;
 405     }
 406
 407     if (target)
 408     {
 409         IDXGIOutput_AddRef(target);
 410     }
 411     else if (FAILED(hr = IDXGISwapChain1_GetContainingOutput(iface, &target)))
 412     {
 413         WARN("Failed to get target output for swapchain, hr %#x.\n", hr);
 414         return hr;
 415     }
 416     dxgi_output = unsafe_impl_from_IDXGIOutput(target);
 417
 418     wined3d_mutex_lock();
 419     state = wined3d_swapchain_get_state(swapchain->wined3d_swapchain);
 420     wined3d_swapchain_get_desc(swapchain->wined3d_swapchain, &swapchain_desc);
 421     swapchain_desc.output = dxgi_output->wined3d_output;
 422     swapchain_desc.windowed = !fullscreen;
 423     hr = wined3d_swapchain_state_set_fullscreen(state, &swapchain_desc, NULL);
 424     wined3d_mutex_unlock();
 425     if (FAILED(hr))
 426     {
 427         IDXGIOutput_Release(target);
 428
 429         return DXGI_ERROR_NOT_CURRENTLY_AVAILABLE;
 430     }
 431
 432     if (!fullscreen)
 433     {
 434         IDXGIOutput_Release(target);
 435         target = NULL;
 436     }
 437
 438     if (swapchain->target)
 439         IDXGIOutput_Release(swapchain->target);
 440     swapchain->target = target;
 441
 442     return S_OK;
 443 }
 444
 445 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_GetFullscreenState(IDXGISwapChain1 *iface,
 446         BOOL *fullscreen, IDXGIOutput **target)
 447 {
 448     struct d3d11_swapchain *swapchain = d3d11_swapchain_from_IDXGISwapChain1(iface);
 449     struct wined3d_swapchain_desc swapchain_desc;
 450     HRESULT hr;
 451
 452     TRACE("iface %p, fullscreen %p, target %p.\n", iface, fullscreen, target);
 453
 454     if (fullscreen || target)
 455     {
 456         wined3d_mutex_lock();
 457         wined3d_swapchain_get_desc(swapchain->wined3d_swapchain, &swapchain_desc);
 458         wined3d_mutex_unlock();
 459     }
 460
 461     if (fullscreen)
 462         *fullscreen = !swapchain_desc.windowed;
 463
 464     if (target)
 465     {
 466         if (!swapchain_desc.windowed)
 467         {
 468             if (!swapchain->target && FAILED(hr = IDXGISwapChain1_GetContainingOutput(iface, &swapchain->target)))
 469                 return hr;
 470
 471             *target = swapchain->target;
 472             IDXGIOutput_AddRef(*target);
 473         }
 474         else
 475         {
 476             *target = NULL;
 477         }
 478     }
 479
 480     return S_OK;
 481 }
 482
 483 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_GetDesc(IDXGISwapChain1 *iface, DXGI_SWAP_CHAIN_DESC *desc)
 484 {
 485     struct d3d11_swapchain *swapchain = d3d11_swapchain_from_IDXGISwapChain1(iface);
 486     struct wined3d_swapchain_desc wined3d_desc;
 487
 488     TRACE("iface %p, desc %p.\n", iface, desc);
 489
 490     if (!desc)
 491     {
 492         WARN("Invalid pointer.\n");
 493         return E_INVALIDARG;
 494     }
 495
 496     wined3d_mutex_lock();
 497     wined3d_swapchain_get_desc(swapchain->wined3d_swapchain, &wined3d_desc);
 498     wined3d_mutex_unlock();
 499
 500     FIXME("Ignoring ScanlineOrdering and Scaling.\n");
 501
 502     desc->BufferDesc.Width = wined3d_desc.backbuffer_width;
 503     desc->BufferDesc.Height = wined3d_desc.backbuffer_height;
 504     desc->BufferDesc.RefreshRate.Numerator = wined3d_desc.refresh_rate;
 505     desc->BufferDesc.RefreshRate.Denominator = 1;
 506     desc->BufferDesc.Format = dxgi_format_from_wined3dformat(wined3d_desc.backbuffer_format);
 507     desc->BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
 508     desc->BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
 509     dxgi_sample_desc_from_wined3d(&desc->SampleDesc,
 510             wined3d_desc.multisample_type, wined3d_desc.multisample_quality);
 511     desc->BufferUsage = dxgi_usage_from_wined3d_bind_flags(wined3d_desc.backbuffer_bind_flags);
 512     desc->BufferCount = wined3d_desc.backbuffer_count;
 513     desc->OutputWindow = wined3d_desc.device_window;
 514     desc->Windowed = wined3d_desc.windowed;
 515     desc->SwapEffect = dxgi_swap_effect_from_wined3d(wined3d_desc.swap_effect);
 516     desc->Flags = dxgi_swapchain_flags_from_wined3d(wined3d_desc.flags);
 517
 518     return S_OK;
 519 }
 520
 521 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_ResizeBuffers(IDXGISwapChain1 *iface,
 522         UINT buffer_count, UINT width, UINT height, DXGI_FORMAT format, UINT flags)
 523 {
 524     struct d3d11_swapchain *swapchain = d3d11_swapchain_from_IDXGISwapChain1(iface);
 525     struct wined3d_swapchain_desc wined3d_desc;
 526     struct wined3d_texture *texture;
 527     IUnknown *parent;
 528     unsigned int i;
 529     HRESULT hr;
 530
 531     TRACE("iface %p, buffer_count %u, width %u, height %u, format %s, flags %#x.\n",
 532             iface, buffer_count, width, height, debug_dxgi_format(format), flags);
 533
 534     if (flags)
 535         FIXME("Ignoring flags %#x.\n", flags);
 536
 537     wined3d_mutex_lock();
 538     wined3d_swapchain_get_desc(swapchain->wined3d_swapchain, &wined3d_desc);
 539     for (i = 0; i < wined3d_desc.backbuffer_count; ++i)
 540     {
 541         texture = wined3d_swapchain_get_back_buffer(swapchain->wined3d_swapchain, i);
 542         parent = wined3d_texture_get_parent(texture);
 543         IUnknown_AddRef(parent);
 544         if (IUnknown_Release(parent))
 545         {
 546             wined3d_mutex_unlock();
 547             return DXGI_ERROR_INVALID_CALL;
 548         }
 549     }
 550     if (format != DXGI_FORMAT_UNKNOWN)
 551         wined3d_desc.backbuffer_format = wined3dformat_from_dxgi_format(format);
 552     hr = wined3d_swapchain_resize_buffers(swapchain->wined3d_swapchain, buffer_count, width, height,
 553             wined3d_desc.backbuffer_format, wined3d_desc.multisample_type, wined3d_desc.multisample_quality);
 554     wined3d_mutex_unlock();
 555
 556     return hr;
 557 }
 558
 559 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_ResizeTarget(IDXGISwapChain1 *iface,
 560         const DXGI_MODE_DESC *target_mode_desc)
 561 {
 562     struct d3d11_swapchain *swapchain = d3d11_swapchain_from_IDXGISwapChain1(iface);
 563     struct wined3d_swapchain_state *state;
 564
 565     TRACE("iface %p, target_mode_desc %p.\n", iface, target_mode_desc);
 566
 567     state = wined3d_swapchain_get_state(swapchain->wined3d_swapchain);
 568
 569     return dxgi_swapchain_resize_target(state, target_mode_desc);
 570 }
 571
 572 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_GetContainingOutput(IDXGISwapChain1 *iface, IDXGIOutput **output)
 573 {
 574     struct d3d11_swapchain *swapchain = d3d11_swapchain_from_IDXGISwapChain1(iface);
 575     HWND window;
 576
 577     TRACE("iface %p, output %p.\n", iface, output);
 578
 579     if (swapchain->target)
 580     {
 581         IDXGIOutput_AddRef(*output = swapchain->target);
 582         return S_OK;
 583     }
 584
 585     if (!swapchain->factory)
 586     {
 587         ERR("Implicit swapchain does not store a reference to factory.\n");
 588         return E_NOINTERFACE;
 589     }
 590
 591     window = d3d11_swapchain_get_hwnd(swapchain);
 592     return dxgi_get_output_from_window(swapchain->factory, window, output);
 593 }
 594
 595 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_GetFrameStatistics(IDXGISwapChain1 *iface,
 596         DXGI_FRAME_STATISTICS *stats)
 597 {
 598     FIXME("iface %p, stats %p stub!\n", iface, stats);
 599
 600     return E_NOTIMPL;
 601 }
 602
 603 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_GetLastPresentCount(IDXGISwapChain1 *iface,
 604         UINT *last_present_count)
 605 {
 606     struct d3d11_swapchain *swapchain = d3d11_swapchain_from_IDXGISwapChain1(iface);
 607
 608     TRACE("iface %p, last_present_count %p.\n", iface, last_present_count);
 609
 610     *last_present_count =  swapchain->present_count;
 611
 612     return S_OK;
 613 }
 614
 615 /* IDXGISwapChain1 methods */
 616
 617 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_GetDesc1(IDXGISwapChain1 *iface, DXGI_SWAP_CHAIN_DESC1 *desc)
 618 {
 619     struct d3d11_swapchain *swapchain = d3d11_swapchain_from_IDXGISwapChain1(iface);
 620     struct wined3d_swapchain_desc wined3d_desc;
 621
 622     TRACE("iface %p, desc %p.\n", iface, desc);
 623
 624     if (!desc)
 625     {
 626         WARN("Invalid pointer.\n");
 627         return E_INVALIDARG;
 628     }
 629
 630     wined3d_mutex_lock();
 631     wined3d_swapchain_get_desc(swapchain->wined3d_swapchain, &wined3d_desc);
 632     wined3d_mutex_unlock();
 633
 634     FIXME("Ignoring Stereo, Scaling and AlphaMode.\n");
 635
 636     desc->Width = wined3d_desc.backbuffer_width;
 637     desc->Height = wined3d_desc.backbuffer_height;
 638     desc->Format = dxgi_format_from_wined3dformat(wined3d_desc.backbuffer_format);
 639     desc->Stereo = FALSE;
 640     dxgi_sample_desc_from_wined3d(&desc->SampleDesc,
 641             wined3d_desc.multisample_type, wined3d_desc.multisample_quality);
 642     desc->BufferUsage = dxgi_usage_from_wined3d_bind_flags(wined3d_desc.backbuffer_bind_flags);
 643     desc->BufferCount = wined3d_desc.backbuffer_count;
 644     desc->Scaling = DXGI_SCALING_STRETCH;
 645     desc->SwapEffect = dxgi_swap_effect_from_wined3d(wined3d_desc.swap_effect);
 646     desc->AlphaMode = DXGI_ALPHA_MODE_IGNORE;
 647     desc->Flags = dxgi_swapchain_flags_from_wined3d(wined3d_desc.flags);
 648
 649     return S_OK;
 650 }
 651
 652 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_GetFullscreenDesc(IDXGISwapChain1 *iface,
 653         DXGI_SWAP_CHAIN_FULLSCREEN_DESC *desc)
 654 {
 655     struct d3d11_swapchain *swapchain = d3d11_swapchain_from_IDXGISwapChain1(iface);
 656     struct wined3d_swapchain_desc wined3d_desc;
 657
 658     TRACE("iface %p, desc %p.\n", iface, desc);
 659
 660     if (!desc)
 661     {
 662         WARN("Invalid pointer.\n");
 663         return E_INVALIDARG;
 664     }
 665
 666     wined3d_mutex_lock();
 667     wined3d_swapchain_get_desc(swapchain->wined3d_swapchain, &wined3d_desc);
 668     wined3d_mutex_unlock();
 669
 670     FIXME("Ignoring ScanlineOrdering and Scaling.\n");
 671
 672     desc->RefreshRate.Numerator = wined3d_desc.refresh_rate;
 673     desc->RefreshRate.Denominator = 1;
 674     desc->ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
 675     desc->Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
 676     desc->Windowed = wined3d_desc.windowed;
 677
 678     return S_OK;
 679 }
 680
 681 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_GetHwnd(IDXGISwapChain1 *iface, HWND *hwnd)
 682 {
 683     struct d3d11_swapchain *swapchain = d3d11_swapchain_from_IDXGISwapChain1(iface);
 684
 685     TRACE("iface %p, hwnd %p.\n", iface, hwnd);
 686
 687     if (!hwnd)
 688     {
 689         WARN("Invalid pointer.\n");
 690         return DXGI_ERROR_INVALID_CALL;
 691     }
 692
 693     *hwnd = d3d11_swapchain_get_hwnd(swapchain);
 694     return S_OK;
 695 }
 696
 697 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_GetCoreWindow(IDXGISwapChain1 *iface,
 698         REFIID iid, void **core_window)
 699 {
 700     FIXME("iface %p, iid %s, core_window %p stub!\n", iface, debugstr_guid(iid), core_window);
 701
 702     if (core_window)
 703         *core_window = NULL;
 704
 705     return DXGI_ERROR_INVALID_CALL;
 706 }
 707
 708 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_Present1(IDXGISwapChain1 *iface,
 709         UINT sync_interval, UINT flags, const DXGI_PRESENT_PARAMETERS *present_parameters)
 710 {
 711     struct d3d11_swapchain *swapchain = d3d11_swapchain_from_IDXGISwapChain1(iface);
 712
 713     TRACE("iface %p, sync_interval %u, flags %#x, present_parameters %p.\n",
 714             iface, sync_interval, flags, present_parameters);
 715
 716     if (present_parameters)
 717         FIXME("Ignored present parameters %p.\n", present_parameters);
 718
 719     return d3d11_swapchain_present(swapchain, sync_interval, flags);
 720 }
 721
 722 static BOOL STDMETHODCALLTYPE d3d11_swapchain_IsTemporaryMonoSupported(IDXGISwapChain1 *iface)
 723 {
 724     FIXME("iface %p stub!\n", iface);
 725
 726     return FALSE;
 727 }
 728
 729 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_GetRestrictToOutput(IDXGISwapChain1 *iface, IDXGIOutput **output)
 730 {
 731     FIXME("iface %p, output %p stub!\n", iface, output);
 732
 733     if (!output)
 734     {
 735         WARN("Invalid pointer.\n");
 736         return E_INVALIDARG;
 737     }
 738
 739     *output = NULL;
 740     return E_NOTIMPL;
 741 }
 742
 743 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_SetBackgroundColor(IDXGISwapChain1 *iface, const DXGI_RGBA *color)
 744 {
 745     FIXME("iface %p, color %p stub!\n", iface, color);
 746
 747     return E_NOTIMPL;
 748 }
 749
 750 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_GetBackgroundColor(IDXGISwapChain1 *iface, DXGI_RGBA *color)
 751 {
 752     FIXME("iface %p, color %p stub!\n", iface, color);
 753
 754     return E_NOTIMPL;
 755 }
 756
 757 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_SetRotation(IDXGISwapChain1 *iface, DXGI_MODE_ROTATION rotation)
 758 {
 759     FIXME("iface %p, rotation %#x stub!\n", iface, rotation);
 760
 761     return E_NOTIMPL;
 762 }
 763
 764 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_GetRotation(IDXGISwapChain1 *iface, DXGI_MODE_ROTATION *rotation)
 765 {
 766     FIXME("iface %p, rotation %p stub!\n", iface, rotation);
 767
 768     return E_NOTIMPL;
 769 }
 770
 771 static const struct IDXGISwapChain1Vtbl d3d11_swapchain_vtbl =
 772 {
 773     /* IUnknown methods */
 774     d3d11_swapchain_QueryInterface,
 775     d3d11_swapchain_AddRef,
 776     d3d11_swapchain_Release,
 777     /* IDXGIObject methods */
 778     d3d11_swapchain_SetPrivateData,
 779     d3d11_swapchain_SetPrivateDataInterface,
 780     d3d11_swapchain_GetPrivateData,
 781     d3d11_swapchain_GetParent,
 782     /* IDXGIDeviceSubObject methods */
 783     d3d11_swapchain_GetDevice,
 784     /* IDXGISwapChain methods */
 785     d3d11_swapchain_Present,
 786     d3d11_swapchain_GetBuffer,
 787     d3d11_swapchain_SetFullscreenState,
 788     d3d11_swapchain_GetFullscreenState,
 789     d3d11_swapchain_GetDesc,
 790     d3d11_swapchain_ResizeBuffers,
 791     d3d11_swapchain_ResizeTarget,
 792     d3d11_swapchain_GetContainingOutput,
 793     d3d11_swapchain_GetFrameStatistics,
 794     d3d11_swapchain_GetLastPresentCount,
 795     /* IDXGISwapChain1 methods */
 796     d3d11_swapchain_GetDesc1,
 797     d3d11_swapchain_GetFullscreenDesc,
 798     d3d11_swapchain_GetHwnd,
 799     d3d11_swapchain_GetCoreWindow,
 800     d3d11_swapchain_Present1,
 801     d3d11_swapchain_IsTemporaryMonoSupported,
 802     d3d11_swapchain_GetRestrictToOutput,
 803     d3d11_swapchain_SetBackgroundColor,
 804     d3d11_swapchain_GetBackgroundColor,
 805     d3d11_swapchain_SetRotation,
 806     d3d11_swapchain_GetRotation,
 807 };
 808
 809 static void STDMETHODCALLTYPE d3d11_swapchain_wined3d_object_released(void *parent)
 810 {
 811     struct d3d11_swapchain *swapchain = parent;
 812
 813     wined3d_private_store_cleanup(&swapchain->private_store);
 814     heap_free(parent);
 815 }
 816
 817 static const struct wined3d_parent_ops d3d11_swapchain_wined3d_parent_ops =
 818 {
 819     d3d11_swapchain_wined3d_object_released,
 820 };
 821
 822 static inline struct d3d11_swapchain *d3d11_swapchain_from_wined3d_swapchain_state_parent(struct wined3d_swapchain_state_parent *parent)
 823 {
 824     return CONTAINING_RECORD(parent, struct d3d11_swapchain, state_parent);
 825 }
 826
 827 static void CDECL d3d11_swapchain_windowed_state_changed(struct wined3d_swapchain_state_parent *parent,
 828         BOOL windowed)
 829 {
 830     struct d3d11_swapchain *swapchain = d3d11_swapchain_from_wined3d_swapchain_state_parent(parent);
 831
 832     TRACE("parent %p, windowed %d.\n", parent, windowed);
 833
 834     if (windowed && swapchain->target)
 835     {
 836         IDXGIOutput_Release(swapchain->target);
 837         swapchain->target = NULL;
 838     }
 839 }
 840
 841 static const struct wined3d_swapchain_state_parent_ops d3d11_swapchain_state_parent_ops =
 842 {
 843     d3d11_swapchain_windowed_state_changed,
 844 };
 845
 846 HRESULT d3d11_swapchain_init(struct d3d11_swapchain *swapchain, struct dxgi_device *device,
 847         struct wined3d_swapchain_desc *desc)
 848 {
 849     BOOL fullscreen;
 850     HRESULT hr;
 851
 852     /* A reference to the implicit swapchain is held by the wined3d device. In
 853      * order to avoid circular references we do not keep a reference to the
 854      * device in the implicit swapchain. */
 855     if (!(desc->flags & WINED3D_SWAPCHAIN_IMPLICIT))
 856     {
 857         if (desc->backbuffer_format == WINED3DFMT_UNKNOWN)
 858             return E_INVALIDARG;
 859
 860         if (FAILED(hr = IWineDXGIAdapter_GetParent(device->adapter,
 861                 &IID_IWineDXGIFactory, (void **)&swapchain->factory)))
 862         {
 863             WARN("Failed to get adapter parent, hr %#x.\n", hr);
 864             return hr;
 865         }
 866         IWineDXGIDevice_AddRef(swapchain->device = &device->IWineDXGIDevice_iface);
 867     }
 868     else
 869     {
 870         swapchain->device = NULL;
 871         swapchain->factory = NULL;
 872     }
 873
 874     swapchain->IDXGISwapChain1_iface.lpVtbl = &d3d11_swapchain_vtbl;
 875     swapchain->state_parent.ops = &d3d11_swapchain_state_parent_ops;
 876     swapchain->refcount = 1;
 877     wined3d_mutex_lock();
 878     wined3d_private_store_init(&swapchain->private_store);
 879
 880     if (!desc->windowed && (!desc->backbuffer_width || !desc->backbuffer_height))
 881         FIXME("Fullscreen swapchain with back buffer width/height equal to 0 not supported properly.\n");
 882
 883     fullscreen = !desc->windowed;
 884     desc->windowed = TRUE;
 885     if (FAILED(hr = wined3d_swapchain_create(device->wined3d_device, desc, &swapchain->state_parent,
 886             swapchain, &d3d11_swapchain_wined3d_parent_ops, &swapchain->wined3d_swapchain)))
 887     {
 888         WARN("Failed to create wined3d swapchain, hr %#x.\n", hr);
 889         goto cleanup;
 890     }
 891
 892     swapchain->target = NULL;
 893     if (fullscreen)
 894     {
 895         struct wined3d_swapchain_state *state;
 896
 897         desc->windowed = FALSE;
 898         state = wined3d_swapchain_get_state(swapchain->wined3d_swapchain);
 899
 900         if (FAILED(hr = IDXGISwapChain1_GetContainingOutput(&swapchain->IDXGISwapChain1_iface,
 901                 &swapchain->target)))
 902         {
 903             WARN("Failed to get target output for fullscreen swapchain, hr %#x.\n", hr);
 904             wined3d_swapchain_decref(swapchain->wined3d_swapchain);
 905             goto cleanup;
 906         }
 907
 908         if (FAILED(hr = wined3d_swapchain_state_set_fullscreen(state, desc, NULL)))
 909         {
 910             WARN("Failed to set fullscreen state, hr %#x.\n", hr);
 911             IDXGIOutput_Release(swapchain->target);
 912             wined3d_swapchain_decref(swapchain->wined3d_swapchain);
 913             goto cleanup;
 914         }
 915
 916     }
 917     wined3d_mutex_unlock();
 918
 919     return S_OK;
 920
 921 cleanup:
 922     wined3d_private_store_cleanup(&swapchain->private_store);
 923     wined3d_mutex_unlock();
 924     if (swapchain->factory)
 925         IWineDXGIFactory_Release(swapchain->factory);
 926     if (swapchain->device)
 927         IWineDXGIDevice_Release(swapchain->device);
 928     return hr;
 929 }
 930
 931 #ifdef SONAME_LIBVKD3D
 932
 933 #ifdef USE_WIN32_VULKAN
 934
 935 static void *load_library(const char *name)
 936 {
 937     return LoadLibraryA(name);
 938 }
 939
 940 static void *get_library_proc(void *handle, const char *name)
 941 {
 942     return (void *)GetProcAddress(handle, name);
 943 }
 944
 945 static void close_library(void *handle)
 946 {
 947     if (handle)
 948         FreeLibrary(handle);
 949 }
 950
 951 static PFN_vkGetInstanceProcAddr load_vulkan(void **vulkan_handle)
 952 {
 953     *vulkan_handle = LoadLibraryA("vulkan-1.dll");
 954     return (void *)GetProcAddress(*vulkan_handle, "vkGetInstanceProcAddr");
 955 }
 956
 957 #else
 958
 959 static void *load_library(const char *name)
 960 {
 961     return dlopen(name, RTLD_NOW);
 962 }
 963
 964 static void *get_library_proc(void *handle, const char *name)
 965 {
 966     return dlsym(handle, name);
 967 }
 968
 969 static void close_library(void *handle)
 970 {
 971     if (handle)
 972         dlclose(handle);
 973 }
 974
 975 static PFN_vkGetInstanceProcAddr load_vulkan(void **vulkan_handle)
 976 {
 977     const struct vulkan_funcs *vk_funcs;
 978     HDC hdc;
 979
 980     *vulkan_handle = NULL;
 981
 982     hdc = GetDC(0);
 983     vk_funcs = __wine_get_vulkan_driver(hdc, WINE_VULKAN_DRIVER_VERSION);
 984     ReleaseDC(0, hdc);
 985
 986     if (vk_funcs)
 987         return (PFN_vkGetInstanceProcAddr)vk_funcs->p_vkGetInstanceProcAddr;
 988
 989     return NULL;
 990 }
 991
 992 #endif  /* USE_WIN32_VULKAN */
 993
 994 static PFN_vkd3d_acquire_vk_queue vkd3d_acquire_vk_queue;
 995 static PFN_vkd3d_create_image_resource vkd3d_create_image_resource;
 996 static PFN_vkd3d_get_device_parent vkd3d_get_device_parent;
 997 static PFN_vkd3d_get_vk_device vkd3d_get_vk_device;
 998 static PFN_vkd3d_get_vk_format vkd3d_get_vk_format;
 999 static PFN_vkd3d_get_vk_physical_device vkd3d_get_vk_physical_device;
1000 static PFN_vkd3d_get_vk_queue_family_index vkd3d_get_vk_queue_family_index;
1001 static PFN_vkd3d_instance_from_device vkd3d_instance_from_device;
1002 static PFN_vkd3d_instance_get_vk_instance vkd3d_instance_get_vk_instance;
1003 static PFN_vkd3d_release_vk_queue vkd3d_release_vk_queue;
1004 static PFN_vkd3d_resource_decref vkd3d_resource_decref;
1005 static PFN_vkd3d_resource_incref vkd3d_resource_incref;
1006
1007 struct dxgi_vk_funcs
1008 {
1009     PFN_vkAcquireNextImageKHR p_vkAcquireNextImageKHR;
1010     PFN_vkAllocateCommandBuffers p_vkAllocateCommandBuffers;
1011     PFN_vkAllocateMemory p_vkAllocateMemory;
1012     PFN_vkBeginCommandBuffer p_vkBeginCommandBuffer;
1013     PFN_vkBindImageMemory p_vkBindImageMemory;
1014     PFN_vkCmdBlitImage p_vkCmdBlitImage;
1015     PFN_vkCmdPipelineBarrier p_vkCmdPipelineBarrier;
1016     PFN_vkCreateCommandPool p_vkCreateCommandPool;
1017     PFN_vkCreateFence p_vkCreateFence;
1018     PFN_vkCreateImage p_vkCreateImage;
1019     PFN_vkCreateSemaphore p_vkCreateSemaphore;
1020     PFN_vkCreateSwapchainKHR p_vkCreateSwapchainKHR;
1021     PFN_vkCreateWin32SurfaceKHR p_vkCreateWin32SurfaceKHR;
1022     PFN_vkDestroyCommandPool p_vkDestroyCommandPool;
1023     PFN_vkDestroyFence p_vkDestroyFence;
1024     PFN_vkDestroyImage p_vkDestroyImage;
1025     PFN_vkDestroySemaphore p_vkDestroySemaphore;
1026     PFN_vkDestroySurfaceKHR p_vkDestroySurfaceKHR;
1027     PFN_vkResetCommandBuffer p_vkResetCommandBuffer;
1028     PFN_vkDestroySwapchainKHR p_vkDestroySwapchainKHR;
1029     PFN_vkEndCommandBuffer p_vkEndCommandBuffer;
1030     PFN_vkFreeMemory p_vkFreeMemory;
1031     PFN_vkGetImageMemoryRequirements p_vkGetImageMemoryRequirements;
1032     PFN_vkGetInstanceProcAddr p_vkGetInstanceProcAddr;
1033     PFN_vkGetPhysicalDeviceMemoryProperties p_vkGetPhysicalDeviceMemoryProperties;
1034     PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR p_vkGetPhysicalDeviceSurfaceCapabilitiesKHR;
1035     PFN_vkGetPhysicalDeviceSurfaceFormatsKHR p_vkGetPhysicalDeviceSurfaceFormatsKHR;
1036     PFN_vkGetPhysicalDeviceSurfacePresentModesKHR p_vkGetPhysicalDeviceSurfacePresentModesKHR;
1037     PFN_vkGetPhysicalDeviceSurfaceSupportKHR p_vkGetPhysicalDeviceSurfaceSupportKHR;
1038     PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR p_vkGetPhysicalDeviceWin32PresentationSupportKHR;
1039     PFN_vkGetSwapchainImagesKHR p_vkGetSwapchainImagesKHR;
1040     PFN_vkQueuePresentKHR p_vkQueuePresentKHR;
1041     PFN_vkQueueSubmit p_vkQueueSubmit;
1042     PFN_vkQueueWaitIdle p_vkQueueWaitIdle;
1043     PFN_vkResetFences p_vkResetFences;
1044     PFN_vkWaitForFences p_vkWaitForFences;
1045
1046     void *vulkan_module;
1047 };
1048
1049 static HRESULT hresult_from_vk_result(VkResult vr)
1050 {
1051     switch (vr)
1052     {
1053         case VK_SUCCESS:
1054             return S_OK;
1055         case VK_ERROR_OUT_OF_HOST_MEMORY:
1056         case VK_ERROR_OUT_OF_DEVICE_MEMORY:
1057             return E_OUTOFMEMORY;
1058         default:
1059             FIXME("Unhandled VkResult %d.\n", vr);
1060             return E_FAIL;
1061     }
1062 }
1063
1064 #define INVALID_VK_IMAGE_INDEX (~(uint32_t)0)
1065
1066 struct d3d12_swapchain
1067 {
1068     IDXGISwapChain4 IDXGISwapChain4_iface;
1069     LONG refcount;
1070     struct wined3d_private_store private_store;
1071
1072     struct wined3d_swapchain_state *state;
1073     struct wined3d_swapchain_state_parent state_parent;
1074
1075     VkSwapchainKHR vk_swapchain;
1076     VkSurfaceKHR vk_surface;
1077     VkFence vk_fence;
1078     VkInstance vk_instance;
1079     VkDevice vk_device;
1080     VkPhysicalDevice vk_physical_device;
1081     VkDeviceMemory vk_memory;
1082     VkCommandPool vk_cmd_pool;
1083     VkImage vk_images[DXGI_MAX_SWAP_CHAIN_BUFFERS];
1084     VkImage vk_swapchain_images[DXGI_MAX_SWAP_CHAIN_BUFFERS];
1085     VkCommandBuffer vk_cmd_buffers[DXGI_MAX_SWAP_CHAIN_BUFFERS];
1086     VkSemaphore vk_semaphores[DXGI_MAX_SWAP_CHAIN_BUFFERS];
1087     ID3D12Resource *buffers[DXGI_MAX_SWAP_CHAIN_BUFFERS];
1088     unsigned int buffer_count;
1089     unsigned int vk_swapchain_width;
1090     unsigned int vk_swapchain_height;
1091     VkPresentModeKHR present_mode;
1092
1093     uint32_t vk_image_index;
1094     unsigned int current_buffer_index;
1095     struct dxgi_vk_funcs vk_funcs;
1096
1097     ID3D12CommandQueue *command_queue;
1098     ID3D12Device *device;
1099     IWineDXGIFactory *factory;
1100
1101     HWND window;
1102     IDXGIOutput *target;
1103     DXGI_SWAP_CHAIN_DESC1 desc;
1104     DXGI_SWAP_CHAIN_FULLSCREEN_DESC fullscreen_desc;
1105
1106     ID3D12Fence *frame_latency_fence;
1107     HANDLE frame_latency_event;
1108
1109     uint64_t frame_number;
1110     uint32_t frame_latency;
1111 };
1112
1113 static DXGI_FORMAT dxgi_format_from_vk_format(VkFormat vk_format)
1114 {
1115     switch (vk_format)
1116     {
1117         case VK_FORMAT_B8G8R8A8_UNORM: return DXGI_FORMAT_B8G8R8A8_UNORM;
1118         case VK_FORMAT_R8G8B8A8_UNORM: return DXGI_FORMAT_R8G8B8A8_UNORM;
1119         case VK_FORMAT_A2B10G10R10_UNORM_PACK32: return DXGI_FORMAT_R10G10B10A2_UNORM;
1120         case VK_FORMAT_R16G16B16A16_SFLOAT: return DXGI_FORMAT_R16G16B16A16_FLOAT;
1121         default:
1122             WARN("Unhandled format %#x.\n", vk_format);
1123             return DXGI_FORMAT_UNKNOWN;
1124     }
1125 }
1126
1127 static VkFormat get_swapchain_fallback_format(VkFormat vk_format)
1128 {
1129     switch (vk_format)
1130     {
1131         case VK_FORMAT_R8G8B8A8_UNORM:
1132         case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
1133         case VK_FORMAT_R16G16B16A16_SFLOAT:
1134             return VK_FORMAT_B8G8R8A8_UNORM;
1135         default:
1136             WARN("Unhandled format %#x.\n", vk_format);
1137             return VK_FORMAT_UNDEFINED;
1138     }
1139 }
1140
1141 static HRESULT select_vk_format(const struct dxgi_vk_funcs *vk_funcs,
1142         VkPhysicalDevice vk_physical_device, VkSurfaceKHR vk_surface,
1143         const DXGI_SWAP_CHAIN_DESC1 *swapchain_desc, VkFormat *vk_format)
1144 {
1145     VkSurfaceFormatKHR *formats;
1146     uint32_t format_count;
1147     VkFormat format;
1148     unsigned int i;
1149     VkResult vr;
1150
1151     *vk_format = VK_FORMAT_UNDEFINED;
1152
1153     format = vkd3d_get_vk_format(swapchain_desc->Format);
1154
1155     vr = vk_funcs->p_vkGetPhysicalDeviceSurfaceFormatsKHR(vk_physical_device, vk_surface, &format_count, NULL);
1156     if (vr < 0 || !format_count)
1157     {
1158         WARN("Failed to get supported surface formats, vr %d.\n", vr);
1159         return DXGI_ERROR_INVALID_CALL;
1160     }
1161
1162     if (!(formats = heap_calloc(format_count, sizeof(*formats))))
1163         return E_OUTOFMEMORY;
1164
1165     if ((vr = vk_funcs->p_vkGetPhysicalDeviceSurfaceFormatsKHR(vk_physical_device,
1166             vk_surface, &format_count, formats)) < 0)
1167     {
1168         WARN("Failed to enumerate supported surface formats, vr %d.\n", vr);
1169         heap_free(formats);
1170         return hresult_from_vk_result(vr);
1171     }
1172
1173     for (i = 0; i < format_count; ++i)
1174     {
1175         if (formats[i].format == format && formats[i].colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR)
1176             break;
1177     }
1178     if (i == format_count)
1179     {
1180         /* Try to create a swapchain with format conversion. */
1181         format = get_swapchain_fallback_format(format);
1182         WARN("Failed to find Vulkan swapchain format for %s.\n", debug_dxgi_format(swapchain_desc->Format));
1183         for (i = 0; i < format_count; ++i)
1184         {
1185             if (formats[i].format == format && formats[i].colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR)
1186             {
1187                 format = formats[i].format;
1188                 break;
1189             }
1190         }
1191     }
1192     heap_free(formats);
1193     if (i == format_count)
1194     {
1195         FIXME("Failed to find Vulkan swapchain format for %s.\n", debug_dxgi_format(swapchain_desc->Format));
1196         return DXGI_ERROR_UNSUPPORTED;
1197     }
1198
1199     TRACE("Using Vulkan swapchain format %#x.\n", format);
1200
1201     *vk_format = format;
1202     return S_OK;
1203 }
1204
1205 static HRESULT vk_select_memory_type(const struct dxgi_vk_funcs *vk_funcs,
1206         VkPhysicalDevice vk_physical_device, uint32_t memory_type_mask,
1207         VkMemoryPropertyFlags flags, uint32_t *memory_type_index)
1208 {
1209     VkPhysicalDeviceMemoryProperties memory_properties;
1210     unsigned int i;
1211
1212     vk_funcs->p_vkGetPhysicalDeviceMemoryProperties(vk_physical_device, &memory_properties);
1213     for (i = 0; i < memory_properties.memoryTypeCount; ++i)
1214     {
1215         if (!(memory_type_mask & (1u << i)))
1216             continue;
1217
1218         if ((memory_properties.memoryTypes[i].propertyFlags & flags) == flags)
1219         {
1220             *memory_type_index = i;
1221             return S_OK;
1222         }
1223     }
1224
1225     FIXME("Failed to find memory type (allowed types %#x).\n", memory_type_mask);
1226     return E_FAIL;
1227 }
1228
1229 static BOOL d3d12_swapchain_is_present_mode_supported(struct d3d12_swapchain *swapchain,
1230         VkPresentModeKHR present_mode)
1231 {
1232     VkPhysicalDevice vk_physical_device = swapchain->vk_physical_device;
1233     const struct dxgi_vk_funcs *vk_funcs = &swapchain->vk_funcs;
1234     VkPresentModeKHR *modes;
1235     uint32_t count, i;
1236     BOOL supported;
1237     VkResult vr;
1238
1239     if (present_mode == VK_PRESENT_MODE_FIFO_KHR)
1240         return TRUE;
1241
1242     if ((vr = vk_funcs->p_vkGetPhysicalDeviceSurfacePresentModesKHR(vk_physical_device,
1243             swapchain->vk_surface, &count, NULL)) < 0)
1244     {
1245         WARN("Failed to get count of available present modes, vr %d.\n", vr);
1246         return FALSE;
1247     }
1248
1249     supported = FALSE;
1250
1251     if (!(modes = heap_calloc(count, sizeof(*modes))))
1252         return FALSE;
1253     if ((vr = vk_funcs->p_vkGetPhysicalDeviceSurfacePresentModesKHR(vk_physical_device,
1254             swapchain->vk_surface, &count, modes)) >= 0)
1255     {
1256         for (i = 0; i < count; ++i)
1257         {
1258             if (modes[i] == present_mode)
1259             {
1260                 supported = TRUE;
1261                 break;
1262             }
1263         }
1264     }
1265     else
1266     {
1267         WARN("Failed to get available present modes, vr %d.\n", vr);
1268     }
1269     heap_free(modes);
1270
1271     return supported;
1272 }
1273
1274 static BOOL d3d12_swapchain_has_user_images(struct d3d12_swapchain *swapchain)
1275 {
1276     return !!swapchain->vk_images[0];
1277 }
1278
1279 static HRESULT d3d12_swapchain_create_user_buffers(struct d3d12_swapchain *swapchain, VkFormat vk_format)
1280 {
1281     const struct dxgi_vk_funcs *vk_funcs = &swapchain->vk_funcs;
1282     VkDeviceSize image_offset[DXGI_MAX_SWAP_CHAIN_BUFFERS];
1283     VkDevice vk_device = swapchain->vk_device;
1284     VkMemoryAllocateInfo allocate_info;
1285     VkMemoryRequirements requirements;
1286     VkImageCreateInfo image_info;
1287     uint32_t memory_type_mask;
1288     VkDeviceSize memory_size;
1289     unsigned int i;
1290     VkResult vr;
1291     HRESULT hr;
1292
1293     if (d3d12_swapchain_has_user_images(swapchain))
1294         return S_OK;
1295
1296     memset(&image_info, 0, sizeof(image_info));
1297     image_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
1298     image_info.flags = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
1299     image_info.imageType = VK_IMAGE_TYPE_2D;
1300     image_info.format = vk_format;
1301     image_info.extent.width = swapchain->desc.Width;
1302     image_info.extent.height = swapchain->desc.Height;
1303     image_info.extent.depth = 1;
1304     image_info.mipLevels = 1;
1305     image_info.arrayLayers = 1;
1306     image_info.samples = VK_SAMPLE_COUNT_1_BIT;
1307     image_info.tiling = VK_IMAGE_TILING_OPTIMAL;
1308     image_info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT
1309             | VK_IMAGE_USAGE_TRANSFER_DST_BIT
1310             | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
1311     image_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
1312     image_info.queueFamilyIndexCount = 0;
1313     image_info.pQueueFamilyIndices = NULL;
1314     image_info.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
1315
1316     for (i = 0; i < swapchain->desc.BufferCount; ++i)
1317     {
1318         assert(swapchain->vk_images[i] == VK_NULL_HANDLE);
1319         if ((vr = vk_funcs->p_vkCreateImage(vk_device, &image_info, NULL, &swapchain->vk_images[i])) < 0)
1320         {
1321             WARN("Failed to create Vulkan image, vr %d.\n", vr);
1322             swapchain->vk_images[i] = VK_NULL_HANDLE;
1323             return hresult_from_vk_result(vr);
1324         }
1325     }
1326
1327     memory_size = 0;
1328     memory_type_mask = ~0u;
1329     for (i = 0; i < swapchain->desc.BufferCount; ++i)
1330     {
1331         vk_funcs->p_vkGetImageMemoryRequirements(vk_device, swapchain->vk_images[i], &requirements);
1332
1333         TRACE("Size %s, alignment %s, memory types %#x.\n",
1334                 wine_dbgstr_longlong(requirements.size), wine_dbgstr_longlong(requirements.alignment),
1335                 requirements.memoryTypeBits);
1336
1337         image_offset[i] = (memory_size + (requirements.alignment - 1)) & ~(requirements.alignment - 1);
1338         memory_size = image_offset[i] + requirements.size;
1339
1340         memory_type_mask &= requirements.memoryTypeBits;
1341     }
1342
1343     TRACE("Allocating %s bytes for user images.\n", wine_dbgstr_longlong(memory_size));
1344
1345     allocate_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
1346     allocate_info.pNext = NULL;
1347     allocate_info.allocationSize = memory_size;
1348
1349     if (FAILED(hr = vk_select_memory_type(vk_funcs, swapchain->vk_physical_device,
1350             memory_type_mask, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, &allocate_info.memoryTypeIndex)))
1351         return hr;
1352
1353     assert(swapchain->vk_memory == VK_NULL_HANDLE);
1354     if ((vr = vk_funcs->p_vkAllocateMemory(vk_device, &allocate_info, NULL, &swapchain->vk_memory)) < 0)
1355     {
1356         WARN("Failed to allocate device memory, vr %d.\n", vr);
1357         swapchain->vk_memory = VK_NULL_HANDLE;
1358         return hresult_from_vk_result(vr);
1359     }
1360
1361     for (i = 0; i < swapchain->desc.BufferCount; ++i)
1362     {
1363         if ((vr = vk_funcs->p_vkBindImageMemory(vk_device, swapchain->vk_images[i],
1364                 swapchain->vk_memory, image_offset[i])) < 0)
1365         {
1366             WARN("Failed to bind image memory, vr %d.\n", vr);
1367             return hresult_from_vk_result(vr);
1368         }
1369     }
1370
1371     return S_OK;
1372 }
1373
1374 static void vk_cmd_image_barrier(const struct dxgi_vk_funcs *vk_funcs, VkCommandBuffer cmd_buffer,
1375         VkPipelineStageFlags src_stage_mask, VkPipelineStageFlags dst_stage_mask,
1376         VkAccessFlags src_access_mask, VkAccessFlags dst_access_mask,
1377         VkImageLayout old_layout, VkImageLayout new_layout, VkImage image)
1378 {
1379     VkImageMemoryBarrier barrier;
1380
1381     barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
1382     barrier.pNext = NULL;
1383     barrier.srcAccessMask = src_access_mask;
1384     barrier.dstAccessMask = dst_access_mask;
1385     barrier.oldLayout = old_layout;
1386     barrier.newLayout = new_layout;
1387     barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
1388     barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
1389     barrier.image = image;
1390     barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
1391     barrier.subresourceRange.baseMipLevel = 0;
1392     barrier.subresourceRange.levelCount = VK_REMAINING_MIP_LEVELS;
1393     barrier.subresourceRange.baseArrayLayer = 0;
1394     barrier.subresourceRange.layerCount = VK_REMAINING_ARRAY_LAYERS;
1395
1396     vk_funcs->p_vkCmdPipelineBarrier(cmd_buffer,
1397             src_stage_mask, dst_stage_mask, 0, 0, NULL, 0, NULL, 1, &barrier);
1398 }
1399
1400 static VkResult d3d12_swapchain_record_swapchain_blit(struct d3d12_swapchain *swapchain,
1401         VkCommandBuffer vk_cmd_buffer, VkImage vk_dst_image, VkImage vk_src_image)
1402 {
1403     const struct dxgi_vk_funcs *vk_funcs = &swapchain->vk_funcs;
1404     VkCommandBufferBeginInfo begin_info;
1405     VkImageBlit blit;
1406     VkFilter filter;
1407     VkResult vr;
1408
1409     if (swapchain->desc.Width != swapchain->vk_swapchain_width
1410             || swapchain->desc.Height != swapchain->vk_swapchain_height)
1411         filter = VK_FILTER_LINEAR;
1412     else
1413         filter = VK_FILTER_NEAREST;
1414
1415     begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
1416     begin_info.pNext = NULL;
1417     begin_info.flags = 0;
1418     begin_info.pInheritanceInfo = NULL;
1419
1420     if ((vr = vk_funcs->p_vkBeginCommandBuffer(vk_cmd_buffer, &begin_info)) < 0)
1421     {
1422         WARN("Failed to begin command buffer, vr %d.\n", vr);
1423         return vr;
1424     }
1425
1426     vk_cmd_image_barrier(vk_funcs, vk_cmd_buffer,
1427             VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
1428             0, VK_ACCESS_TRANSFER_WRITE_BIT,
1429             VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, vk_dst_image);
1430
1431     blit.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
1432     blit.srcSubresource.mipLevel = 0;
1433     blit.srcSubresource.baseArrayLayer = 0;
1434     blit.srcSubresource.layerCount = 1;
1435     blit.srcOffsets[0].x = 0;
1436     blit.srcOffsets[0].y = 0;
1437     blit.srcOffsets[0].z = 0;
1438     blit.srcOffsets[1].x = swapchain->desc.Width;
1439     blit.srcOffsets[1].y = swapchain->desc.Height;
1440     blit.srcOffsets[1].z = 1;
1441     blit.dstSubresource = blit.srcSubresource;
1442     blit.dstOffsets[0].x = 0;
1443     blit.dstOffsets[0].y = 0;
1444     blit.dstOffsets[0].z = 0;
1445     if (swapchain->desc.Scaling == DXGI_SCALING_NONE)
1446     {
1447         blit.srcOffsets[1].x = min(swapchain->vk_swapchain_width, blit.srcOffsets[1].x);
1448         blit.srcOffsets[1].y = min(swapchain->vk_swapchain_height, blit.srcOffsets[1].y);
1449         blit.dstOffsets[1].x = blit.srcOffsets[1].x;
1450         blit.dstOffsets[1].y = blit.srcOffsets[1].y;
1451     }
1452     else
1453     {
1454         /* FIXME: handle DXGI_SCALING_ASPECT_RATIO_STRETCH. */
1455         blit.dstOffsets[1].x = swapchain->vk_swapchain_width;
1456         blit.dstOffsets[1].y = swapchain->vk_swapchain_height;
1457     }
1458     blit.dstOffsets[1].z = 1;
1459
1460     vk_funcs->p_vkCmdBlitImage(vk_cmd_buffer,
1461             vk_src_image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
1462             vk_dst_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
1463             1, &blit, filter);
1464
1465     vk_cmd_image_barrier(vk_funcs, vk_cmd_buffer,
1466             VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
1467             VK_ACCESS_TRANSFER_WRITE_BIT, 0,
1468             VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, vk_dst_image);
1469
1470     if ((vr = vk_funcs->p_vkEndCommandBuffer(vk_cmd_buffer)) < 0)
1471         WARN("Failed to end command buffer, vr %d.\n", vr);
1472
1473     return vr;
1474 }
1475
1476 static HRESULT d3d12_swapchain_prepare_command_buffers(struct d3d12_swapchain *swapchain,
1477         uint32_t queue_family_index)
1478 {
1479     const struct dxgi_vk_funcs *vk_funcs = &swapchain->vk_funcs;
1480     VkDevice vk_device = swapchain->vk_device;
1481     VkCommandBufferAllocateInfo allocate_info;
1482     VkSemaphoreCreateInfo semaphore_info;
1483     VkCommandPoolCreateInfo pool_info;
1484     unsigned int i;
1485     VkResult vr;
1486
1487     pool_info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
1488     pool_info.pNext = NULL;
1489     pool_info.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
1490     pool_info.queueFamilyIndex = queue_family_index;
1491
1492     assert(swapchain->vk_cmd_pool == VK_NULL_HANDLE);
1493     if ((vr = vk_funcs->p_vkCreateCommandPool(vk_device, &pool_info,
1494             NULL, &swapchain->vk_cmd_pool)) < 0)
1495     {
1496         WARN("Failed to create command pool, vr %d.\n", vr);
1497         swapchain->vk_cmd_pool = VK_NULL_HANDLE;
1498         return hresult_from_vk_result(vr);
1499     }
1500
1501     allocate_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
1502     allocate_info.pNext = NULL;
1503     allocate_info.commandPool = swapchain->vk_cmd_pool;
1504     allocate_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
1505     allocate_info.commandBufferCount = swapchain->buffer_count;
1506
1507     if ((vr = vk_funcs->p_vkAllocateCommandBuffers(vk_device, &allocate_info,
1508             swapchain->vk_cmd_buffers)) < 0)
1509     {
1510         WARN("Failed to allocate command buffers, vr %d.\n", vr);
1511         return hresult_from_vk_result(vr);
1512     }
1513
1514     for (i = 0; i < swapchain->buffer_count; ++i)
1515     {
1516         semaphore_info.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
1517         semaphore_info.pNext = NULL;
1518         semaphore_info.flags = 0;
1519
1520         assert(swapchain->vk_semaphores[i] == VK_NULL_HANDLE);
1521         if ((vr = vk_funcs->p_vkCreateSemaphore(vk_device, &semaphore_info,
1522                 NULL, &swapchain->vk_semaphores[i])) < 0)
1523         {
1524             WARN("Failed to create semaphore, vr %d.\n", vr);
1525             swapchain->vk_semaphores[i] = VK_NULL_HANDLE;
1526             return hresult_from_vk_result(vr);
1527         }
1528     }
1529
1530     return S_OK;
1531 }
1532
1533 static HRESULT d3d12_swapchain_create_buffers(struct d3d12_swapchain *swapchain,
1534         VkFormat vk_swapchain_format, VkFormat vk_format)
1535 {
1536     const struct dxgi_vk_funcs *vk_funcs = &swapchain->vk_funcs;
1537     struct vkd3d_image_resource_create_info resource_info;
1538     VkSwapchainKHR vk_swapchain = swapchain->vk_swapchain;
1539     ID3D12CommandQueue *queue = swapchain->command_queue;
1540     VkDevice vk_device = swapchain->vk_device;
1541     ID3D12Device *device = swapchain->device;
1542     uint32_t image_count, queue_family_index;
1543     D3D12_COMMAND_QUEUE_DESC queue_desc;
1544     unsigned int i;
1545     VkResult vr;
1546     HRESULT hr;
1547
1548     if ((vr = vk_funcs->p_vkGetSwapchainImagesKHR(vk_device, vk_swapchain, &image_count, NULL)) < 0)
1549     {
1550         WARN("Failed to get Vulkan swapchain images, vr %d.\n", vr);
1551         return hresult_from_vk_result(vr);
1552     }
1553     if (image_count > ARRAY_SIZE(swapchain->vk_swapchain_images))
1554     {
1555         FIXME("Unsupported Vulkan swapchain image count %u.\n", image_count);
1556         return E_FAIL;
1557     }
1558     swapchain->buffer_count = image_count;
1559     if ((vr = vk_funcs->p_vkGetSwapchainImagesKHR(vk_device, vk_swapchain,
1560             &image_count, swapchain->vk_swapchain_images)) < 0)
1561     {
1562         WARN("Failed to get Vulkan swapchain images, vr %d.\n", vr);
1563         return hresult_from_vk_result(vr);
1564     }
1565
1566     resource_info.type = VKD3D_STRUCTURE_TYPE_IMAGE_RESOURCE_CREATE_INFO;
1567     resource_info.next = NULL;
1568     resource_info.desc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
1569     resource_info.desc.Alignment = 0;
1570     resource_info.desc.Width = swapchain->desc.Width;
1571     resource_info.desc.Height = swapchain->desc.Height;
1572     resource_info.desc.DepthOrArraySize = 1;
1573     resource_info.desc.MipLevels = 1;
1574     resource_info.desc.Format = dxgi_format_from_vk_format(vk_format);
1575     resource_info.desc.SampleDesc.Count = 1;
1576     resource_info.desc.SampleDesc.Quality = 0;
1577     resource_info.desc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN;
1578     resource_info.desc.Flags = D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET;
1579     resource_info.flags = VKD3D_RESOURCE_INITIAL_STATE_TRANSITION | VKD3D_RESOURCE_PRESENT_STATE_TRANSITION;
1580
1581     queue_desc = ID3D12CommandQueue_GetDesc(queue);
1582     if (queue_desc.Type != D3D12_COMMAND_LIST_TYPE_DIRECT)
1583     {
1584         /* vkCmdBlitImage() is only supported for graphics queues. */
1585         FIXME("Swapchain blit not implemented for command queue type %#x.\n", queue_desc.Type);
1586         if (vk_swapchain_format != vk_format)
1587             return E_NOTIMPL;
1588         if (image_count != swapchain->desc.BufferCount)
1589         {
1590             FIXME("Got %u swapchain images, expected %u.\n", image_count, swapchain->desc.BufferCount);
1591             return E_NOTIMPL;
1592         }
1593     }
1594     queue_family_index = vkd3d_get_vk_queue_family_index(queue);
1595
1596     if (queue_desc.Type == D3D12_COMMAND_LIST_TYPE_DIRECT)
1597     {
1598         TRACE("Creating user swapchain buffers.\n");
1599
1600         if (FAILED(hr = d3d12_swapchain_create_user_buffers(swapchain, vk_format)))
1601             return hr;
1602
1603         if (FAILED(hr = d3d12_swapchain_prepare_command_buffers(swapchain, queue_family_index)))
1604             return hr;
1605     }
1606
1607     if (swapchain->buffers[0])
1608         return S_OK;
1609
1610     for (i = 0; i < swapchain->desc.BufferCount; ++i)
1611     {
1612         if (swapchain->vk_images[i])
1613         {
1614             resource_info.vk_image = swapchain->vk_images[i];
1615             resource_info.present_state = D3D12_RESOURCE_STATE_COPY_SOURCE;
1616         }
1617         else
1618         {
1619             resource_info.vk_image = swapchain->vk_swapchain_images[i];
1620             resource_info.present_state = D3D12_RESOURCE_STATE_PRESENT;
1621         }
1622
1623         if (FAILED(hr = vkd3d_create_image_resource(device, &resource_info, &swapchain->buffers[i])))
1624         {
1625             WARN("Failed to create vkd3d resource for Vulkan image %u, hr %#x.\n", i, hr);
1626             return hr;
1627         }
1628
1629         vkd3d_resource_incref(swapchain->buffers[i]);
1630         ID3D12Resource_Release(swapchain->buffers[i]);
1631     }
1632
1633     return S_OK;
1634 }
1635
1636 static VkResult d3d12_swapchain_acquire_next_vulkan_image(struct d3d12_swapchain *swapchain)
1637 {
1638     const struct dxgi_vk_funcs *vk_funcs = &swapchain->vk_funcs;
1639     VkDevice vk_device = swapchain->vk_device;
1640     VkFence vk_fence = swapchain->vk_fence;
1641     VkResult vr;
1642
1643     swapchain->vk_image_index = INVALID_VK_IMAGE_INDEX;
1644
1645     if ((vr = vk_funcs->p_vkAcquireNextImageKHR(vk_device, swapchain->vk_swapchain, UINT64_MAX,
1646             VK_NULL_HANDLE, vk_fence, &swapchain->vk_image_index)) < 0)
1647     {
1648         WARN("Failed to acquire next Vulkan image, vr %d.\n", vr);
1649         return vr;
1650     }
1651
1652     if ((vr = vk_funcs->p_vkWaitForFences(vk_device, 1, &vk_fence, VK_TRUE, UINT64_MAX)) != VK_SUCCESS)
1653     {
1654         ERR("Failed to wait for fence, vr %d.\n", vr);
1655         return vr;
1656     }
1657     if ((vr = vk_funcs->p_vkResetFences(vk_device, 1, &vk_fence)) < 0)
1658         ERR("Failed to reset fence, vr %d.\n", vr);
1659
1660     return vr;
1661 }
1662
1663 static VkResult d3d12_swapchain_acquire_next_back_buffer(struct d3d12_swapchain *swapchain)
1664 {
1665     VkResult vr;
1666
1667     /* If we don't have user images, we need to acquire a Vulkan image in order
1668      * to get the correct value for the current back buffer index. */
1669     if (d3d12_swapchain_has_user_images(swapchain))
1670         return VK_SUCCESS;
1671
1672     if ((vr = d3d12_swapchain_acquire_next_vulkan_image(swapchain)) >= 0)
1673         swapchain->current_buffer_index = swapchain->vk_image_index;
1674     else
1675         ERR("Failed to acquire Vulkan image, vr %d.\n", vr);
1676
1677     return vr;
1678 }
1679
1680 static void d3d12_swapchain_destroy_buffers(struct d3d12_swapchain *swapchain, BOOL destroy_user_buffers)
1681 {
1682     const struct dxgi_vk_funcs *vk_funcs = &swapchain->vk_funcs;
1683     VkQueue vk_queue;
1684     unsigned int i;
1685
1686     if (swapchain->command_queue)
1687     {
1688         if ((vk_queue = vkd3d_acquire_vk_queue(swapchain->command_queue)))
1689         {
1690             vk_funcs->p_vkQueueWaitIdle(vk_queue);
1691
1692             vkd3d_release_vk_queue(swapchain->command_queue);
1693         }
1694         else
1695         {
1696             WARN("Failed to acquire Vulkan queue.\n");
1697         }
1698     }
1699
1700     for (i = 0; i < swapchain->desc.BufferCount; ++i)
1701     {
1702         if (swapchain->buffers[i] && (destroy_user_buffers || !d3d12_swapchain_has_user_images(swapchain)))
1703         {
1704             vkd3d_resource_decref(swapchain->buffers[i]);
1705             swapchain->buffers[i] = NULL;
1706         }
1707         if (swapchain->vk_device && destroy_user_buffers)
1708         {
1709             vk_funcs->p_vkDestroyImage(swapchain->vk_device, swapchain->vk_images[i], NULL);
1710             swapchain->vk_images[i] = VK_NULL_HANDLE;
1711         }
1712     }
1713
1714     if (swapchain->vk_device)
1715     {
1716         for (i = 0; i < swapchain->buffer_count; ++i)
1717         {
1718             vk_funcs->p_vkDestroySemaphore(swapchain->vk_device, swapchain->vk_semaphores[i], NULL);
1719             swapchain->vk_semaphores[i] = VK_NULL_HANDLE;
1720         }
1721         if (destroy_user_buffers)
1722         {
1723             vk_funcs->p_vkFreeMemory(swapchain->vk_device, swapchain->vk_memory, NULL);
1724             swapchain->vk_memory = VK_NULL_HANDLE;
1725         }
1726         vk_funcs->p_vkDestroyCommandPool(swapchain->vk_device, swapchain->vk_cmd_pool, NULL);
1727         swapchain->vk_cmd_pool = VK_NULL_HANDLE;
1728     }
1729 }
1730
1731 static HRESULT d3d12_swapchain_create_vulkan_swapchain(struct d3d12_swapchain *swapchain)
1732 {
1733     VkPhysicalDevice vk_physical_device = swapchain->vk_physical_device;
1734     const struct dxgi_vk_funcs *vk_funcs = &swapchain->vk_funcs;
1735     VkSwapchainCreateInfoKHR vk_swapchain_desc;
1736     VkDevice vk_device = swapchain->vk_device;
1737     VkFormat vk_format, vk_swapchain_format;
1738     unsigned int width, height, image_count;
1739     VkSurfaceCapabilitiesKHR surface_caps;
1740     VkSwapchainKHR vk_swapchain;
1741     VkImageUsageFlags usage;
1742     VkResult vr;
1743     HRESULT hr;
1744
1745     if (!(vk_format = vkd3d_get_vk_format(swapchain->desc.Format)))
1746     {
1747         WARN("Invalid format %#x.\n", swapchain->desc.Format);
1748         return DXGI_ERROR_INVALID_CALL;
1749     }
1750
1751     if (FAILED(hr = select_vk_format(vk_funcs, vk_physical_device,
1752             swapchain->vk_surface, &swapchain->desc, &vk_swapchain_format)))
1753         return hr;
1754
1755     if ((vr = vk_funcs->p_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(vk_physical_device,
1756             swapchain->vk_surface, &surface_caps)) < 0)
1757     {
1758         WARN("Failed to get surface capabilities, vr %d.\n", vr);
1759         return hresult_from_vk_result(vr);
1760     }
1761
1762     image_count = swapchain->desc.BufferCount;
1763     image_count = max(image_count, surface_caps.minImageCount);
1764     if (surface_caps.maxImageCount)
1765         image_count = min(image_count, surface_caps.maxImageCount);
1766
1767     if (image_count != swapchain->desc.BufferCount)
1768     {
1769         WARN("Buffer count %u is not supported (%u-%u).\n", swapchain->desc.BufferCount,
1770                 surface_caps.minImageCount, surface_caps.maxImageCount);
1771     }
1772
1773     width = swapchain->desc.Width;
1774     height = swapchain->desc.Height;
1775     width = max(width, surface_caps.minImageExtent.width);
1776     width = min(width, surface_caps.maxImageExtent.width);
1777     height = max(height, surface_caps.minImageExtent.height);
1778     height = min(height, surface_caps.maxImageExtent.height);
1779
1780     if (width != swapchain->desc.Width || height != swapchain->desc.Height)
1781     {
1782         WARN("Swapchain dimensions %ux%u are not supported (%u-%u x %u-%u).\n",
1783                 swapchain->desc.Width, swapchain->desc.Height,
1784                 surface_caps.minImageExtent.width, surface_caps.maxImageExtent.width,
1785                 surface_caps.minImageExtent.height, surface_caps.maxImageExtent.height);
1786     }
1787
1788     TRACE("Vulkan swapchain extent %ux%u.\n", width, height);
1789
1790     if (!(surface_caps.supportedCompositeAlpha & VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR))
1791     {
1792         FIXME("Unsupported alpha mode.\n");
1793         return DXGI_ERROR_UNSUPPORTED;
1794     }
1795
1796     usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
1797     usage |= surface_caps.supportedUsageFlags & VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
1798     usage |= surface_caps.supportedUsageFlags & VK_IMAGE_USAGE_TRANSFER_DST_BIT;
1799     if (!(usage & VK_IMAGE_USAGE_TRANSFER_SRC_BIT) || !(usage & VK_IMAGE_USAGE_TRANSFER_DST_BIT))
1800         WARN("Transfer not supported for swapchain images.\n");
1801
1802     vk_swapchain_desc.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
1803     vk_swapchain_desc.pNext = NULL;
1804     vk_swapchain_desc.flags = 0;
1805     vk_swapchain_desc.surface = swapchain->vk_surface;
1806     vk_swapchain_desc.minImageCount = image_count;
1807     vk_swapchain_desc.imageFormat = vk_swapchain_format;
1808     vk_swapchain_desc.imageColorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR;
1809     vk_swapchain_desc.imageExtent.width = width;
1810     vk_swapchain_desc.imageExtent.height = height;
1811     vk_swapchain_desc.imageArrayLayers = 1;
1812     vk_swapchain_desc.imageUsage = usage;
1813     vk_swapchain_desc.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
1814     vk_swapchain_desc.queueFamilyIndexCount = 0;
1815     vk_swapchain_desc.pQueueFamilyIndices = NULL;
1816     vk_swapchain_desc.preTransform = surface_caps.currentTransform;
1817     vk_swapchain_desc.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
1818     vk_swapchain_desc.presentMode = swapchain->present_mode;
1819     vk_swapchain_desc.clipped = VK_TRUE;
1820     vk_swapchain_desc.oldSwapchain = swapchain->vk_swapchain;
1821     if ((vr = vk_funcs->p_vkCreateSwapchainKHR(vk_device, &vk_swapchain_desc, NULL, &vk_swapchain)) < 0)
1822     {
1823         WARN("Failed to create Vulkan swapchain, vr %d.\n", vr);
1824         return hresult_from_vk_result(vr);
1825     }
1826
1827     if (swapchain->vk_swapchain)
1828         vk_funcs->p_vkDestroySwapchainKHR(swapchain->vk_device, swapchain->vk_swapchain, NULL);
1829
1830     swapchain->vk_swapchain = vk_swapchain;
1831     swapchain->vk_swapchain_width = width;
1832     swapchain->vk_swapchain_height = height;
1833
1834     swapchain->vk_image_index = INVALID_VK_IMAGE_INDEX;
1835
1836     return d3d12_swapchain_create_buffers(swapchain, vk_swapchain_format, vk_format);
1837 }
1838
1839 static HRESULT d3d12_swapchain_recreate_vulkan_swapchain(struct d3d12_swapchain *swapchain)
1840 {
1841     VkResult vr;
1842     HRESULT hr;
1843
1844     if (SUCCEEDED(hr = d3d12_swapchain_create_vulkan_swapchain(swapchain)))
1845     {
1846         vr = d3d12_swapchain_acquire_next_back_buffer(swapchain);
1847         hr = hresult_from_vk_result(vr);
1848     }
1849     else
1850     {
1851         ERR("Failed to recreate Vulkan swapchain, hr %#x.\n", hr);
1852     }
1853
1854     return hr;
1855 }
1856
1857 static inline struct d3d12_swapchain *d3d12_swapchain_from_IDXGISwapChain4(IDXGISwapChain4 *iface)
1858 {
1859     return CONTAINING_RECORD(iface, struct d3d12_swapchain, IDXGISwapChain4_iface);
1860 }
1861
1862 /* IUnknown methods */
1863
1864 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_QueryInterface(IDXGISwapChain4 *iface, REFIID iid, void **object)
1865 {
1866     TRACE("iface %p, iid %s, object %p.\n", iface, debugstr_guid(iid), object);
1867
1868     if (IsEqualGUID(iid, &IID_IUnknown)
1869             || IsEqualGUID(iid, &IID_IDXGIObject)
1870             || IsEqualGUID(iid, &IID_IDXGIDeviceSubObject)
1871             || IsEqualGUID(iid, &IID_IDXGISwapChain)
1872             || IsEqualGUID(iid, &IID_IDXGISwapChain1)
1873             || IsEqualGUID(iid, &IID_IDXGISwapChain2)
1874             || IsEqualGUID(iid, &IID_IDXGISwapChain3)
1875             || IsEqualGUID(iid, &IID_IDXGISwapChain4))
1876     {
1877         IUnknown_AddRef(iface);
1878         *object = iface;
1879         return S_OK;
1880     }
1881
1882     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
1883
1884     *object = NULL;
1885     return E_NOINTERFACE;
1886 }
1887
1888 static ULONG STDMETHODCALLTYPE d3d12_swapchain_AddRef(IDXGISwapChain4 *iface)
1889 {
1890     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
1891     ULONG refcount = InterlockedIncrement(&swapchain->refcount);
1892
1893     TRACE("%p increasing refcount to %u.\n", swapchain, refcount);
1894
1895     return refcount;
1896 }
1897
1898 static void d3d12_swapchain_destroy(struct d3d12_swapchain *swapchain)
1899 {
1900     const struct dxgi_vk_funcs *vk_funcs = &swapchain->vk_funcs;
1901     void *vulkan_module = vk_funcs->vulkan_module;
1902
1903     d3d12_swapchain_destroy_buffers(swapchain, TRUE);
1904
1905     if (swapchain->frame_latency_event)
1906         CloseHandle(swapchain->frame_latency_event);
1907
1908     if (swapchain->frame_latency_fence)
1909         ID3D12Fence_Release(swapchain->frame_latency_fence);
1910
1911     if (swapchain->command_queue)
1912         ID3D12CommandQueue_Release(swapchain->command_queue);
1913
1914     wined3d_private_store_cleanup(&swapchain->private_store);
1915
1916     if (swapchain->vk_device)
1917     {
1918         vk_funcs->p_vkDestroyFence(swapchain->vk_device, swapchain->vk_fence, NULL);
1919         vk_funcs->p_vkDestroySwapchainKHR(swapchain->vk_device, swapchain->vk_swapchain, NULL);
1920     }
1921
1922     if (swapchain->vk_instance)
1923         vk_funcs->p_vkDestroySurfaceKHR(swapchain->vk_instance, swapchain->vk_surface, NULL);
1924
1925     if (swapchain->target)
1926     {
1927         WARN("Destroying fullscreen swapchain.\n");
1928         IDXGIOutput_Release(swapchain->target);
1929     }
1930
1931     if (swapchain->device)
1932         ID3D12Device_Release(swapchain->device);
1933
1934     if (swapchain->factory)
1935         IWineDXGIFactory_Release(swapchain->factory);
1936
1937     close_library(vulkan_module);
1938
1939     wined3d_swapchain_state_destroy(swapchain->state);
1940 }
1941
1942 static ULONG STDMETHODCALLTYPE d3d12_swapchain_Release(IDXGISwapChain4 *iface)
1943 {
1944     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
1945     ULONG refcount = InterlockedDecrement(&swapchain->refcount);
1946
1947     TRACE("%p decreasing refcount to %u.\n", swapchain, refcount);
1948
1949     if (!refcount)
1950     {
1951         d3d12_swapchain_destroy(swapchain);
1952         heap_free(swapchain);
1953     }
1954
1955     return refcount;
1956 }
1957
1958 /* IDXGIObject methods */
1959
1960 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_SetPrivateData(IDXGISwapChain4 *iface,
1961         REFGUID guid, UINT data_size, const void *data)
1962 {
1963     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
1964
1965     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
1966
1967     return dxgi_set_private_data(&swapchain->private_store, guid, data_size, data);
1968 }
1969
1970 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_SetPrivateDataInterface(IDXGISwapChain4 *iface,
1971         REFGUID guid, const IUnknown *object)
1972 {
1973     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
1974
1975     TRACE("iface %p, guid %s, object %p.\n", iface, debugstr_guid(guid), object);
1976
1977     return dxgi_set_private_data_interface(&swapchain->private_store, guid, object);
1978 }
1979
1980 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_GetPrivateData(IDXGISwapChain4 *iface,
1981         REFGUID guid, UINT *data_size, void *data)
1982 {
1983     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
1984
1985     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
1986
1987     return dxgi_get_private_data(&swapchain->private_store, guid, data_size, data);
1988 }
1989
1990 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_GetParent(IDXGISwapChain4 *iface, REFIID iid, void **parent)
1991 {
1992     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
1993
1994     TRACE("iface %p, iid %s, parent %p.\n", iface, debugstr_guid(iid), parent);
1995
1996     return IWineDXGIFactory_QueryInterface(swapchain->factory, iid, parent);
1997 }
1998
1999 /* IDXGIDeviceSubObject methods */
2000
2001 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_GetDevice(IDXGISwapChain4 *iface, REFIID iid, void **device)
2002 {
2003     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
2004
2005     TRACE("iface %p, iid %s, device %p.\n", iface, debugstr_guid(iid), device);
2006
2007     return ID3D12Device_QueryInterface(swapchain->device, iid, device);
2008 }
2009
2010 /* IDXGISwapChain methods */
2011
2012 static HRESULT d3d12_swapchain_set_sync_interval(struct d3d12_swapchain *swapchain,
2013         unsigned int sync_interval)
2014 {
2015     VkPresentModeKHR present_mode;
2016
2017     switch (sync_interval)
2018     {
2019         case 0:
2020             present_mode = VK_PRESENT_MODE_IMMEDIATE_KHR;
2021             break;
2022         default:
2023             FIXME("Unsupported sync interval %u.\n", sync_interval);
2024         case 1:
2025             present_mode = VK_PRESENT_MODE_FIFO_KHR;
2026             break;
2027     }
2028
2029     if (swapchain->present_mode == present_mode)
2030         return S_OK;
2031
2032     if (!d3d12_swapchain_has_user_images(swapchain))
2033     {
2034         FIXME("Cannot recreate swapchain without user images.\n");
2035         return S_OK;
2036     }
2037
2038     if (!d3d12_swapchain_is_present_mode_supported(swapchain, present_mode))
2039     {
2040         FIXME("Vulkan present mode %#x is not supported.\n", present_mode);
2041         return S_OK;
2042     }
2043
2044     d3d12_swapchain_destroy_buffers(swapchain, FALSE);
2045     swapchain->present_mode = present_mode;
2046     return d3d12_swapchain_recreate_vulkan_swapchain(swapchain);
2047 }
2048
2049 static VkResult d3d12_swapchain_queue_present(struct d3d12_swapchain *swapchain, VkQueue vk_queue)
2050 {
2051     const struct dxgi_vk_funcs *vk_funcs = &swapchain->vk_funcs;
2052     VkPresentInfoKHR present_info;
2053     VkSubmitInfo submit_info;
2054     VkResult vr;
2055
2056     if (swapchain->vk_image_index == INVALID_VK_IMAGE_INDEX)
2057     {
2058         if ((vr = d3d12_swapchain_acquire_next_vulkan_image(swapchain)) < 0)
2059             return vr;
2060     }
2061
2062     assert(swapchain->vk_image_index < swapchain->buffer_count);
2063
2064     present_info.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
2065     present_info.pNext = NULL;
2066     present_info.waitSemaphoreCount = 0;
2067     present_info.pWaitSemaphores = NULL;
2068     present_info.swapchainCount = 1;
2069     present_info.pSwapchains = &swapchain->vk_swapchain;
2070     present_info.pImageIndices = &swapchain->vk_image_index;
2071     present_info.pResults = NULL;
2072
2073     if (d3d12_swapchain_has_user_images(swapchain))
2074     {
2075         /* blit */
2076         VkCommandBuffer vk_cmd_buffer = swapchain->vk_cmd_buffers[swapchain->vk_image_index];
2077         VkImage vk_dst_image = swapchain->vk_swapchain_images[swapchain->vk_image_index];
2078         VkImage vk_src_image = swapchain->vk_images[swapchain->current_buffer_index];
2079
2080         if ((vr = vk_funcs->p_vkResetCommandBuffer(vk_cmd_buffer, 0)) < 0)
2081         {
2082             ERR("Failed to reset command buffer, vr %d.\n", vr);
2083             return vr;
2084         }
2085
2086         if ((vr = d3d12_swapchain_record_swapchain_blit(swapchain,
2087                 vk_cmd_buffer, vk_dst_image, vk_src_image)) < 0 )
2088             return vr;
2089
2090         submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
2091         submit_info.pNext = NULL;
2092         submit_info.waitSemaphoreCount = 0;
2093         submit_info.pWaitSemaphores = NULL;
2094         submit_info.pWaitDstStageMask = NULL;
2095         submit_info.commandBufferCount = 1;
2096         submit_info.pCommandBuffers = &vk_cmd_buffer;
2097         submit_info.signalSemaphoreCount = 1;
2098         submit_info.pSignalSemaphores = &swapchain->vk_semaphores[swapchain->vk_image_index];
2099
2100         if ((vr = vk_funcs->p_vkQueueSubmit(vk_queue, 1, &submit_info, VK_NULL_HANDLE)) < 0)
2101         {
2102             ERR("Failed to blit swapchain buffer, vr %d.\n", vr);
2103             return vr;
2104         }
2105
2106         present_info.waitSemaphoreCount = 1;
2107         present_info.pWaitSemaphores = &swapchain->vk_semaphores[swapchain->vk_image_index];
2108     }
2109
2110     if ((vr = vk_funcs->p_vkQueuePresentKHR(vk_queue, &present_info)) >= 0)
2111         swapchain->vk_image_index = INVALID_VK_IMAGE_INDEX;
2112
2113     return vr;
2114 }
2115
2116 static HRESULT d3d12_swapchain_present(struct d3d12_swapchain *swapchain,
2117         unsigned int sync_interval, unsigned int flags)
2118 {
2119     HANDLE frame_latency_event;
2120     VkQueue vk_queue;
2121     VkResult vr;
2122     HRESULT hr;
2123
2124     if (sync_interval > 4)
2125     {
2126         WARN("Invalid sync interval %u.\n", sync_interval);
2127         return DXGI_ERROR_INVALID_CALL;
2128     }
2129
2130     if (flags & ~DXGI_PRESENT_TEST)
2131         FIXME("Unimplemented flags %#x.\n", flags);
2132     if (flags & DXGI_PRESENT_TEST)
2133     {
2134         WARN("Returning S_OK for DXGI_PRESENT_TEST.\n");
2135         return S_OK;
2136     }
2137
2138     if (FAILED(hr = d3d12_swapchain_set_sync_interval(swapchain, sync_interval)))
2139         return hr;
2140
2141     if (!(vk_queue = vkd3d_acquire_vk_queue(swapchain->command_queue)))
2142     {
2143         ERR("Failed to acquire Vulkan queue.\n");
2144         return E_FAIL;
2145     }
2146
2147     vr = d3d12_swapchain_queue_present(swapchain, vk_queue);
2148     if (vr == VK_ERROR_OUT_OF_DATE_KHR)
2149     {
2150         vkd3d_release_vk_queue(swapchain->command_queue);
2151
2152         if (!d3d12_swapchain_has_user_images(swapchain))
2153         {
2154             FIXME("Cannot recreate swapchain without user images.\n");
2155             return DXGI_STATUS_MODE_CHANGED;
2156         }
2157
2158         TRACE("Recreating Vulkan swapchain.\n");
2159
2160         d3d12_swapchain_destroy_buffers(swapchain, FALSE);
2161         if (FAILED(hr = d3d12_swapchain_recreate_vulkan_swapchain(swapchain)))
2162             return hr;
2163
2164         if (!(vk_queue = vkd3d_acquire_vk_queue(swapchain->command_queue)))
2165         {
2166             ERR("Failed to acquire Vulkan queue.\n");
2167             return E_FAIL;
2168         }
2169
2170         if ((vr = d3d12_swapchain_queue_present(swapchain, vk_queue)) < 0)
2171             ERR("Failed to present after recreating swapchain, vr %d.\n", vr);
2172     }
2173
2174     vkd3d_release_vk_queue(swapchain->command_queue);
2175
2176     if (vr < 0)
2177     {
2178         ERR("Failed to queue present, vr %d.\n", vr);
2179         return hresult_from_vk_result(vr);
2180     }
2181
2182     ++swapchain->frame_number;
2183     if ((frame_latency_event = swapchain->frame_latency_event))
2184     {
2185         if (FAILED(hr = ID3D12CommandQueue_Signal(swapchain->command_queue,
2186                 swapchain->frame_latency_fence, swapchain->frame_number)))
2187         {
2188             ERR("Failed to signal frame latency fence, hr %#x.\n", hr);
2189             return hr;
2190         }
2191
2192         if (FAILED(hr = ID3D12Fence_SetEventOnCompletion(swapchain->frame_latency_fence,
2193                 swapchain->frame_number - swapchain->frame_latency, frame_latency_event)))
2194         {
2195             ERR("Failed to enqueue frame latency event, hr %#x.\n", hr);
2196             return hr;
2197         }
2198     }
2199
2200     swapchain->current_buffer_index = (swapchain->current_buffer_index + 1) % swapchain->desc.BufferCount;
2201     vr = d3d12_swapchain_acquire_next_back_buffer(swapchain);
2202     if (vr == VK_ERROR_OUT_OF_DATE_KHR)
2203     {
2204         if (!d3d12_swapchain_has_user_images(swapchain))
2205         {
2206             FIXME("Cannot recreate swapchain without user images.\n");
2207             return DXGI_STATUS_MODE_CHANGED;
2208         }
2209
2210         TRACE("Recreating Vulkan swapchain.\n");
2211
2212         d3d12_swapchain_destroy_buffers(swapchain, FALSE);
2213         return d3d12_swapchain_recreate_vulkan_swapchain(swapchain);
2214     }
2215     if (vr < 0)
2216         ERR("Failed to acquire next Vulkan image, vr %d.\n", vr);
2217     return hresult_from_vk_result(vr);
2218 }
2219
2220 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_Present(IDXGISwapChain4 *iface, UINT sync_interval, UINT flags)
2221 {
2222     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
2223
2224     TRACE("iface %p, sync_interval %u, flags %#x.\n", iface, sync_interval, flags);
2225
2226     return d3d12_swapchain_present(swapchain, sync_interval, flags);
2227 }
2228
2229 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_GetBuffer(IDXGISwapChain4 *iface,
2230         UINT buffer_idx, REFIID iid, void **surface)
2231 {
2232     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
2233
2234     TRACE("iface %p, buffer_idx %u, iid %s, surface %p.\n",
2235             iface, buffer_idx, debugstr_guid(iid), surface);
2236
2237     if (buffer_idx >= swapchain->desc.BufferCount)
2238     {
2239         WARN("Invalid buffer index %u.\n", buffer_idx);
2240         return DXGI_ERROR_INVALID_CALL;
2241     }
2242
2243     assert(swapchain->buffers[buffer_idx]);
2244     return ID3D12Resource_QueryInterface(swapchain->buffers[buffer_idx], iid, surface);
2245 }
2246
2247 static HRESULT STDMETHODCALLTYPE DECLSPEC_HOTPATCH d3d12_swapchain_SetFullscreenState(IDXGISwapChain4 *iface,
2248         BOOL fullscreen, IDXGIOutput *target)
2249 {
2250     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
2251     DXGI_SWAP_CHAIN_FULLSCREEN_DESC *fullscreen_desc = &swapchain->fullscreen_desc;
2252     const DXGI_SWAP_CHAIN_DESC1 *swapchain_desc = &swapchain->desc;
2253     struct wined3d_swapchain_desc wined3d_desc;
2254     HWND window = swapchain->window;
2255     HRESULT hr;
2256
2257     TRACE("iface %p, fullscreen %#x, target %p.\n", iface, fullscreen, target);
2258
2259     if (!fullscreen && target)
2260     {
2261         WARN("Invalid call.\n");
2262         return DXGI_ERROR_INVALID_CALL;
2263     }
2264
2265     if (target)
2266     {
2267         IDXGIOutput_AddRef(target);
2268     }
2269     else if (FAILED(hr = IDXGISwapChain4_GetContainingOutput(iface, &target)))
2270     {
2271         WARN("Failed to get target output for swapchain, hr %#x.\n", hr);
2272         return hr;
2273     }
2274
2275     if (FAILED(hr = wined3d_swapchain_desc_from_dxgi(&wined3d_desc, target, window, swapchain_desc,
2276             fullscreen_desc)))
2277         goto fail;
2278     wined3d_mutex_lock();
2279     wined3d_desc.windowed = !fullscreen;
2280     hr = wined3d_swapchain_state_set_fullscreen(swapchain->state, &wined3d_desc, NULL);
2281     wined3d_mutex_unlock();
2282     if (FAILED(hr))
2283         goto fail;
2284
2285     fullscreen_desc->Windowed = wined3d_desc.windowed;
2286     if (!fullscreen)
2287     {
2288         IDXGIOutput_Release(target);
2289         target = NULL;
2290     }
2291
2292     if (swapchain->target)
2293         IDXGIOutput_Release(swapchain->target);
2294     swapchain->target = target;
2295
2296     return S_OK;
2297
2298 fail:
2299     IDXGIOutput_Release(target);
2300
2301     return DXGI_ERROR_NOT_CURRENTLY_AVAILABLE;
2302 }
2303
2304 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_GetFullscreenState(IDXGISwapChain4 *iface,
2305         BOOL *fullscreen, IDXGIOutput **target)
2306 {
2307     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
2308     BOOL windowed;
2309     HRESULT hr;
2310
2311     TRACE("iface %p, fullscreen %p, target %p.\n", iface, fullscreen, target);
2312
2313     if (fullscreen || target)
2314     {
2315         wined3d_mutex_lock();
2316         windowed = wined3d_swapchain_state_is_windowed(swapchain->state);
2317         wined3d_mutex_unlock();
2318     }
2319
2320     if (fullscreen)
2321         *fullscreen = !windowed;
2322
2323     if (target)
2324     {
2325         if (!windowed)
2326         {
2327             if (!swapchain->target && FAILED(hr = IDXGISwapChain4_GetContainingOutput(iface,
2328                     &swapchain->target)))
2329                 return hr;
2330
2331             *target = swapchain->target;
2332             IDXGIOutput_AddRef(*target);
2333         }
2334         else
2335         {
2336             *target = NULL;
2337         }
2338     }
2339
2340     return S_OK;
2341 }
2342
2343 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_GetDesc(IDXGISwapChain4 *iface, DXGI_SWAP_CHAIN_DESC *desc)
2344 {
2345     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
2346     const DXGI_SWAP_CHAIN_FULLSCREEN_DESC *fullscreen_desc = &swapchain->fullscreen_desc;
2347     const DXGI_SWAP_CHAIN_DESC1 *swapchain_desc = &swapchain->desc;
2348     BOOL windowed;
2349
2350     TRACE("iface %p, desc %p.\n", iface, desc);
2351
2352     if (!desc)
2353     {
2354         WARN("Invalid pointer.\n");
2355         return E_INVALIDARG;
2356     }
2357
2358     wined3d_mutex_lock();
2359     windowed = wined3d_swapchain_state_is_windowed(swapchain->state);
2360     wined3d_mutex_unlock();
2361
2362     desc->BufferDesc.Width = swapchain_desc->Width;
2363     desc->BufferDesc.Height = swapchain_desc->Height;
2364     desc->BufferDesc.RefreshRate = fullscreen_desc->RefreshRate;
2365     desc->BufferDesc.Format = swapchain_desc->Format;
2366     desc->BufferDesc.ScanlineOrdering = fullscreen_desc->ScanlineOrdering;
2367     desc->BufferDesc.Scaling = fullscreen_desc->Scaling;
2368     desc->SampleDesc = swapchain_desc->SampleDesc;
2369     desc->BufferUsage = swapchain_desc->BufferUsage;
2370     desc->BufferCount = swapchain_desc->BufferCount;
2371     desc->OutputWindow = swapchain->window;
2372     desc->Windowed = windowed;
2373     desc->SwapEffect = swapchain_desc->SwapEffect;
2374     desc->Flags = swapchain_desc->Flags;
2375
2376     return S_OK;
2377 }
2378
2379 static HRESULT d3d12_swapchain_resize_buffers(struct d3d12_swapchain *swapchain,
2380         UINT buffer_count, UINT width, UINT height, DXGI_FORMAT format, UINT flags)
2381 {
2382     DXGI_SWAP_CHAIN_DESC1 *desc, new_desc;
2383     unsigned int i;
2384     ULONG refcount;
2385
2386     if (flags)
2387         FIXME("Ignoring flags %#x.\n", flags);
2388
2389     for (i = 0; i < swapchain->desc.BufferCount; ++i)
2390     {
2391         ID3D12Resource_AddRef(swapchain->buffers[i]);
2392         if ((refcount = ID3D12Resource_Release(swapchain->buffers[i])))
2393         {
2394             WARN("Buffer %p has %u references left.\n", swapchain->buffers[i], refcount);
2395             return DXGI_ERROR_INVALID_CALL;
2396         }
2397     }
2398
2399     desc = &swapchain->desc;
2400     new_desc = swapchain->desc;
2401
2402     if (buffer_count)
2403         new_desc.BufferCount = buffer_count;
2404     if (!width || !height)
2405     {
2406         RECT client_rect;
2407
2408         if (!GetClientRect(swapchain->window, &client_rect))
2409         {
2410             WARN("Failed to get client rect, last error %#x.\n", GetLastError());
2411             return DXGI_ERROR_INVALID_CALL;
2412         }
2413
2414         if (!width)
2415             width = client_rect.right;
2416         if (!height)
2417             height = client_rect.bottom;
2418     }
2419     new_desc.Width = width;
2420     new_desc.Height = height;
2421
2422     if (format)
2423         new_desc.Format = format;
2424
2425     if (!dxgi_validate_swapchain_desc(&new_desc))
2426         return DXGI_ERROR_INVALID_CALL;
2427
2428     if (desc->Width == new_desc.Width && desc->Height == new_desc.Height
2429             && desc->Format == new_desc.Format && desc->BufferCount == new_desc.BufferCount)
2430         return S_OK;
2431
2432     d3d12_swapchain_destroy_buffers(swapchain, TRUE);
2433     swapchain->desc = new_desc;
2434     return d3d12_swapchain_recreate_vulkan_swapchain(swapchain);
2435 }
2436
2437 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_ResizeBuffers(IDXGISwapChain4 *iface,
2438         UINT buffer_count, UINT width, UINT height, DXGI_FORMAT format, UINT flags)
2439 {
2440     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
2441
2442     TRACE("iface %p, buffer_count %u, width %u, height %u, format %s, flags %#x.\n",
2443             iface, buffer_count, width, height, debug_dxgi_format(format), flags);
2444
2445     return d3d12_swapchain_resize_buffers(swapchain, buffer_count, width, height, format, flags);
2446 }
2447
2448 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_ResizeTarget(IDXGISwapChain4 *iface,
2449         const DXGI_MODE_DESC *target_mode_desc)
2450 {
2451     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
2452
2453     TRACE("iface %p, target_mode_desc %p.\n", iface, target_mode_desc);
2454
2455     return dxgi_swapchain_resize_target(swapchain->state, target_mode_desc);
2456 }
2457
2458 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_GetContainingOutput(IDXGISwapChain4 *iface,
2459         IDXGIOutput **output)
2460 {
2461     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
2462     IUnknown *device_parent;
2463     IWineDXGIFactory *factory;
2464     IDXGIAdapter *adapter;
2465     HRESULT hr;
2466
2467     TRACE("iface %p, output %p.\n", iface, output);
2468
2469     if (swapchain->target)
2470     {
2471         IDXGIOutput_AddRef(*output = swapchain->target);
2472         return S_OK;
2473     }
2474
2475     device_parent = vkd3d_get_device_parent(swapchain->device);
2476
2477     if (FAILED(hr = IUnknown_QueryInterface(device_parent, &IID_IDXGIAdapter, (void **)&adapter)))
2478     {
2479         WARN("Failed to get adapter, hr %#x.\n", hr);
2480         return hr;
2481     }
2482
2483     if (FAILED(hr = IDXGIAdapter_GetParent(adapter, &IID_IWineDXGIFactory, (void **)&factory)))
2484     {
2485         WARN("Failed to get factory, hr %#x.\n", hr);
2486         IDXGIAdapter_Release(adapter);
2487         return hr;
2488     }
2489
2490     hr = dxgi_get_output_from_window(factory, swapchain->window, output);
2491     IWineDXGIFactory_Release(factory);
2492     IDXGIAdapter_Release(adapter);
2493     return hr;
2494 }
2495
2496 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_GetFrameStatistics(IDXGISwapChain4 *iface,
2497         DXGI_FRAME_STATISTICS *stats)
2498 {
2499     FIXME("iface %p, stats %p stub!\n", iface, stats);
2500
2501     return E_NOTIMPL;
2502 }
2503
2504 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_GetLastPresentCount(IDXGISwapChain4 *iface,
2505         UINT *last_present_count)
2506 {
2507     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
2508
2509     TRACE("iface %p, last_present_count %p.\n", iface, last_present_count);
2510
2511     *last_present_count = swapchain->frame_number;
2512
2513     return S_OK;
2514 }
2515
2516 /* IDXGISwapChain1 methods */
2517
2518 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_GetDesc1(IDXGISwapChain4 *iface, DXGI_SWAP_CHAIN_DESC1 *desc)
2519 {
2520     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
2521
2522     TRACE("iface %p, desc %p.\n", iface, desc);
2523
2524     if (!desc)
2525     {
2526         WARN("Invalid pointer.\n");
2527         return E_INVALIDARG;
2528     }
2529
2530     *desc = swapchain->desc;
2531     return S_OK;
2532 }
2533
2534 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_GetFullscreenDesc(IDXGISwapChain4 *iface,
2535         DXGI_SWAP_CHAIN_FULLSCREEN_DESC *desc)
2536 {
2537     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
2538     BOOL windowed;
2539
2540     TRACE("iface %p, desc %p.\n", iface, desc);
2541
2542     if (!desc)
2543     {
2544         WARN("Invalid pointer.\n");
2545         return E_INVALIDARG;
2546     }
2547
2548     wined3d_mutex_lock();
2549     windowed = wined3d_swapchain_state_is_windowed(swapchain->state);
2550     wined3d_mutex_unlock();
2551
2552     *desc = swapchain->fullscreen_desc;
2553     desc->Windowed = windowed;
2554     return S_OK;
2555 }
2556
2557 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_GetHwnd(IDXGISwapChain4 *iface, HWND *hwnd)
2558 {
2559     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
2560
2561     TRACE("iface %p, hwnd %p.\n", iface, hwnd);
2562
2563     if (!hwnd)
2564     {
2565         WARN("Invalid pointer.\n");
2566         return DXGI_ERROR_INVALID_CALL;
2567     }
2568
2569     *hwnd = swapchain->window;
2570     return S_OK;
2571 }
2572
2573 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_GetCoreWindow(IDXGISwapChain4 *iface,
2574         REFIID iid, void **core_window)
2575 {
2576     FIXME("iface %p, iid %s, core_window %p stub!\n", iface, debugstr_guid(iid), core_window);
2577
2578     if (core_window)
2579         *core_window = NULL;
2580
2581     return DXGI_ERROR_INVALID_CALL;
2582 }
2583
2584 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_Present1(IDXGISwapChain4 *iface,
2585         UINT sync_interval, UINT flags, const DXGI_PRESENT_PARAMETERS *present_parameters)
2586 {
2587     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
2588
2589     TRACE("iface %p, sync_interval %u, flags %#x, present_parameters %p.\n",
2590             iface, sync_interval, flags, present_parameters);
2591
2592     if (present_parameters)
2593         FIXME("Ignored present parameters %p.\n", present_parameters);
2594
2595     return d3d12_swapchain_present(swapchain, sync_interval, flags);
2596 }
2597
2598 static BOOL STDMETHODCALLTYPE d3d12_swapchain_IsTemporaryMonoSupported(IDXGISwapChain4 *iface)
2599 {
2600     FIXME("iface %p stub!\n", iface);
2601
2602     return FALSE;
2603 }
2604
2605 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_GetRestrictToOutput(IDXGISwapChain4 *iface, IDXGIOutput **output)
2606 {
2607     FIXME("iface %p, output %p stub!\n", iface, output);
2608
2609     if (!output)
2610     {
2611         WARN("Invalid pointer.\n");
2612         return E_INVALIDARG;
2613     }
2614
2615     *output = NULL;
2616     return E_NOTIMPL;
2617 }
2618
2619 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_SetBackgroundColor(IDXGISwapChain4 *iface, const DXGI_RGBA *color)
2620 {
2621     FIXME("iface %p, color %p stub!\n", iface, color);
2622
2623     return E_NOTIMPL;
2624 }
2625
2626 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_GetBackgroundColor(IDXGISwapChain4 *iface, DXGI_RGBA *color)
2627 {
2628     FIXME("iface %p, color %p stub!\n", iface, color);
2629
2630     return E_NOTIMPL;
2631 }
2632
2633 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_SetRotation(IDXGISwapChain4 *iface, DXGI_MODE_ROTATION rotation)
2634 {
2635     FIXME("iface %p, rotation %#x stub!\n", iface, rotation);
2636
2637     return E_NOTIMPL;
2638 }
2639
2640 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_GetRotation(IDXGISwapChain4 *iface, DXGI_MODE_ROTATION *rotation)
2641 {
2642     FIXME("iface %p, rotation %p stub!\n", iface, rotation);
2643
2644     return E_NOTIMPL;
2645 }
2646
2647 /* IDXGISwapChain2 methods */
2648
2649 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_SetSourceSize(IDXGISwapChain4 *iface, UINT width, UINT height)
2650 {
2651     FIXME("iface %p, width %u, height %u stub!\n", iface, width, height);
2652
2653     return E_NOTIMPL;
2654 }
2655
2656 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_GetSourceSize(IDXGISwapChain4 *iface, UINT *width, UINT *height)
2657 {
2658     FIXME("iface %p, width %p, height %p stub!\n", iface, width, height);
2659
2660     return E_NOTIMPL;
2661 }
2662
2663 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_SetMaximumFrameLatency(IDXGISwapChain4 *iface, UINT max_latency)
2664 {
2665     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
2666
2667     TRACE("iface %p, max_latency %u.\n", iface, max_latency);
2668
2669     if (!(swapchain->desc.Flags & DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT))
2670     {
2671         WARN("DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT not set for swap chain %p.\n", iface);
2672         return DXGI_ERROR_INVALID_CALL;
2673     }
2674
2675     if (!max_latency)
2676     {
2677         WARN("Invalid maximum frame latency %u.\n", max_latency);
2678         return DXGI_ERROR_INVALID_CALL;
2679     }
2680
2681     swapchain->frame_latency = max_latency;
2682     return S_OK;
2683 }
2684
2685 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_GetMaximumFrameLatency(IDXGISwapChain4 *iface, UINT *max_latency)
2686 {
2687     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
2688
2689     TRACE("iface %p, max_latency %p.\n", iface, max_latency);
2690
2691     if (!(swapchain->desc.Flags & DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT))
2692     {
2693         WARN("DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT not set for swap chain %p.\n", iface);
2694         return DXGI_ERROR_INVALID_CALL;
2695     }
2696
2697     *max_latency = swapchain->frame_latency;
2698     return S_OK;
2699 }
2700
2701 static HANDLE STDMETHODCALLTYPE d3d12_swapchain_GetFrameLatencyWaitableObject(IDXGISwapChain4 *iface)
2702 {
2703     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
2704
2705     TRACE("iface %p.\n", iface);
2706
2707     return swapchain->frame_latency_event;
2708 }
2709
2710 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_SetMatrixTransform(IDXGISwapChain4 *iface,
2711         const DXGI_MATRIX_3X2_F *matrix)
2712 {
2713     FIXME("iface %p, matrix %p stub!\n", iface, matrix);
2714
2715     return E_NOTIMPL;
2716 }
2717
2718 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_GetMatrixTransform(IDXGISwapChain4 *iface,
2719         DXGI_MATRIX_3X2_F *matrix)
2720 {
2721     FIXME("iface %p, matrix %p stub!\n", iface, matrix);
2722
2723     return E_NOTIMPL;
2724 }
2725
2726 /* IDXGISwapChain3 methods */
2727
2728 static UINT STDMETHODCALLTYPE d3d12_swapchain_GetCurrentBackBufferIndex(IDXGISwapChain4 *iface)
2729 {
2730     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
2731
2732     TRACE("iface %p.\n", iface);
2733
2734     TRACE("Current back buffer index %u.\n", swapchain->current_buffer_index);
2735     assert(swapchain->current_buffer_index < swapchain->desc.BufferCount);
2736     return swapchain->current_buffer_index;
2737 }
2738
2739 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_CheckColorSpaceSupport(IDXGISwapChain4 *iface,
2740         DXGI_COLOR_SPACE_TYPE colour_space, UINT *colour_space_support)
2741 {
2742     UINT support_flags = 0;
2743
2744     FIXME("iface %p, colour_space %#x, colour_space_support %p semi-stub!\n",
2745             iface, colour_space, colour_space_support);
2746
2747     if (!colour_space_support)
2748         return E_INVALIDARG;
2749
2750     if (colour_space == DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709)
2751       support_flags |= DXGI_SWAP_CHAIN_COLOR_SPACE_SUPPORT_FLAG_PRESENT;
2752
2753     *colour_space_support = support_flags;
2754     return S_OK;
2755 }
2756
2757 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_SetColorSpace1(IDXGISwapChain4 *iface,
2758         DXGI_COLOR_SPACE_TYPE colour_space)
2759 {
2760     FIXME("iface %p, colour_space %#x semi-stub!\n", iface, colour_space);
2761
2762     if (colour_space != DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709)
2763     {
2764         WARN("Colour space %u not supported.\n", colour_space);
2765         return E_INVALIDARG;
2766     }
2767
2768     return S_OK;
2769 }
2770
2771 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_ResizeBuffers1(IDXGISwapChain4 *iface,
2772         UINT buffer_count, UINT width, UINT height, DXGI_FORMAT format, UINT flags,
2773         const UINT *node_mask, IUnknown * const *present_queue)
2774 {
2775     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
2776     size_t i, count;
2777
2778     TRACE("iface %p, buffer_count %u, width %u, height %u, format %s, flags %#x, "
2779             "node_mask %p, present_queue %p.\n",
2780             iface, buffer_count, width, height, debug_dxgi_format(format), flags, node_mask, present_queue);
2781
2782     if (!node_mask || !present_queue)
2783         return DXGI_ERROR_INVALID_CALL;
2784
2785     count = buffer_count ? buffer_count : swapchain->desc.BufferCount;
2786     for (i = 0; i < count; ++i)
2787     {
2788         if (node_mask[i] > 1 || !present_queue[i])
2789             return DXGI_ERROR_INVALID_CALL;
2790         if ((ID3D12CommandQueue*)present_queue[i] != swapchain->command_queue)
2791             FIXME("Ignoring present queue %p.\n", present_queue[i]);
2792     }
2793
2794     return d3d12_swapchain_resize_buffers(swapchain, buffer_count, width, height, format, flags);
2795 }
2796
2797 /* IDXGISwapChain4 methods */
2798
2799 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_SetHDRMetaData(IDXGISwapChain4 *iface,
2800         DXGI_HDR_METADATA_TYPE type, UINT size, void *metadata)
2801 {
2802     FIXME("iface %p, type %#x, size %#x, metadata %p stub!\n", iface, type, size, metadata);
2803
2804     return E_NOTIMPL;
2805 }
2806
2807 static const struct IDXGISwapChain4Vtbl d3d12_swapchain_vtbl =
2808 {
2809     /* IUnknown methods */
2810     d3d12_swapchain_QueryInterface,
2811     d3d12_swapchain_AddRef,
2812     d3d12_swapchain_Release,
2813     /* IDXGIObject methods */
2814     d3d12_swapchain_SetPrivateData,
2815     d3d12_swapchain_SetPrivateDataInterface,
2816     d3d12_swapchain_GetPrivateData,
2817     d3d12_swapchain_GetParent,
2818     /* IDXGIDeviceSubObject methods */
2819     d3d12_swapchain_GetDevice,
2820     /* IDXGISwapChain methods */
2821     d3d12_swapchain_Present,
2822     d3d12_swapchain_GetBuffer,
2823     d3d12_swapchain_SetFullscreenState,
2824     d3d12_swapchain_GetFullscreenState,
2825     d3d12_swapchain_GetDesc,
2826     d3d12_swapchain_ResizeBuffers,
2827     d3d12_swapchain_ResizeTarget,
2828     d3d12_swapchain_GetContainingOutput,
2829     d3d12_swapchain_GetFrameStatistics,
2830     d3d12_swapchain_GetLastPresentCount,
2831     /* IDXGISwapChain1 methods */
2832     d3d12_swapchain_GetDesc1,
2833     d3d12_swapchain_GetFullscreenDesc,
2834     d3d12_swapchain_GetHwnd,
2835     d3d12_swapchain_GetCoreWindow,
2836     d3d12_swapchain_Present1,
2837     d3d12_swapchain_IsTemporaryMonoSupported,
2838     d3d12_swapchain_GetRestrictToOutput,
2839     d3d12_swapchain_SetBackgroundColor,
2840     d3d12_swapchain_GetBackgroundColor,
2841     d3d12_swapchain_SetRotation,
2842     d3d12_swapchain_GetRotation,
2843     /* IDXGISwapChain2 methods */
2844     d3d12_swapchain_SetSourceSize,
2845     d3d12_swapchain_GetSourceSize,
2846     d3d12_swapchain_SetMaximumFrameLatency,
2847     d3d12_swapchain_GetMaximumFrameLatency,
2848     d3d12_swapchain_GetFrameLatencyWaitableObject,
2849     d3d12_swapchain_SetMatrixTransform,
2850     d3d12_swapchain_GetMatrixTransform,
2851     /* IDXGISwapChain3 methods */
2852     d3d12_swapchain_GetCurrentBackBufferIndex,
2853     d3d12_swapchain_CheckColorSpaceSupport,
2854     d3d12_swapchain_SetColorSpace1,
2855     d3d12_swapchain_ResizeBuffers1,
2856     /* IDXGISwapChain4 methods */
2857     d3d12_swapchain_SetHDRMetaData,
2858 };
2859
2860 static BOOL load_vkd3d_functions(void *vkd3d_handle)
2861 {
2862 #define LOAD_FUNCPTR(f) if (!(f = get_library_proc(vkd3d_handle, #f))) return FALSE;
2863     LOAD_FUNCPTR(vkd3d_acquire_vk_queue)
2864     LOAD_FUNCPTR(vkd3d_create_image_resource)
2865     LOAD_FUNCPTR(vkd3d_get_device_parent)
2866     LOAD_FUNCPTR(vkd3d_get_vk_device)
2867     LOAD_FUNCPTR(vkd3d_get_vk_format)
2868     LOAD_FUNCPTR(vkd3d_get_vk_physical_device)
2869     LOAD_FUNCPTR(vkd3d_get_vk_queue_family_index)
2870     LOAD_FUNCPTR(vkd3d_instance_from_device)
2871     LOAD_FUNCPTR(vkd3d_instance_get_vk_instance)
2872     LOAD_FUNCPTR(vkd3d_release_vk_queue)
2873     LOAD_FUNCPTR(vkd3d_resource_decref)
2874     LOAD_FUNCPTR(vkd3d_resource_incref)
2875 #undef LOAD_FUNCPTR
2876
2877     return TRUE;
2878 }
2879
2880 static void *vkd3d_handle;
2881
2882 static BOOL WINAPI init_vkd3d_once(INIT_ONCE *once, void *param, void **context)
2883 {
2884     TRACE("Loading vkd3d %s.\n", SONAME_LIBVKD3D);
2885
2886     if (!(vkd3d_handle = load_library(SONAME_LIBVKD3D)))
2887         return FALSE;
2888
2889     if (!load_vkd3d_functions(vkd3d_handle))
2890     {
2891         ERR("Failed to load vkd3d functions.\n");
2892         close_library(vkd3d_handle);
2893         vkd3d_handle = NULL;
2894         return FALSE;
2895     }
2896
2897     return TRUE;
2898 }
2899
2900 static BOOL init_vkd3d(void)
2901 {
2902     static INIT_ONCE init_once = INIT_ONCE_STATIC_INIT;
2903     InitOnceExecuteOnce(&init_once, init_vkd3d_once, NULL, NULL);
2904     return !!vkd3d_handle;
2905 }
2906
2907 static BOOL init_vk_funcs(struct dxgi_vk_funcs *dxgi, VkInstance vk_instance, VkDevice vk_device)
2908 {
2909     PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr;
2910     PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr;
2911
2912     dxgi->vulkan_module = NULL;
2913
2914     if (!(vkGetInstanceProcAddr = load_vulkan(&dxgi->vulkan_module)))
2915     {
2916         ERR_(winediag)("Failed to load Vulkan.\n");
2917         return FALSE;
2918     }
2919
2920     vkGetDeviceProcAddr = (void *)vkGetInstanceProcAddr(vk_instance, "vkGetDeviceProcAddr");
2921
2922 #define LOAD_INSTANCE_PFN(name) \
2923     if (!(dxgi->p_##name = (void *)vkGetInstanceProcAddr(vk_instance, #name))) \
2924     { \
2925         ERR("Failed to get instance proc "#name".\n"); \
2926         close_library(dxgi->vulkan_module); \
2927         return FALSE; \
2928     }
2929     LOAD_INSTANCE_PFN(vkCreateWin32SurfaceKHR)
2930     LOAD_INSTANCE_PFN(vkDestroySurfaceKHR)
2931     LOAD_INSTANCE_PFN(vkGetPhysicalDeviceMemoryProperties)
2932     LOAD_INSTANCE_PFN(vkGetPhysicalDeviceSurfaceCapabilitiesKHR)
2933     LOAD_INSTANCE_PFN(vkGetPhysicalDeviceSurfaceFormatsKHR)
2934     LOAD_INSTANCE_PFN(vkGetPhysicalDeviceSurfacePresentModesKHR)
2935     LOAD_INSTANCE_PFN(vkGetPhysicalDeviceSurfaceSupportKHR)
2936     LOAD_INSTANCE_PFN(vkGetPhysicalDeviceWin32PresentationSupportKHR)
2937 #undef LOAD_INSTANCE_PFN
2938
2939 #define LOAD_DEVICE_PFN(name) \
2940     if (!(dxgi->p_##name = (void *)vkGetDeviceProcAddr(vk_device, #name))) \
2941     { \
2942         ERR("Failed to get device proc "#name".\n"); \
2943         close_library(dxgi->vulkan_module); \
2944         return FALSE; \
2945     }
2946     LOAD_DEVICE_PFN(vkAcquireNextImageKHR)
2947     LOAD_DEVICE_PFN(vkAllocateCommandBuffers)
2948     LOAD_DEVICE_PFN(vkAllocateMemory)
2949     LOAD_DEVICE_PFN(vkBeginCommandBuffer)
2950     LOAD_DEVICE_PFN(vkBindImageMemory)
2951     LOAD_DEVICE_PFN(vkCmdBlitImage)
2952     LOAD_DEVICE_PFN(vkCmdPipelineBarrier)
2953     LOAD_DEVICE_PFN(vkCreateCommandPool)
2954     LOAD_DEVICE_PFN(vkCreateFence)
2955     LOAD_DEVICE_PFN(vkCreateImage)
2956     LOAD_DEVICE_PFN(vkCreateSemaphore)
2957     LOAD_DEVICE_PFN(vkCreateSwapchainKHR)
2958     LOAD_DEVICE_PFN(vkDestroyCommandPool)
2959     LOAD_DEVICE_PFN(vkDestroyFence)
2960     LOAD_DEVICE_PFN(vkDestroyImage)
2961     LOAD_DEVICE_PFN(vkDestroySemaphore)
2962     LOAD_DEVICE_PFN(vkDestroySwapchainKHR)
2963     LOAD_DEVICE_PFN(vkEndCommandBuffer)
2964     LOAD_DEVICE_PFN(vkFreeMemory)
2965     LOAD_DEVICE_PFN(vkResetCommandBuffer)
2966     LOAD_DEVICE_PFN(vkGetImageMemoryRequirements)
2967     LOAD_DEVICE_PFN(vkGetSwapchainImagesKHR)
2968     LOAD_DEVICE_PFN(vkQueuePresentKHR)
2969     LOAD_DEVICE_PFN(vkQueueSubmit)
2970     LOAD_DEVICE_PFN(vkQueueWaitIdle)
2971     LOAD_DEVICE_PFN(vkResetFences)
2972     LOAD_DEVICE_PFN(vkWaitForFences)
2973 #undef LOAD_DEVICE_PFN
2974
2975     return TRUE;
2976 }
2977
2978 static inline struct d3d12_swapchain *d3d12_swapchain_from_wined3d_swapchain_state_parent(struct wined3d_swapchain_state_parent *parent)
2979 {
2980     return CONTAINING_RECORD(parent, struct d3d12_swapchain, state_parent);
2981 }
2982
2983 static void CDECL d3d12_swapchain_windowed_state_changed(struct wined3d_swapchain_state_parent *parent,
2984         BOOL windowed)
2985 {
2986     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_wined3d_swapchain_state_parent(parent);
2987
2988     TRACE("parent %p, windowed %d.\n", parent, windowed);
2989
2990     if (windowed && swapchain->target)
2991     {
2992         IDXGIOutput_Release(swapchain->target);
2993         swapchain->target = NULL;
2994     }
2995 }
2996
2997 static const struct wined3d_swapchain_state_parent_ops d3d12_swapchain_state_parent_ops =
2998 {
2999     d3d12_swapchain_windowed_state_changed,
3000 };
3001
3002 static HRESULT d3d12_swapchain_init(struct d3d12_swapchain *swapchain, IWineDXGIFactory *factory,
3003         ID3D12Device *device, ID3D12CommandQueue *queue, HWND window,
3004         const DXGI_SWAP_CHAIN_DESC1 *swapchain_desc, const DXGI_SWAP_CHAIN_FULLSCREEN_DESC *fullscreen_desc)
3005 {
3006     const struct dxgi_vk_funcs *vk_funcs = &swapchain->vk_funcs;
3007     struct wined3d_swapchain_desc wined3d_desc;
3008     VkWin32SurfaceCreateInfoKHR surface_desc;
3009     VkPhysicalDevice vk_physical_device;
3010     struct dxgi_factory *dxgi_factory;
3011     VkFenceCreateInfo fence_desc;
3012     uint32_t queue_family_index;
3013     VkSurfaceKHR vk_surface;
3014     VkInstance vk_instance;
3015     IDXGIOutput *output;
3016     VkBool32 supported;
3017     VkDevice vk_device;
3018     VkFence vk_fence;
3019     VkResult vr;
3020     HRESULT hr;
3021
3022     if (window == GetDesktopWindow())
3023     {
3024         WARN("D3D12 swapchain cannot be created on desktop window.\n");
3025         return E_ACCESSDENIED;
3026     }
3027
3028     swapchain->IDXGISwapChain4_iface.lpVtbl = &d3d12_swapchain_vtbl;
3029     swapchain->state_parent.ops = &d3d12_swapchain_state_parent_ops;
3030     swapchain->refcount = 1;
3031
3032     swapchain->window = window;
3033     swapchain->desc = *swapchain_desc;
3034     swapchain->fullscreen_desc = *fullscreen_desc;
3035
3036     swapchain->present_mode = VK_PRESENT_MODE_FIFO_KHR;
3037
3038     switch (swapchain_desc->SwapEffect)
3039     {
3040         case DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL:
3041         case DXGI_SWAP_EFFECT_FLIP_DISCARD:
3042             FIXME("Ignoring swap effect %#x.\n", swapchain_desc->SwapEffect);
3043             break;
3044         default:
3045             WARN("Invalid swap effect %#x.\n", swapchain_desc->SwapEffect);
3046             return DXGI_ERROR_INVALID_CALL;
3047     }
3048
3049     if (!init_vkd3d())
3050     {
3051         ERR_(winediag)("libvkd3d could not be loaded.\n");
3052         return DXGI_ERROR_UNSUPPORTED;
3053     }
3054
3055     if (FAILED(hr = dxgi_get_output_from_window(factory, window, &output)))
3056     {
3057         WARN("Failed to get output from window %p, hr %#x.\n", window, hr);
3058         return hr;
3059     }
3060
3061     hr = wined3d_swapchain_desc_from_dxgi(&wined3d_desc, output, window, swapchain_desc,
3062             fullscreen_desc);
3063     if (FAILED(hr))
3064     {
3065         IDXGIOutput_Release(output);
3066         return hr;
3067     }
3068
3069     dxgi_factory = unsafe_impl_from_IDXGIFactory((IDXGIFactory *)factory);
3070     if (FAILED(hr = wined3d_swapchain_state_create(&wined3d_desc, window, dxgi_factory->wined3d,
3071             &swapchain->state_parent, &swapchain->state)))
3072     {
3073         IDXGIOutput_Release(output);
3074         return hr;
3075     }
3076
3077     if (!fullscreen_desc->Windowed)
3078     {
3079         hr = wined3d_swapchain_state_set_fullscreen(swapchain->state, &wined3d_desc, NULL);
3080         if (FAILED(hr))
3081         {
3082             wined3d_swapchain_state_destroy(swapchain->state);
3083             IDXGIOutput_Release(output);
3084             return hr;
3085         }
3086
3087         swapchain->target = output;
3088     }
3089     else
3090     {
3091         IDXGIOutput_Release(output);
3092     }
3093
3094     if (swapchain_desc->BufferUsage && swapchain_desc->BufferUsage != DXGI_USAGE_RENDER_TARGET_OUTPUT)
3095         FIXME("Ignoring buffer usage %#x.\n", swapchain_desc->BufferUsage);
3096     if (swapchain_desc->Scaling != DXGI_SCALING_STRETCH && swapchain_desc->Scaling != DXGI_SCALING_NONE)
3097         FIXME("Ignoring scaling %#x.\n", swapchain_desc->Scaling);
3098     if (swapchain_desc->AlphaMode && swapchain_desc->AlphaMode != DXGI_ALPHA_MODE_IGNORE)
3099         FIXME("Ignoring alpha mode %#x.\n", swapchain_desc->AlphaMode);
3100     if (swapchain_desc->Flags & ~(DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT))
3101         FIXME("Ignoring swapchain flags %#x.\n", swapchain_desc->Flags);
3102
3103     if (fullscreen_desc->RefreshRate.Numerator || fullscreen_desc->RefreshRate.Denominator)
3104         FIXME("Ignoring refresh rate.\n");
3105     if (fullscreen_desc->ScanlineOrdering)
3106         FIXME("Unhandled scanline ordering %#x.\n", fullscreen_desc->ScanlineOrdering);
3107     if (fullscreen_desc->Scaling)
3108         FIXME("Unhandled mode scaling %#x.\n", fullscreen_desc->Scaling);
3109
3110     vk_instance = vkd3d_instance_get_vk_instance(vkd3d_instance_from_device(device));
3111     vk_physical_device = vkd3d_get_vk_physical_device(device);
3112     vk_device = vkd3d_get_vk_device(device);
3113
3114     swapchain->vk_instance = vk_instance;
3115     swapchain->vk_device = vk_device;
3116     swapchain->vk_physical_device = vk_physical_device;
3117
3118     if (!init_vk_funcs(&swapchain->vk_funcs, vk_instance, vk_device))
3119     {
3120         wined3d_swapchain_state_destroy(swapchain->state);
3121         return E_FAIL;
3122     }
3123
3124     wined3d_private_store_init(&swapchain->private_store);
3125
3126     surface_desc.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
3127     surface_desc.pNext = NULL;
3128     surface_desc.flags = 0;
3129     surface_desc.hinstance = GetModuleHandleA("dxgi.dll");
3130     surface_desc.hwnd = window;
3131     if ((vr = vk_funcs->p_vkCreateWin32SurfaceKHR(vk_instance, &surface_desc, NULL, &vk_surface)) < 0)
3132     {
3133         WARN("Failed to create Vulkan surface, vr %d.\n", vr);
3134         d3d12_swapchain_destroy(swapchain);
3135         return hresult_from_vk_result(vr);
3136     }
3137     swapchain->vk_surface = vk_surface;
3138
3139     queue_family_index = vkd3d_get_vk_queue_family_index(queue);
3140     if ((vr = vk_funcs->p_vkGetPhysicalDeviceSurfaceSupportKHR(vk_physical_device,
3141             queue_family_index, vk_surface, &supported)) < 0 || !supported)
3142     {
3143         FIXME("Queue family does not support presentation, vr %d.\n", vr);
3144         d3d12_swapchain_destroy(swapchain);
3145         return DXGI_ERROR_UNSUPPORTED;
3146     }
3147
3148     ID3D12CommandQueue_AddRef(swapchain->command_queue = queue);
3149     ID3D12Device_AddRef(swapchain->device = device);
3150
3151     if (FAILED(hr = d3d12_swapchain_create_vulkan_swapchain(swapchain)))
3152     {
3153         d3d12_swapchain_destroy(swapchain);
3154         return hr;
3155     }
3156
3157     fence_desc.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
3158     fence_desc.pNext = NULL;
3159     fence_desc.flags = 0;
3160     if ((vr = vk_funcs->p_vkCreateFence(vk_device, &fence_desc, NULL, &vk_fence)) < 0)
3161     {
3162         WARN("Failed to create Vulkan fence, vr %d.\n", vr);
3163         d3d12_swapchain_destroy(swapchain);
3164         return hresult_from_vk_result(vr);
3165     }
3166     swapchain->vk_fence = vk_fence;
3167
3168     swapchain->current_buffer_index = 0;
3169     if ((vr = d3d12_swapchain_acquire_next_back_buffer(swapchain)) < 0)
3170     {
3171         d3d12_swapchain_destroy(swapchain);
3172         return hresult_from_vk_result(vr);
3173     }
3174
3175     if (swapchain_desc->Flags & DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT)
3176     {
3177         swapchain->frame_number = DXGI_MAX_SWAP_CHAIN_BUFFERS;
3178         swapchain->frame_latency = 1;
3179
3180         if (FAILED(hr = ID3D12Device_CreateFence(device, DXGI_MAX_SWAP_CHAIN_BUFFERS,
3181                 0, &IID_ID3D12Fence, (void **)&swapchain->frame_latency_fence)))
3182         {
3183             WARN("Failed to create frame latency fence, hr %#x.\n", hr);
3184             d3d12_swapchain_destroy(swapchain);
3185             return hr;
3186         }
3187
3188         if (!(swapchain->frame_latency_event = CreateEventW(NULL, FALSE, TRUE, NULL)))
3189         {
3190             hr = HRESULT_FROM_WIN32(GetLastError());
3191             WARN("Failed to create frame latency event, hr %#x.\n", hr);
3192             d3d12_swapchain_destroy(swapchain);
3193             return hr;
3194         }
3195     }
3196
3197     IWineDXGIFactory_AddRef(swapchain->factory = factory);
3198
3199     return S_OK;
3200 }
3201
3202 HRESULT d3d12_swapchain_create(IWineDXGIFactory *factory, ID3D12CommandQueue *queue, HWND window,
3203         const DXGI_SWAP_CHAIN_DESC1 *swapchain_desc, const DXGI_SWAP_CHAIN_FULLSCREEN_DESC *fullscreen_desc,
3204         IDXGISwapChain1 **swapchain)
3205 {
3206     DXGI_SWAP_CHAIN_FULLSCREEN_DESC default_fullscreen_desc;
3207     struct d3d12_swapchain *object;
3208     ID3D12Device *device;
3209     HRESULT hr;
3210
3211     if (swapchain_desc->Format == DXGI_FORMAT_UNKNOWN)
3212         return DXGI_ERROR_INVALID_CALL;
3213
3214     if (!fullscreen_desc)
3215     {
3216         memset(&default_fullscreen_desc, 0, sizeof(default_fullscreen_desc));
3217         default_fullscreen_desc.Windowed = TRUE;
3218         fullscreen_desc = &default_fullscreen_desc;
3219     }
3220
3221     if (!(object = heap_alloc_zero(sizeof(*object))))
3222         return E_OUTOFMEMORY;
3223
3224     if (FAILED(hr = ID3D12CommandQueue_GetDevice(queue, &IID_ID3D12Device, (void **)&device)))
3225     {
3226         ERR("Failed to get D3D12 device, hr %#x.\n", hr);
3227         heap_free(object);
3228         return hr;
3229     }
3230
3231     hr = d3d12_swapchain_init(object, factory, device, queue, window, swapchain_desc, fullscreen_desc);
3232     ID3D12Device_Release(device);
3233     if (FAILED(hr))
3234     {
3235         heap_free(object);
3236         return hr;
3237     }
3238
3239     TRACE("Created swapchain %p.\n", object);
3240
3241     *swapchain = (IDXGISwapChain1 *)&object->IDXGISwapChain4_iface;
3242
3243     return S_OK;
3244 }
3245
3246 #else
3247
3248 HRESULT d3d12_swapchain_create(IWineDXGIFactory *factory, ID3D12CommandQueue *queue, HWND window,
3249         const DXGI_SWAP_CHAIN_DESC1 *swapchain_desc, const DXGI_SWAP_CHAIN_FULLSCREEN_DESC *fullscreen_desc,
3250         IDXGISwapChain1 **swapchain)
3251 {
3252     ERR_(winediag)("Wine was built without Direct3D 12 support.\n");
3253     return DXGI_ERROR_UNSUPPORTED;
3254 }
3255
3256 #endif  /* SONAME_LIBVKD3D */