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