2 * Copyright 2008 Henri Verbeet for CodeWeavers
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.
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.
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
21 #include "wine/port.h"
23 #include "dxgi_private.h"
25 #ifdef SONAME_LIBVKD3D
26 #define VK_NO_PROTOTYPES
27 #define VKD3D_NO_PROTOTYPES
28 #define VKD3D_NO_VULKAN_H
29 #define VKD3D_NO_WIN32_TYPES
30 #ifndef USE_WIN32_VULKAN
33 #include "wine/vulkan.h"
34 #include "wine/vulkan_driver.h"
38 WINE_DEFAULT_DEBUG_CHANNEL(dxgi
);
39 WINE_DECLARE_DEBUG_CHANNEL(winediag
);
41 static DXGI_SWAP_EFFECT
dxgi_swap_effect_from_wined3d(enum wined3d_swap_effect swap_effect
)
45 case WINED3D_SWAP_EFFECT_DISCARD
:
46 return DXGI_SWAP_EFFECT_DISCARD
;
47 case WINED3D_SWAP_EFFECT_SEQUENTIAL
:
48 return DXGI_SWAP_EFFECT_SEQUENTIAL
;
49 case WINED3D_SWAP_EFFECT_FLIP_DISCARD
:
50 return DXGI_SWAP_EFFECT_FLIP_DISCARD
;
51 case WINED3D_SWAP_EFFECT_FLIP_SEQUENTIAL
:
52 return DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL
;
54 FIXME("Invalid swap effect %#x.\n", swap_effect
);
55 return DXGI_SWAP_EFFECT_DISCARD
;
59 static BOOL
dxgi_validate_flip_swap_effect_format(DXGI_FORMAT format
)
63 case DXGI_FORMAT_R16G16B16A16_FLOAT
:
64 case DXGI_FORMAT_R10G10B10A2_UNORM
:
65 case DXGI_FORMAT_R8G8B8A8_UNORM
:
66 case DXGI_FORMAT_B8G8R8A8_UNORM
:
69 WARN("Invalid swapchain format %#x for flip presentation model.\n", format
);
74 BOOL
dxgi_validate_swapchain_desc(const DXGI_SWAP_CHAIN_DESC1
*desc
)
76 unsigned int min_buffer_count
;
78 switch (desc
->SwapEffect
)
80 case DXGI_SWAP_EFFECT_DISCARD
:
81 case DXGI_SWAP_EFFECT_SEQUENTIAL
:
85 case DXGI_SWAP_EFFECT_FLIP_DISCARD
:
86 case DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL
:
89 if (desc
->Format
&& !dxgi_validate_flip_swap_effect_format(desc
->Format
))
92 if (desc
->SampleDesc
.Count
!= 1 || desc
->SampleDesc
.Quality
)
94 WARN("Invalid sample desc %u, %u for swap effect %#x.\n",
95 desc
->SampleDesc
.Count
, desc
->SampleDesc
.Quality
, desc
->SwapEffect
);
101 WARN("Invalid swap effect %u used.\n", desc
->SwapEffect
);
105 if (desc
->BufferCount
< min_buffer_count
|| desc
->BufferCount
> DXGI_MAX_SWAP_CHAIN_BUFFERS
)
107 WARN("BufferCount is %u.\n", desc
->BufferCount
);
114 HRESULT
dxgi_get_output_from_window(IWineDXGIFactory
*factory
, HWND window
, IDXGIOutput
**dxgi_output
)
116 unsigned int adapter_idx
, output_idx
;
117 DXGI_OUTPUT_DESC desc
;
118 IDXGIAdapter
*adapter
;
123 if (!(monitor
= MonitorFromWindow(window
, MONITOR_DEFAULTTONEAREST
)))
125 WARN("Failed to get monitor from window.\n");
126 return DXGI_ERROR_INVALID_CALL
;
129 for (adapter_idx
= 0; SUCCEEDED(hr
= IWineDXGIFactory_EnumAdapters(factory
, adapter_idx
, &adapter
));
132 for (output_idx
= 0; SUCCEEDED(hr
= IDXGIAdapter_EnumOutputs(adapter
, output_idx
,
133 &output
)); ++output_idx
)
135 if (FAILED(hr
= IDXGIOutput_GetDesc(output
, &desc
)))
137 WARN("Adapter %u output %u: Failed to get output desc, hr %#x.\n", adapter_idx
,
139 IDXGIOutput_Release(output
);
143 if (desc
.Monitor
== monitor
)
145 *dxgi_output
= output
;
146 IDXGIAdapter_Release(adapter
);
150 IDXGIOutput_Release(output
);
152 IDXGIAdapter_Release(adapter
);
155 if (hr
!= DXGI_ERROR_NOT_FOUND
)
156 WARN("Failed to enumerate outputs, hr %#x.\n", hr
);
158 WARN("Output could not be found.\n");
159 return DXGI_ERROR_NOT_FOUND
;
162 static HRESULT
dxgi_swapchain_resize_target(struct wined3d_swapchain_state
*state
,
163 const DXGI_MODE_DESC
*target_mode_desc
)
165 struct wined3d_display_mode mode
;
167 if (!target_mode_desc
)
169 WARN("Invalid pointer.\n");
170 return DXGI_ERROR_INVALID_CALL
;
173 TRACE("Mode: %s.\n", debug_dxgi_mode(target_mode_desc
));
175 if (target_mode_desc
->Scaling
)
176 FIXME("Ignoring scaling %#x.\n", target_mode_desc
->Scaling
);
178 wined3d_display_mode_from_dxgi(&mode
, target_mode_desc
);
180 return wined3d_swapchain_state_resize_target(state
, &mode
);
183 static HWND
d3d11_swapchain_get_hwnd(struct d3d11_swapchain
*swapchain
)
185 struct wined3d_swapchain_desc wined3d_desc
;
187 wined3d_mutex_lock();
188 wined3d_swapchain_get_desc(swapchain
->wined3d_swapchain
, &wined3d_desc
);
189 wined3d_mutex_unlock();
191 return wined3d_desc
.device_window
;
194 static inline struct d3d11_swapchain
*d3d11_swapchain_from_IDXGISwapChain1(IDXGISwapChain1
*iface
)
196 return CONTAINING_RECORD(iface
, struct d3d11_swapchain
, IDXGISwapChain1_iface
);
199 /* IUnknown methods */
201 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_QueryInterface(IDXGISwapChain1
*iface
, REFIID riid
, void **object
)
203 TRACE("iface %p, riid %s, object %p\n", iface
, debugstr_guid(riid
), object
);
205 if (IsEqualGUID(riid
, &IID_IUnknown
)
206 || IsEqualGUID(riid
, &IID_IDXGIObject
)
207 || IsEqualGUID(riid
, &IID_IDXGIDeviceSubObject
)
208 || IsEqualGUID(riid
, &IID_IDXGISwapChain
)
209 || IsEqualGUID(riid
, &IID_IDXGISwapChain1
))
211 IUnknown_AddRef(iface
);
216 WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid
));
219 return E_NOINTERFACE
;
222 static ULONG STDMETHODCALLTYPE
d3d11_swapchain_AddRef(IDXGISwapChain1
*iface
)
224 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
225 ULONG refcount
= InterlockedIncrement(&swapchain
->refcount
);
227 TRACE("%p increasing refcount to %u.\n", swapchain
, refcount
);
230 wined3d_swapchain_incref(swapchain
->wined3d_swapchain
);
235 static ULONG STDMETHODCALLTYPE
d3d11_swapchain_Release(IDXGISwapChain1
*iface
)
237 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
238 ULONG refcount
= InterlockedDecrement(&swapchain
->refcount
);
240 TRACE("%p decreasing refcount to %u.\n", swapchain
, refcount
);
244 IWineDXGIDevice
*device
= swapchain
->device
;
245 if (swapchain
->target
)
247 WARN("Releasing fullscreen swapchain.\n");
248 IDXGIOutput_Release(swapchain
->target
);
250 if (swapchain
->factory
)
251 IWineDXGIFactory_Release(swapchain
->factory
);
252 wined3d_swapchain_decref(swapchain
->wined3d_swapchain
);
254 IWineDXGIDevice_Release(device
);
260 /* IDXGIObject methods */
262 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_SetPrivateData(IDXGISwapChain1
*iface
,
263 REFGUID guid
, UINT data_size
, const void *data
)
265 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
267 TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface
, debugstr_guid(guid
), data_size
, data
);
269 return dxgi_set_private_data(&swapchain
->private_store
, guid
, data_size
, data
);
272 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_SetPrivateDataInterface(IDXGISwapChain1
*iface
,
273 REFGUID guid
, const IUnknown
*object
)
275 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
277 TRACE("iface %p, guid %s, object %p.\n", iface
, debugstr_guid(guid
), object
);
279 return dxgi_set_private_data_interface(&swapchain
->private_store
, guid
, object
);
282 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetPrivateData(IDXGISwapChain1
*iface
,
283 REFGUID guid
, UINT
*data_size
, void *data
)
285 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
287 TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface
, debugstr_guid(guid
), data_size
, data
);
289 return dxgi_get_private_data(&swapchain
->private_store
, guid
, data_size
, data
);
292 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetParent(IDXGISwapChain1
*iface
, REFIID riid
, void **parent
)
294 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
296 TRACE("iface %p, riid %s, parent %p.\n", iface
, debugstr_guid(riid
), parent
);
298 if (!swapchain
->factory
)
300 ERR("Implicit swapchain does not store reference to parent.\n");
302 return E_NOINTERFACE
;
305 return IWineDXGIFactory_QueryInterface(swapchain
->factory
, riid
, parent
);
308 /* IDXGIDeviceSubObject methods */
310 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetDevice(IDXGISwapChain1
*iface
, REFIID riid
, void **device
)
312 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
314 TRACE("iface %p, riid %s, device %p.\n", iface
, debugstr_guid(riid
), device
);
316 if (!swapchain
->device
)
318 ERR("Implicit swapchain does not store reference to device.\n");
320 return E_NOINTERFACE
;
323 return IWineDXGIDevice_QueryInterface(swapchain
->device
, riid
, device
);
326 /* IDXGISwapChain1 methods */
328 static HRESULT
d3d11_swapchain_present(struct d3d11_swapchain
*swapchain
,
329 unsigned int sync_interval
, unsigned int flags
)
333 if (sync_interval
> 4)
335 WARN("Invalid sync interval %u.\n", sync_interval
);
336 return DXGI_ERROR_INVALID_CALL
;
339 if (IsIconic(d3d11_swapchain_get_hwnd(swapchain
)))
340 return DXGI_STATUS_OCCLUDED
;
342 if (flags
& ~DXGI_PRESENT_TEST
)
343 FIXME("Unimplemented flags %#x.\n", flags
);
344 if (flags
& DXGI_PRESENT_TEST
)
346 WARN("Returning S_OK for DXGI_PRESENT_TEST.\n");
350 if (SUCCEEDED(hr
= wined3d_swapchain_present(swapchain
->wined3d_swapchain
, NULL
, NULL
, NULL
, sync_interval
, 0)))
351 InterlockedIncrement(&swapchain
->present_count
);
355 static HRESULT STDMETHODCALLTYPE DECLSPEC_HOTPATCH
d3d11_swapchain_Present(IDXGISwapChain1
*iface
, UINT sync_interval
, UINT flags
)
357 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
359 TRACE("iface %p, sync_interval %u, flags %#x.\n", iface
, sync_interval
, flags
);
361 return d3d11_swapchain_present(swapchain
, sync_interval
, flags
);
364 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetBuffer(IDXGISwapChain1
*iface
,
365 UINT buffer_idx
, REFIID riid
, void **surface
)
367 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
368 struct wined3d_texture
*texture
;
372 TRACE("iface %p, buffer_idx %u, riid %s, surface %p\n",
373 iface
, buffer_idx
, debugstr_guid(riid
), surface
);
375 wined3d_mutex_lock();
377 if (!(texture
= wined3d_swapchain_get_back_buffer(swapchain
->wined3d_swapchain
, buffer_idx
)))
379 wined3d_mutex_unlock();
380 return DXGI_ERROR_INVALID_CALL
;
383 parent
= wined3d_texture_get_parent(texture
);
384 hr
= IUnknown_QueryInterface(parent
, riid
, surface
);
385 wined3d_mutex_unlock();
390 static HRESULT STDMETHODCALLTYPE DECLSPEC_HOTPATCH
d3d11_swapchain_SetFullscreenState(IDXGISwapChain1
*iface
,
391 BOOL fullscreen
, IDXGIOutput
*target
)
393 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
394 struct wined3d_swapchain_desc swapchain_desc
;
395 struct wined3d_swapchain_state
*state
;
396 struct dxgi_output
*dxgi_output
;
399 TRACE("iface %p, fullscreen %#x, target %p.\n", iface
, fullscreen
, target
);
401 if (!fullscreen
&& target
)
403 WARN("Invalid call.\n");
404 return DXGI_ERROR_INVALID_CALL
;
409 IDXGIOutput_AddRef(target
);
411 else if (FAILED(hr
= IDXGISwapChain1_GetContainingOutput(iface
, &target
)))
413 WARN("Failed to get target output for swapchain, hr %#x.\n", hr
);
416 dxgi_output
= unsafe_impl_from_IDXGIOutput(target
);
418 wined3d_mutex_lock();
419 state
= wined3d_swapchain_get_state(swapchain
->wined3d_swapchain
);
420 wined3d_swapchain_get_desc(swapchain
->wined3d_swapchain
, &swapchain_desc
);
421 swapchain_desc
.output
= dxgi_output
->wined3d_output
;
422 swapchain_desc
.windowed
= !fullscreen
;
423 hr
= wined3d_swapchain_state_set_fullscreen(state
, &swapchain_desc
, NULL
);
424 wined3d_mutex_unlock();
427 IDXGIOutput_Release(target
);
429 return DXGI_ERROR_NOT_CURRENTLY_AVAILABLE
;
434 IDXGIOutput_Release(target
);
438 if (swapchain
->target
)
439 IDXGIOutput_Release(swapchain
->target
);
440 swapchain
->target
= target
;
445 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetFullscreenState(IDXGISwapChain1
*iface
,
446 BOOL
*fullscreen
, IDXGIOutput
**target
)
448 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
449 struct wined3d_swapchain_desc swapchain_desc
;
452 TRACE("iface %p, fullscreen %p, target %p.\n", iface
, fullscreen
, target
);
454 if (fullscreen
|| target
)
456 wined3d_mutex_lock();
457 wined3d_swapchain_get_desc(swapchain
->wined3d_swapchain
, &swapchain_desc
);
458 wined3d_mutex_unlock();
462 *fullscreen
= !swapchain_desc
.windowed
;
466 if (!swapchain_desc
.windowed
)
468 if (!swapchain
->target
&& FAILED(hr
= IDXGISwapChain1_GetContainingOutput(iface
, &swapchain
->target
)))
471 *target
= swapchain
->target
;
472 IDXGIOutput_AddRef(*target
);
483 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetDesc(IDXGISwapChain1
*iface
, DXGI_SWAP_CHAIN_DESC
*desc
)
485 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
486 struct wined3d_swapchain_desc wined3d_desc
;
488 TRACE("iface %p, desc %p.\n", iface
, desc
);
492 WARN("Invalid pointer.\n");
496 wined3d_mutex_lock();
497 wined3d_swapchain_get_desc(swapchain
->wined3d_swapchain
, &wined3d_desc
);
498 wined3d_mutex_unlock();
500 FIXME("Ignoring ScanlineOrdering and Scaling.\n");
502 desc
->BufferDesc
.Width
= wined3d_desc
.backbuffer_width
;
503 desc
->BufferDesc
.Height
= wined3d_desc
.backbuffer_height
;
504 desc
->BufferDesc
.RefreshRate
.Numerator
= wined3d_desc
.refresh_rate
;
505 desc
->BufferDesc
.RefreshRate
.Denominator
= 1;
506 desc
->BufferDesc
.Format
= dxgi_format_from_wined3dformat(wined3d_desc
.backbuffer_format
);
507 desc
->BufferDesc
.ScanlineOrdering
= DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED
;
508 desc
->BufferDesc
.Scaling
= DXGI_MODE_SCALING_UNSPECIFIED
;
509 dxgi_sample_desc_from_wined3d(&desc
->SampleDesc
,
510 wined3d_desc
.multisample_type
, wined3d_desc
.multisample_quality
);
511 desc
->BufferUsage
= dxgi_usage_from_wined3d_bind_flags(wined3d_desc
.backbuffer_bind_flags
);
512 desc
->BufferCount
= wined3d_desc
.backbuffer_count
;
513 desc
->OutputWindow
= wined3d_desc
.device_window
;
514 desc
->Windowed
= wined3d_desc
.windowed
;
515 desc
->SwapEffect
= dxgi_swap_effect_from_wined3d(wined3d_desc
.swap_effect
);
516 desc
->Flags
= dxgi_swapchain_flags_from_wined3d(wined3d_desc
.flags
);
521 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_ResizeBuffers(IDXGISwapChain1
*iface
,
522 UINT buffer_count
, UINT width
, UINT height
, DXGI_FORMAT format
, UINT flags
)
524 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
525 struct wined3d_swapchain_desc wined3d_desc
;
526 struct wined3d_texture
*texture
;
531 TRACE("iface %p, buffer_count %u, width %u, height %u, format %s, flags %#x.\n",
532 iface
, buffer_count
, width
, height
, debug_dxgi_format(format
), flags
);
535 FIXME("Ignoring flags %#x.\n", flags
);
537 wined3d_mutex_lock();
538 wined3d_swapchain_get_desc(swapchain
->wined3d_swapchain
, &wined3d_desc
);
539 for (i
= 0; i
< wined3d_desc
.backbuffer_count
; ++i
)
541 texture
= wined3d_swapchain_get_back_buffer(swapchain
->wined3d_swapchain
, i
);
542 parent
= wined3d_texture_get_parent(texture
);
543 IUnknown_AddRef(parent
);
544 if (IUnknown_Release(parent
))
546 wined3d_mutex_unlock();
547 return DXGI_ERROR_INVALID_CALL
;
550 if (format
!= DXGI_FORMAT_UNKNOWN
)
551 wined3d_desc
.backbuffer_format
= wined3dformat_from_dxgi_format(format
);
552 hr
= wined3d_swapchain_resize_buffers(swapchain
->wined3d_swapchain
, buffer_count
, width
, height
,
553 wined3d_desc
.backbuffer_format
, wined3d_desc
.multisample_type
, wined3d_desc
.multisample_quality
);
554 wined3d_mutex_unlock();
559 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_ResizeTarget(IDXGISwapChain1
*iface
,
560 const DXGI_MODE_DESC
*target_mode_desc
)
562 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
563 struct wined3d_swapchain_state
*state
;
565 TRACE("iface %p, target_mode_desc %p.\n", iface
, target_mode_desc
);
567 state
= wined3d_swapchain_get_state(swapchain
->wined3d_swapchain
);
569 return dxgi_swapchain_resize_target(state
, target_mode_desc
);
572 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetContainingOutput(IDXGISwapChain1
*iface
, IDXGIOutput
**output
)
574 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
577 TRACE("iface %p, output %p.\n", iface
, output
);
579 if (swapchain
->target
)
581 IDXGIOutput_AddRef(*output
= swapchain
->target
);
585 if (!swapchain
->factory
)
587 ERR("Implicit swapchain does not store a reference to factory.\n");
588 return E_NOINTERFACE
;
591 window
= d3d11_swapchain_get_hwnd(swapchain
);
592 return dxgi_get_output_from_window(swapchain
->factory
, window
, output
);
595 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetFrameStatistics(IDXGISwapChain1
*iface
,
596 DXGI_FRAME_STATISTICS
*stats
)
598 FIXME("iface %p, stats %p stub!\n", iface
, stats
);
603 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetLastPresentCount(IDXGISwapChain1
*iface
,
604 UINT
*last_present_count
)
606 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
608 TRACE("iface %p, last_present_count %p.\n", iface
, last_present_count
);
610 *last_present_count
= swapchain
->present_count
;
615 /* IDXGISwapChain1 methods */
617 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetDesc1(IDXGISwapChain1
*iface
, DXGI_SWAP_CHAIN_DESC1
*desc
)
619 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
620 struct wined3d_swapchain_desc wined3d_desc
;
622 TRACE("iface %p, desc %p.\n", iface
, desc
);
626 WARN("Invalid pointer.\n");
630 wined3d_mutex_lock();
631 wined3d_swapchain_get_desc(swapchain
->wined3d_swapchain
, &wined3d_desc
);
632 wined3d_mutex_unlock();
634 FIXME("Ignoring Stereo, Scaling and AlphaMode.\n");
636 desc
->Width
= wined3d_desc
.backbuffer_width
;
637 desc
->Height
= wined3d_desc
.backbuffer_height
;
638 desc
->Format
= dxgi_format_from_wined3dformat(wined3d_desc
.backbuffer_format
);
639 desc
->Stereo
= FALSE
;
640 dxgi_sample_desc_from_wined3d(&desc
->SampleDesc
,
641 wined3d_desc
.multisample_type
, wined3d_desc
.multisample_quality
);
642 desc
->BufferUsage
= dxgi_usage_from_wined3d_bind_flags(wined3d_desc
.backbuffer_bind_flags
);
643 desc
->BufferCount
= wined3d_desc
.backbuffer_count
;
644 desc
->Scaling
= DXGI_SCALING_STRETCH
;
645 desc
->SwapEffect
= dxgi_swap_effect_from_wined3d(wined3d_desc
.swap_effect
);
646 desc
->AlphaMode
= DXGI_ALPHA_MODE_IGNORE
;
647 desc
->Flags
= dxgi_swapchain_flags_from_wined3d(wined3d_desc
.flags
);
652 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetFullscreenDesc(IDXGISwapChain1
*iface
,
653 DXGI_SWAP_CHAIN_FULLSCREEN_DESC
*desc
)
655 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
656 struct wined3d_swapchain_desc wined3d_desc
;
658 TRACE("iface %p, desc %p.\n", iface
, desc
);
662 WARN("Invalid pointer.\n");
666 wined3d_mutex_lock();
667 wined3d_swapchain_get_desc(swapchain
->wined3d_swapchain
, &wined3d_desc
);
668 wined3d_mutex_unlock();
670 FIXME("Ignoring ScanlineOrdering and Scaling.\n");
672 desc
->RefreshRate
.Numerator
= wined3d_desc
.refresh_rate
;
673 desc
->RefreshRate
.Denominator
= 1;
674 desc
->ScanlineOrdering
= DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED
;
675 desc
->Scaling
= DXGI_MODE_SCALING_UNSPECIFIED
;
676 desc
->Windowed
= wined3d_desc
.windowed
;
681 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetHwnd(IDXGISwapChain1
*iface
, HWND
*hwnd
)
683 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
685 TRACE("iface %p, hwnd %p.\n", iface
, hwnd
);
689 WARN("Invalid pointer.\n");
690 return DXGI_ERROR_INVALID_CALL
;
693 *hwnd
= d3d11_swapchain_get_hwnd(swapchain
);
697 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetCoreWindow(IDXGISwapChain1
*iface
,
698 REFIID iid
, void **core_window
)
700 FIXME("iface %p, iid %s, core_window %p stub!\n", iface
, debugstr_guid(iid
), core_window
);
705 return DXGI_ERROR_INVALID_CALL
;
708 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_Present1(IDXGISwapChain1
*iface
,
709 UINT sync_interval
, UINT flags
, const DXGI_PRESENT_PARAMETERS
*present_parameters
)
711 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
713 TRACE("iface %p, sync_interval %u, flags %#x, present_parameters %p.\n",
714 iface
, sync_interval
, flags
, present_parameters
);
716 if (present_parameters
)
717 FIXME("Ignored present parameters %p.\n", present_parameters
);
719 return d3d11_swapchain_present(swapchain
, sync_interval
, flags
);
722 static BOOL STDMETHODCALLTYPE
d3d11_swapchain_IsTemporaryMonoSupported(IDXGISwapChain1
*iface
)
724 FIXME("iface %p stub!\n", iface
);
729 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetRestrictToOutput(IDXGISwapChain1
*iface
, IDXGIOutput
**output
)
731 FIXME("iface %p, output %p stub!\n", iface
, output
);
735 WARN("Invalid pointer.\n");
743 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_SetBackgroundColor(IDXGISwapChain1
*iface
, const DXGI_RGBA
*color
)
745 FIXME("iface %p, color %p stub!\n", iface
, color
);
750 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetBackgroundColor(IDXGISwapChain1
*iface
, DXGI_RGBA
*color
)
752 FIXME("iface %p, color %p stub!\n", iface
, color
);
757 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_SetRotation(IDXGISwapChain1
*iface
, DXGI_MODE_ROTATION rotation
)
759 FIXME("iface %p, rotation %#x stub!\n", iface
, rotation
);
764 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetRotation(IDXGISwapChain1
*iface
, DXGI_MODE_ROTATION
*rotation
)
766 FIXME("iface %p, rotation %p stub!\n", iface
, rotation
);
771 static const struct IDXGISwapChain1Vtbl d3d11_swapchain_vtbl
=
773 /* IUnknown methods */
774 d3d11_swapchain_QueryInterface
,
775 d3d11_swapchain_AddRef
,
776 d3d11_swapchain_Release
,
777 /* IDXGIObject methods */
778 d3d11_swapchain_SetPrivateData
,
779 d3d11_swapchain_SetPrivateDataInterface
,
780 d3d11_swapchain_GetPrivateData
,
781 d3d11_swapchain_GetParent
,
782 /* IDXGIDeviceSubObject methods */
783 d3d11_swapchain_GetDevice
,
784 /* IDXGISwapChain methods */
785 d3d11_swapchain_Present
,
786 d3d11_swapchain_GetBuffer
,
787 d3d11_swapchain_SetFullscreenState
,
788 d3d11_swapchain_GetFullscreenState
,
789 d3d11_swapchain_GetDesc
,
790 d3d11_swapchain_ResizeBuffers
,
791 d3d11_swapchain_ResizeTarget
,
792 d3d11_swapchain_GetContainingOutput
,
793 d3d11_swapchain_GetFrameStatistics
,
794 d3d11_swapchain_GetLastPresentCount
,
795 /* IDXGISwapChain1 methods */
796 d3d11_swapchain_GetDesc1
,
797 d3d11_swapchain_GetFullscreenDesc
,
798 d3d11_swapchain_GetHwnd
,
799 d3d11_swapchain_GetCoreWindow
,
800 d3d11_swapchain_Present1
,
801 d3d11_swapchain_IsTemporaryMonoSupported
,
802 d3d11_swapchain_GetRestrictToOutput
,
803 d3d11_swapchain_SetBackgroundColor
,
804 d3d11_swapchain_GetBackgroundColor
,
805 d3d11_swapchain_SetRotation
,
806 d3d11_swapchain_GetRotation
,
809 static void STDMETHODCALLTYPE
d3d11_swapchain_wined3d_object_released(void *parent
)
811 struct d3d11_swapchain
*swapchain
= parent
;
813 wined3d_private_store_cleanup(&swapchain
->private_store
);
817 static const struct wined3d_parent_ops d3d11_swapchain_wined3d_parent_ops
=
819 d3d11_swapchain_wined3d_object_released
,
822 static inline struct d3d11_swapchain
*d3d11_swapchain_from_wined3d_swapchain_state_parent(struct wined3d_swapchain_state_parent
*parent
)
824 return CONTAINING_RECORD(parent
, struct d3d11_swapchain
, state_parent
);
827 static void CDECL
d3d11_swapchain_windowed_state_changed(struct wined3d_swapchain_state_parent
*parent
,
830 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_wined3d_swapchain_state_parent(parent
);
832 TRACE("parent %p, windowed %d.\n", parent
, windowed
);
834 if (windowed
&& swapchain
->target
)
836 IDXGIOutput_Release(swapchain
->target
);
837 swapchain
->target
= NULL
;
841 static const struct wined3d_swapchain_state_parent_ops d3d11_swapchain_state_parent_ops
=
843 d3d11_swapchain_windowed_state_changed
,
846 HRESULT
d3d11_swapchain_init(struct d3d11_swapchain
*swapchain
, struct dxgi_device
*device
,
847 struct wined3d_swapchain_desc
*desc
)
852 /* A reference to the implicit swapchain is held by the wined3d device. In
853 * order to avoid circular references we do not keep a reference to the
854 * device in the implicit swapchain. */
855 if (!(desc
->flags
& WINED3D_SWAPCHAIN_IMPLICIT
))
857 if (desc
->backbuffer_format
== WINED3DFMT_UNKNOWN
)
860 if (FAILED(hr
= IWineDXGIAdapter_GetParent(device
->adapter
,
861 &IID_IWineDXGIFactory
, (void **)&swapchain
->factory
)))
863 WARN("Failed to get adapter parent, hr %#x.\n", hr
);
866 IWineDXGIDevice_AddRef(swapchain
->device
= &device
->IWineDXGIDevice_iface
);
870 swapchain
->device
= NULL
;
871 swapchain
->factory
= NULL
;
874 swapchain
->IDXGISwapChain1_iface
.lpVtbl
= &d3d11_swapchain_vtbl
;
875 swapchain
->state_parent
.ops
= &d3d11_swapchain_state_parent_ops
;
876 swapchain
->refcount
= 1;
877 wined3d_mutex_lock();
878 wined3d_private_store_init(&swapchain
->private_store
);
880 if (!desc
->windowed
&& (!desc
->backbuffer_width
|| !desc
->backbuffer_height
))
881 FIXME("Fullscreen swapchain with back buffer width/height equal to 0 not supported properly.\n");
883 fullscreen
= !desc
->windowed
;
884 desc
->windowed
= TRUE
;
885 if (FAILED(hr
= wined3d_swapchain_create(device
->wined3d_device
, desc
, &swapchain
->state_parent
,
886 swapchain
, &d3d11_swapchain_wined3d_parent_ops
, &swapchain
->wined3d_swapchain
)))
888 WARN("Failed to create wined3d swapchain, hr %#x.\n", hr
);
892 swapchain
->target
= NULL
;
895 struct wined3d_swapchain_state
*state
;
897 desc
->windowed
= FALSE
;
898 state
= wined3d_swapchain_get_state(swapchain
->wined3d_swapchain
);
900 if (FAILED(hr
= IDXGISwapChain1_GetContainingOutput(&swapchain
->IDXGISwapChain1_iface
,
901 &swapchain
->target
)))
903 WARN("Failed to get target output for fullscreen swapchain, hr %#x.\n", hr
);
904 wined3d_swapchain_decref(swapchain
->wined3d_swapchain
);
908 if (FAILED(hr
= wined3d_swapchain_state_set_fullscreen(state
, desc
, NULL
)))
910 WARN("Failed to set fullscreen state, hr %#x.\n", hr
);
911 IDXGIOutput_Release(swapchain
->target
);
912 wined3d_swapchain_decref(swapchain
->wined3d_swapchain
);
917 wined3d_mutex_unlock();
922 wined3d_private_store_cleanup(&swapchain
->private_store
);
923 wined3d_mutex_unlock();
924 if (swapchain
->factory
)
925 IWineDXGIFactory_Release(swapchain
->factory
);
926 if (swapchain
->device
)
927 IWineDXGIDevice_Release(swapchain
->device
);
931 #ifdef SONAME_LIBVKD3D
933 #ifdef USE_WIN32_VULKAN
935 static void *load_library(const char *name
)
937 return LoadLibraryA(name
);
940 static void *get_library_proc(void *handle
, const char *name
)
942 return (void *)GetProcAddress(handle
, name
);
945 static void close_library(void *handle
)
951 static PFN_vkGetInstanceProcAddr
load_vulkan(void **vulkan_handle
)
953 *vulkan_handle
= LoadLibraryA("vulkan-1.dll");
954 return (void *)GetProcAddress(*vulkan_handle
, "vkGetInstanceProcAddr");
959 static void *load_library(const char *name
)
961 return dlopen(name
, RTLD_NOW
);
964 static void *get_library_proc(void *handle
, const char *name
)
966 return dlsym(handle
, name
);
969 static void close_library(void *handle
)
975 static PFN_vkGetInstanceProcAddr
load_vulkan(void **vulkan_handle
)
977 const struct vulkan_funcs
*vk_funcs
;
980 *vulkan_handle
= NULL
;
983 vk_funcs
= __wine_get_vulkan_driver(hdc
, WINE_VULKAN_DRIVER_VERSION
);
987 return (PFN_vkGetInstanceProcAddr
)vk_funcs
->p_vkGetInstanceProcAddr
;
992 #endif /* USE_WIN32_VULKAN */
994 static PFN_vkd3d_acquire_vk_queue vkd3d_acquire_vk_queue
;
995 static PFN_vkd3d_create_image_resource vkd3d_create_image_resource
;
996 static PFN_vkd3d_get_device_parent vkd3d_get_device_parent
;
997 static PFN_vkd3d_get_vk_device vkd3d_get_vk_device
;
998 static PFN_vkd3d_get_vk_format vkd3d_get_vk_format
;
999 static PFN_vkd3d_get_vk_physical_device vkd3d_get_vk_physical_device
;
1000 static PFN_vkd3d_get_vk_queue_family_index vkd3d_get_vk_queue_family_index
;
1001 static PFN_vkd3d_instance_from_device vkd3d_instance_from_device
;
1002 static PFN_vkd3d_instance_get_vk_instance vkd3d_instance_get_vk_instance
;
1003 static PFN_vkd3d_release_vk_queue vkd3d_release_vk_queue
;
1004 static PFN_vkd3d_resource_decref vkd3d_resource_decref
;
1005 static PFN_vkd3d_resource_incref vkd3d_resource_incref
;
1007 struct dxgi_vk_funcs
1009 PFN_vkAcquireNextImageKHR p_vkAcquireNextImageKHR
;
1010 PFN_vkAllocateCommandBuffers p_vkAllocateCommandBuffers
;
1011 PFN_vkAllocateMemory p_vkAllocateMemory
;
1012 PFN_vkBeginCommandBuffer p_vkBeginCommandBuffer
;
1013 PFN_vkBindImageMemory p_vkBindImageMemory
;
1014 PFN_vkCmdBlitImage p_vkCmdBlitImage
;
1015 PFN_vkCmdPipelineBarrier p_vkCmdPipelineBarrier
;
1016 PFN_vkCreateCommandPool p_vkCreateCommandPool
;
1017 PFN_vkCreateFence p_vkCreateFence
;
1018 PFN_vkCreateImage p_vkCreateImage
;
1019 PFN_vkCreateSemaphore p_vkCreateSemaphore
;
1020 PFN_vkCreateSwapchainKHR p_vkCreateSwapchainKHR
;
1021 PFN_vkCreateWin32SurfaceKHR p_vkCreateWin32SurfaceKHR
;
1022 PFN_vkDestroyCommandPool p_vkDestroyCommandPool
;
1023 PFN_vkDestroyFence p_vkDestroyFence
;
1024 PFN_vkDestroyImage p_vkDestroyImage
;
1025 PFN_vkDestroySemaphore p_vkDestroySemaphore
;
1026 PFN_vkDestroySurfaceKHR p_vkDestroySurfaceKHR
;
1027 PFN_vkResetCommandBuffer p_vkResetCommandBuffer
;
1028 PFN_vkDestroySwapchainKHR p_vkDestroySwapchainKHR
;
1029 PFN_vkEndCommandBuffer p_vkEndCommandBuffer
;
1030 PFN_vkFreeMemory p_vkFreeMemory
;
1031 PFN_vkGetImageMemoryRequirements p_vkGetImageMemoryRequirements
;
1032 PFN_vkGetInstanceProcAddr p_vkGetInstanceProcAddr
;
1033 PFN_vkGetPhysicalDeviceMemoryProperties p_vkGetPhysicalDeviceMemoryProperties
;
1034 PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR p_vkGetPhysicalDeviceSurfaceCapabilitiesKHR
;
1035 PFN_vkGetPhysicalDeviceSurfaceFormatsKHR p_vkGetPhysicalDeviceSurfaceFormatsKHR
;
1036 PFN_vkGetPhysicalDeviceSurfacePresentModesKHR p_vkGetPhysicalDeviceSurfacePresentModesKHR
;
1037 PFN_vkGetPhysicalDeviceSurfaceSupportKHR p_vkGetPhysicalDeviceSurfaceSupportKHR
;
1038 PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR p_vkGetPhysicalDeviceWin32PresentationSupportKHR
;
1039 PFN_vkGetSwapchainImagesKHR p_vkGetSwapchainImagesKHR
;
1040 PFN_vkQueuePresentKHR p_vkQueuePresentKHR
;
1041 PFN_vkQueueSubmit p_vkQueueSubmit
;
1042 PFN_vkQueueWaitIdle p_vkQueueWaitIdle
;
1043 PFN_vkResetFences p_vkResetFences
;
1044 PFN_vkWaitForFences p_vkWaitForFences
;
1046 void *vulkan_module
;
1049 static HRESULT
hresult_from_vk_result(VkResult vr
)
1055 case VK_ERROR_OUT_OF_HOST_MEMORY
:
1056 case VK_ERROR_OUT_OF_DEVICE_MEMORY
:
1057 return E_OUTOFMEMORY
;
1059 FIXME("Unhandled VkResult %d.\n", vr
);
1064 #define INVALID_VK_IMAGE_INDEX (~(uint32_t)0)
1066 struct d3d12_swapchain
1068 IDXGISwapChain4 IDXGISwapChain4_iface
;
1070 struct wined3d_private_store private_store
;
1072 struct wined3d_swapchain_state
*state
;
1073 struct wined3d_swapchain_state_parent state_parent
;
1075 VkSwapchainKHR vk_swapchain
;
1076 VkSurfaceKHR vk_surface
;
1078 VkInstance vk_instance
;
1080 VkPhysicalDevice vk_physical_device
;
1081 VkDeviceMemory vk_memory
;
1082 VkCommandPool vk_cmd_pool
;
1083 VkImage vk_images
[DXGI_MAX_SWAP_CHAIN_BUFFERS
];
1084 VkImage vk_swapchain_images
[DXGI_MAX_SWAP_CHAIN_BUFFERS
];
1085 VkCommandBuffer vk_cmd_buffers
[DXGI_MAX_SWAP_CHAIN_BUFFERS
];
1086 VkSemaphore vk_semaphores
[DXGI_MAX_SWAP_CHAIN_BUFFERS
];
1087 ID3D12Resource
*buffers
[DXGI_MAX_SWAP_CHAIN_BUFFERS
];
1088 unsigned int buffer_count
;
1089 unsigned int vk_swapchain_width
;
1090 unsigned int vk_swapchain_height
;
1091 VkPresentModeKHR present_mode
;
1093 uint32_t vk_image_index
;
1094 unsigned int current_buffer_index
;
1095 struct dxgi_vk_funcs vk_funcs
;
1097 ID3D12CommandQueue
*command_queue
;
1098 ID3D12Device
*device
;
1099 IWineDXGIFactory
*factory
;
1102 IDXGIOutput
*target
;
1103 DXGI_SWAP_CHAIN_DESC1 desc
;
1104 DXGI_SWAP_CHAIN_FULLSCREEN_DESC fullscreen_desc
;
1106 ID3D12Fence
*frame_latency_fence
;
1107 HANDLE frame_latency_event
;
1109 uint64_t frame_number
;
1110 uint32_t frame_latency
;
1113 static DXGI_FORMAT
dxgi_format_from_vk_format(VkFormat vk_format
)
1117 case VK_FORMAT_B8G8R8A8_UNORM
: return DXGI_FORMAT_B8G8R8A8_UNORM
;
1118 case VK_FORMAT_R8G8B8A8_UNORM
: return DXGI_FORMAT_R8G8B8A8_UNORM
;
1119 case VK_FORMAT_A2B10G10R10_UNORM_PACK32
: return DXGI_FORMAT_R10G10B10A2_UNORM
;
1120 case VK_FORMAT_R16G16B16A16_SFLOAT
: return DXGI_FORMAT_R16G16B16A16_FLOAT
;
1122 WARN("Unhandled format %#x.\n", vk_format
);
1123 return DXGI_FORMAT_UNKNOWN
;
1127 static VkFormat
get_swapchain_fallback_format(VkFormat vk_format
)
1131 case VK_FORMAT_R8G8B8A8_UNORM
:
1132 case VK_FORMAT_A2B10G10R10_UNORM_PACK32
:
1133 case VK_FORMAT_R16G16B16A16_SFLOAT
:
1134 return VK_FORMAT_B8G8R8A8_UNORM
;
1136 WARN("Unhandled format %#x.\n", vk_format
);
1137 return VK_FORMAT_UNDEFINED
;
1141 static HRESULT
select_vk_format(const struct dxgi_vk_funcs
*vk_funcs
,
1142 VkPhysicalDevice vk_physical_device
, VkSurfaceKHR vk_surface
,
1143 const DXGI_SWAP_CHAIN_DESC1
*swapchain_desc
, VkFormat
*vk_format
)
1145 VkSurfaceFormatKHR
*formats
;
1146 uint32_t format_count
;
1151 *vk_format
= VK_FORMAT_UNDEFINED
;
1153 format
= vkd3d_get_vk_format(swapchain_desc
->Format
);
1155 vr
= vk_funcs
->p_vkGetPhysicalDeviceSurfaceFormatsKHR(vk_physical_device
, vk_surface
, &format_count
, NULL
);
1156 if (vr
< 0 || !format_count
)
1158 WARN("Failed to get supported surface formats, vr %d.\n", vr
);
1159 return DXGI_ERROR_INVALID_CALL
;
1162 if (!(formats
= heap_calloc(format_count
, sizeof(*formats
))))
1163 return E_OUTOFMEMORY
;
1165 if ((vr
= vk_funcs
->p_vkGetPhysicalDeviceSurfaceFormatsKHR(vk_physical_device
,
1166 vk_surface
, &format_count
, formats
)) < 0)
1168 WARN("Failed to enumerate supported surface formats, vr %d.\n", vr
);
1170 return hresult_from_vk_result(vr
);
1173 for (i
= 0; i
< format_count
; ++i
)
1175 if (formats
[i
].format
== format
&& formats
[i
].colorSpace
== VK_COLOR_SPACE_SRGB_NONLINEAR_KHR
)
1178 if (i
== format_count
)
1180 /* Try to create a swapchain with format conversion. */
1181 format
= get_swapchain_fallback_format(format
);
1182 WARN("Failed to find Vulkan swapchain format for %s.\n", debug_dxgi_format(swapchain_desc
->Format
));
1183 for (i
= 0; i
< format_count
; ++i
)
1185 if (formats
[i
].format
== format
&& formats
[i
].colorSpace
== VK_COLOR_SPACE_SRGB_NONLINEAR_KHR
)
1187 format
= formats
[i
].format
;
1193 if (i
== format_count
)
1195 FIXME("Failed to find Vulkan swapchain format for %s.\n", debug_dxgi_format(swapchain_desc
->Format
));
1196 return DXGI_ERROR_UNSUPPORTED
;
1199 TRACE("Using Vulkan swapchain format %#x.\n", format
);
1201 *vk_format
= format
;
1205 static HRESULT
vk_select_memory_type(const struct dxgi_vk_funcs
*vk_funcs
,
1206 VkPhysicalDevice vk_physical_device
, uint32_t memory_type_mask
,
1207 VkMemoryPropertyFlags flags
, uint32_t *memory_type_index
)
1209 VkPhysicalDeviceMemoryProperties memory_properties
;
1212 vk_funcs
->p_vkGetPhysicalDeviceMemoryProperties(vk_physical_device
, &memory_properties
);
1213 for (i
= 0; i
< memory_properties
.memoryTypeCount
; ++i
)
1215 if (!(memory_type_mask
& (1u << i
)))
1218 if ((memory_properties
.memoryTypes
[i
].propertyFlags
& flags
) == flags
)
1220 *memory_type_index
= i
;
1225 FIXME("Failed to find memory type (allowed types %#x).\n", memory_type_mask
);
1229 static BOOL
d3d12_swapchain_is_present_mode_supported(struct d3d12_swapchain
*swapchain
,
1230 VkPresentModeKHR present_mode
)
1232 VkPhysicalDevice vk_physical_device
= swapchain
->vk_physical_device
;
1233 const struct dxgi_vk_funcs
*vk_funcs
= &swapchain
->vk_funcs
;
1234 VkPresentModeKHR
*modes
;
1239 if (present_mode
== VK_PRESENT_MODE_FIFO_KHR
)
1242 if ((vr
= vk_funcs
->p_vkGetPhysicalDeviceSurfacePresentModesKHR(vk_physical_device
,
1243 swapchain
->vk_surface
, &count
, NULL
)) < 0)
1245 WARN("Failed to get count of available present modes, vr %d.\n", vr
);
1251 if (!(modes
= heap_calloc(count
, sizeof(*modes
))))
1253 if ((vr
= vk_funcs
->p_vkGetPhysicalDeviceSurfacePresentModesKHR(vk_physical_device
,
1254 swapchain
->vk_surface
, &count
, modes
)) >= 0)
1256 for (i
= 0; i
< count
; ++i
)
1258 if (modes
[i
] == present_mode
)
1267 WARN("Failed to get available present modes, vr %d.\n", vr
);
1274 static BOOL
d3d12_swapchain_has_user_images(struct d3d12_swapchain
*swapchain
)
1276 return !!swapchain
->vk_images
[0];
1279 static HRESULT
d3d12_swapchain_create_user_buffers(struct d3d12_swapchain
*swapchain
, VkFormat vk_format
)
1281 const struct dxgi_vk_funcs
*vk_funcs
= &swapchain
->vk_funcs
;
1282 VkDeviceSize image_offset
[DXGI_MAX_SWAP_CHAIN_BUFFERS
];
1283 VkDevice vk_device
= swapchain
->vk_device
;
1284 VkMemoryAllocateInfo allocate_info
;
1285 VkMemoryRequirements requirements
;
1286 VkImageCreateInfo image_info
;
1287 uint32_t memory_type_mask
;
1288 VkDeviceSize memory_size
;
1293 if (d3d12_swapchain_has_user_images(swapchain
))
1296 memset(&image_info
, 0, sizeof(image_info
));
1297 image_info
.sType
= VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO
;
1298 image_info
.flags
= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT
;
1299 image_info
.imageType
= VK_IMAGE_TYPE_2D
;
1300 image_info
.format
= vk_format
;
1301 image_info
.extent
.width
= swapchain
->desc
.Width
;
1302 image_info
.extent
.height
= swapchain
->desc
.Height
;
1303 image_info
.extent
.depth
= 1;
1304 image_info
.mipLevels
= 1;
1305 image_info
.arrayLayers
= 1;
1306 image_info
.samples
= VK_SAMPLE_COUNT_1_BIT
;
1307 image_info
.tiling
= VK_IMAGE_TILING_OPTIMAL
;
1308 image_info
.usage
= VK_IMAGE_USAGE_TRANSFER_SRC_BIT
1309 | VK_IMAGE_USAGE_TRANSFER_DST_BIT
1310 | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT
;
1311 image_info
.sharingMode
= VK_SHARING_MODE_EXCLUSIVE
;
1312 image_info
.queueFamilyIndexCount
= 0;
1313 image_info
.pQueueFamilyIndices
= NULL
;
1314 image_info
.initialLayout
= VK_IMAGE_LAYOUT_UNDEFINED
;
1316 for (i
= 0; i
< swapchain
->desc
.BufferCount
; ++i
)
1318 assert(swapchain
->vk_images
[i
] == VK_NULL_HANDLE
);
1319 if ((vr
= vk_funcs
->p_vkCreateImage(vk_device
, &image_info
, NULL
, &swapchain
->vk_images
[i
])) < 0)
1321 WARN("Failed to create Vulkan image, vr %d.\n", vr
);
1322 swapchain
->vk_images
[i
] = VK_NULL_HANDLE
;
1323 return hresult_from_vk_result(vr
);
1328 memory_type_mask
= ~0u;
1329 for (i
= 0; i
< swapchain
->desc
.BufferCount
; ++i
)
1331 vk_funcs
->p_vkGetImageMemoryRequirements(vk_device
, swapchain
->vk_images
[i
], &requirements
);
1333 TRACE("Size %s, alignment %s, memory types %#x.\n",
1334 wine_dbgstr_longlong(requirements
.size
), wine_dbgstr_longlong(requirements
.alignment
),
1335 requirements
.memoryTypeBits
);
1337 image_offset
[i
] = (memory_size
+ (requirements
.alignment
- 1)) & ~(requirements
.alignment
- 1);
1338 memory_size
= image_offset
[i
] + requirements
.size
;
1340 memory_type_mask
&= requirements
.memoryTypeBits
;
1343 TRACE("Allocating %s bytes for user images.\n", wine_dbgstr_longlong(memory_size
));
1345 allocate_info
.sType
= VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO
;
1346 allocate_info
.pNext
= NULL
;
1347 allocate_info
.allocationSize
= memory_size
;
1349 if (FAILED(hr
= vk_select_memory_type(vk_funcs
, swapchain
->vk_physical_device
,
1350 memory_type_mask
, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT
, &allocate_info
.memoryTypeIndex
)))
1353 assert(swapchain
->vk_memory
== VK_NULL_HANDLE
);
1354 if ((vr
= vk_funcs
->p_vkAllocateMemory(vk_device
, &allocate_info
, NULL
, &swapchain
->vk_memory
)) < 0)
1356 WARN("Failed to allocate device memory, vr %d.\n", vr
);
1357 swapchain
->vk_memory
= VK_NULL_HANDLE
;
1358 return hresult_from_vk_result(vr
);
1361 for (i
= 0; i
< swapchain
->desc
.BufferCount
; ++i
)
1363 if ((vr
= vk_funcs
->p_vkBindImageMemory(vk_device
, swapchain
->vk_images
[i
],
1364 swapchain
->vk_memory
, image_offset
[i
])) < 0)
1366 WARN("Failed to bind image memory, vr %d.\n", vr
);
1367 return hresult_from_vk_result(vr
);
1374 static void vk_cmd_image_barrier(const struct dxgi_vk_funcs
*vk_funcs
, VkCommandBuffer cmd_buffer
,
1375 VkPipelineStageFlags src_stage_mask
, VkPipelineStageFlags dst_stage_mask
,
1376 VkAccessFlags src_access_mask
, VkAccessFlags dst_access_mask
,
1377 VkImageLayout old_layout
, VkImageLayout new_layout
, VkImage image
)
1379 VkImageMemoryBarrier barrier
;
1381 barrier
.sType
= VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER
;
1382 barrier
.pNext
= NULL
;
1383 barrier
.srcAccessMask
= src_access_mask
;
1384 barrier
.dstAccessMask
= dst_access_mask
;
1385 barrier
.oldLayout
= old_layout
;
1386 barrier
.newLayout
= new_layout
;
1387 barrier
.srcQueueFamilyIndex
= VK_QUEUE_FAMILY_IGNORED
;
1388 barrier
.dstQueueFamilyIndex
= VK_QUEUE_FAMILY_IGNORED
;
1389 barrier
.image
= image
;
1390 barrier
.subresourceRange
.aspectMask
= VK_IMAGE_ASPECT_COLOR_BIT
;
1391 barrier
.subresourceRange
.baseMipLevel
= 0;
1392 barrier
.subresourceRange
.levelCount
= VK_REMAINING_MIP_LEVELS
;
1393 barrier
.subresourceRange
.baseArrayLayer
= 0;
1394 barrier
.subresourceRange
.layerCount
= VK_REMAINING_ARRAY_LAYERS
;
1396 vk_funcs
->p_vkCmdPipelineBarrier(cmd_buffer
,
1397 src_stage_mask
, dst_stage_mask
, 0, 0, NULL
, 0, NULL
, 1, &barrier
);
1400 static VkResult
d3d12_swapchain_record_swapchain_blit(struct d3d12_swapchain
*swapchain
,
1401 VkCommandBuffer vk_cmd_buffer
, VkImage vk_dst_image
, VkImage vk_src_image
)
1403 const struct dxgi_vk_funcs
*vk_funcs
= &swapchain
->vk_funcs
;
1404 VkCommandBufferBeginInfo begin_info
;
1409 if (swapchain
->desc
.Width
!= swapchain
->vk_swapchain_width
1410 || swapchain
->desc
.Height
!= swapchain
->vk_swapchain_height
)
1411 filter
= VK_FILTER_LINEAR
;
1413 filter
= VK_FILTER_NEAREST
;
1415 begin_info
.sType
= VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO
;
1416 begin_info
.pNext
= NULL
;
1417 begin_info
.flags
= 0;
1418 begin_info
.pInheritanceInfo
= NULL
;
1420 if ((vr
= vk_funcs
->p_vkBeginCommandBuffer(vk_cmd_buffer
, &begin_info
)) < 0)
1422 WARN("Failed to begin command buffer, vr %d.\n", vr
);
1426 vk_cmd_image_barrier(vk_funcs
, vk_cmd_buffer
,
1427 VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT
, VK_PIPELINE_STAGE_TRANSFER_BIT
,
1428 0, VK_ACCESS_TRANSFER_WRITE_BIT
,
1429 VK_IMAGE_LAYOUT_UNDEFINED
, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
, vk_dst_image
);
1431 blit
.srcSubresource
.aspectMask
= VK_IMAGE_ASPECT_COLOR_BIT
;
1432 blit
.srcSubresource
.mipLevel
= 0;
1433 blit
.srcSubresource
.baseArrayLayer
= 0;
1434 blit
.srcSubresource
.layerCount
= 1;
1435 blit
.srcOffsets
[0].x
= 0;
1436 blit
.srcOffsets
[0].y
= 0;
1437 blit
.srcOffsets
[0].z
= 0;
1438 blit
.srcOffsets
[1].x
= swapchain
->desc
.Width
;
1439 blit
.srcOffsets
[1].y
= swapchain
->desc
.Height
;
1440 blit
.srcOffsets
[1].z
= 1;
1441 blit
.dstSubresource
= blit
.srcSubresource
;
1442 blit
.dstOffsets
[0].x
= 0;
1443 blit
.dstOffsets
[0].y
= 0;
1444 blit
.dstOffsets
[0].z
= 0;
1445 if (swapchain
->desc
.Scaling
== DXGI_SCALING_NONE
)
1447 blit
.srcOffsets
[1].x
= min(swapchain
->vk_swapchain_width
, blit
.srcOffsets
[1].x
);
1448 blit
.srcOffsets
[1].y
= min(swapchain
->vk_swapchain_height
, blit
.srcOffsets
[1].y
);
1449 blit
.dstOffsets
[1].x
= blit
.srcOffsets
[1].x
;
1450 blit
.dstOffsets
[1].y
= blit
.srcOffsets
[1].y
;
1454 /* FIXME: handle DXGI_SCALING_ASPECT_RATIO_STRETCH. */
1455 blit
.dstOffsets
[1].x
= swapchain
->vk_swapchain_width
;
1456 blit
.dstOffsets
[1].y
= swapchain
->vk_swapchain_height
;
1458 blit
.dstOffsets
[1].z
= 1;
1460 vk_funcs
->p_vkCmdBlitImage(vk_cmd_buffer
,
1461 vk_src_image
, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL
,
1462 vk_dst_image
, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
,
1465 vk_cmd_image_barrier(vk_funcs
, vk_cmd_buffer
,
1466 VK_PIPELINE_STAGE_TRANSFER_BIT
, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT
,
1467 VK_ACCESS_TRANSFER_WRITE_BIT
, 0,
1468 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR
, vk_dst_image
);
1470 if ((vr
= vk_funcs
->p_vkEndCommandBuffer(vk_cmd_buffer
)) < 0)
1471 WARN("Failed to end command buffer, vr %d.\n", vr
);
1476 static HRESULT
d3d12_swapchain_prepare_command_buffers(struct d3d12_swapchain
*swapchain
,
1477 uint32_t queue_family_index
)
1479 const struct dxgi_vk_funcs
*vk_funcs
= &swapchain
->vk_funcs
;
1480 VkDevice vk_device
= swapchain
->vk_device
;
1481 VkCommandBufferAllocateInfo allocate_info
;
1482 VkSemaphoreCreateInfo semaphore_info
;
1483 VkCommandPoolCreateInfo pool_info
;
1487 pool_info
.sType
= VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO
;
1488 pool_info
.pNext
= NULL
;
1489 pool_info
.flags
= VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT
;
1490 pool_info
.queueFamilyIndex
= queue_family_index
;
1492 assert(swapchain
->vk_cmd_pool
== VK_NULL_HANDLE
);
1493 if ((vr
= vk_funcs
->p_vkCreateCommandPool(vk_device
, &pool_info
,
1494 NULL
, &swapchain
->vk_cmd_pool
)) < 0)
1496 WARN("Failed to create command pool, vr %d.\n", vr
);
1497 swapchain
->vk_cmd_pool
= VK_NULL_HANDLE
;
1498 return hresult_from_vk_result(vr
);
1501 allocate_info
.sType
= VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO
;
1502 allocate_info
.pNext
= NULL
;
1503 allocate_info
.commandPool
= swapchain
->vk_cmd_pool
;
1504 allocate_info
.level
= VK_COMMAND_BUFFER_LEVEL_PRIMARY
;
1505 allocate_info
.commandBufferCount
= swapchain
->buffer_count
;
1507 if ((vr
= vk_funcs
->p_vkAllocateCommandBuffers(vk_device
, &allocate_info
,
1508 swapchain
->vk_cmd_buffers
)) < 0)
1510 WARN("Failed to allocate command buffers, vr %d.\n", vr
);
1511 return hresult_from_vk_result(vr
);
1514 for (i
= 0; i
< swapchain
->buffer_count
; ++i
)
1516 semaphore_info
.sType
= VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO
;
1517 semaphore_info
.pNext
= NULL
;
1518 semaphore_info
.flags
= 0;
1520 assert(swapchain
->vk_semaphores
[i
] == VK_NULL_HANDLE
);
1521 if ((vr
= vk_funcs
->p_vkCreateSemaphore(vk_device
, &semaphore_info
,
1522 NULL
, &swapchain
->vk_semaphores
[i
])) < 0)
1524 WARN("Failed to create semaphore, vr %d.\n", vr
);
1525 swapchain
->vk_semaphores
[i
] = VK_NULL_HANDLE
;
1526 return hresult_from_vk_result(vr
);
1533 static HRESULT
d3d12_swapchain_create_buffers(struct d3d12_swapchain
*swapchain
,
1534 VkFormat vk_swapchain_format
, VkFormat vk_format
)
1536 const struct dxgi_vk_funcs
*vk_funcs
= &swapchain
->vk_funcs
;
1537 struct vkd3d_image_resource_create_info resource_info
;
1538 VkSwapchainKHR vk_swapchain
= swapchain
->vk_swapchain
;
1539 ID3D12CommandQueue
*queue
= swapchain
->command_queue
;
1540 VkDevice vk_device
= swapchain
->vk_device
;
1541 ID3D12Device
*device
= swapchain
->device
;
1542 uint32_t image_count
, queue_family_index
;
1543 D3D12_COMMAND_QUEUE_DESC queue_desc
;
1548 if ((vr
= vk_funcs
->p_vkGetSwapchainImagesKHR(vk_device
, vk_swapchain
, &image_count
, NULL
)) < 0)
1550 WARN("Failed to get Vulkan swapchain images, vr %d.\n", vr
);
1551 return hresult_from_vk_result(vr
);
1553 if (image_count
> ARRAY_SIZE(swapchain
->vk_swapchain_images
))
1555 FIXME("Unsupported Vulkan swapchain image count %u.\n", image_count
);
1558 swapchain
->buffer_count
= image_count
;
1559 if ((vr
= vk_funcs
->p_vkGetSwapchainImagesKHR(vk_device
, vk_swapchain
,
1560 &image_count
, swapchain
->vk_swapchain_images
)) < 0)
1562 WARN("Failed to get Vulkan swapchain images, vr %d.\n", vr
);
1563 return hresult_from_vk_result(vr
);
1566 resource_info
.type
= VKD3D_STRUCTURE_TYPE_IMAGE_RESOURCE_CREATE_INFO
;
1567 resource_info
.next
= NULL
;
1568 resource_info
.desc
.Dimension
= D3D12_RESOURCE_DIMENSION_TEXTURE2D
;
1569 resource_info
.desc
.Alignment
= 0;
1570 resource_info
.desc
.Width
= swapchain
->desc
.Width
;
1571 resource_info
.desc
.Height
= swapchain
->desc
.Height
;
1572 resource_info
.desc
.DepthOrArraySize
= 1;
1573 resource_info
.desc
.MipLevels
= 1;
1574 resource_info
.desc
.Format
= dxgi_format_from_vk_format(vk_format
);
1575 resource_info
.desc
.SampleDesc
.Count
= 1;
1576 resource_info
.desc
.SampleDesc
.Quality
= 0;
1577 resource_info
.desc
.Layout
= D3D12_TEXTURE_LAYOUT_UNKNOWN
;
1578 resource_info
.desc
.Flags
= D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET
;
1579 resource_info
.flags
= VKD3D_RESOURCE_INITIAL_STATE_TRANSITION
| VKD3D_RESOURCE_PRESENT_STATE_TRANSITION
;
1581 queue_desc
= ID3D12CommandQueue_GetDesc(queue
);
1582 if (queue_desc
.Type
!= D3D12_COMMAND_LIST_TYPE_DIRECT
)
1584 /* vkCmdBlitImage() is only supported for graphics queues. */
1585 FIXME("Swapchain blit not implemented for command queue type %#x.\n", queue_desc
.Type
);
1586 if (vk_swapchain_format
!= vk_format
)
1588 if (image_count
!= swapchain
->desc
.BufferCount
)
1590 FIXME("Got %u swapchain images, expected %u.\n", image_count
, swapchain
->desc
.BufferCount
);
1594 queue_family_index
= vkd3d_get_vk_queue_family_index(queue
);
1596 if (queue_desc
.Type
== D3D12_COMMAND_LIST_TYPE_DIRECT
)
1598 TRACE("Creating user swapchain buffers.\n");
1600 if (FAILED(hr
= d3d12_swapchain_create_user_buffers(swapchain
, vk_format
)))
1603 if (FAILED(hr
= d3d12_swapchain_prepare_command_buffers(swapchain
, queue_family_index
)))
1607 if (swapchain
->buffers
[0])
1610 for (i
= 0; i
< swapchain
->desc
.BufferCount
; ++i
)
1612 if (swapchain
->vk_images
[i
])
1614 resource_info
.vk_image
= swapchain
->vk_images
[i
];
1615 resource_info
.present_state
= D3D12_RESOURCE_STATE_COPY_SOURCE
;
1619 resource_info
.vk_image
= swapchain
->vk_swapchain_images
[i
];
1620 resource_info
.present_state
= D3D12_RESOURCE_STATE_PRESENT
;
1623 if (FAILED(hr
= vkd3d_create_image_resource(device
, &resource_info
, &swapchain
->buffers
[i
])))
1625 WARN("Failed to create vkd3d resource for Vulkan image %u, hr %#x.\n", i
, hr
);
1629 vkd3d_resource_incref(swapchain
->buffers
[i
]);
1630 ID3D12Resource_Release(swapchain
->buffers
[i
]);
1636 static VkResult
d3d12_swapchain_acquire_next_vulkan_image(struct d3d12_swapchain
*swapchain
)
1638 const struct dxgi_vk_funcs
*vk_funcs
= &swapchain
->vk_funcs
;
1639 VkDevice vk_device
= swapchain
->vk_device
;
1640 VkFence vk_fence
= swapchain
->vk_fence
;
1643 swapchain
->vk_image_index
= INVALID_VK_IMAGE_INDEX
;
1645 if ((vr
= vk_funcs
->p_vkAcquireNextImageKHR(vk_device
, swapchain
->vk_swapchain
, UINT64_MAX
,
1646 VK_NULL_HANDLE
, vk_fence
, &swapchain
->vk_image_index
)) < 0)
1648 WARN("Failed to acquire next Vulkan image, vr %d.\n", vr
);
1652 if ((vr
= vk_funcs
->p_vkWaitForFences(vk_device
, 1, &vk_fence
, VK_TRUE
, UINT64_MAX
)) != VK_SUCCESS
)
1654 ERR("Failed to wait for fence, vr %d.\n", vr
);
1657 if ((vr
= vk_funcs
->p_vkResetFences(vk_device
, 1, &vk_fence
)) < 0)
1658 ERR("Failed to reset fence, vr %d.\n", vr
);
1663 static VkResult
d3d12_swapchain_acquire_next_back_buffer(struct d3d12_swapchain
*swapchain
)
1667 /* If we don't have user images, we need to acquire a Vulkan image in order
1668 * to get the correct value for the current back buffer index. */
1669 if (d3d12_swapchain_has_user_images(swapchain
))
1672 if ((vr
= d3d12_swapchain_acquire_next_vulkan_image(swapchain
)) >= 0)
1673 swapchain
->current_buffer_index
= swapchain
->vk_image_index
;
1675 ERR("Failed to acquire Vulkan image, vr %d.\n", vr
);
1680 static void d3d12_swapchain_destroy_buffers(struct d3d12_swapchain
*swapchain
, BOOL destroy_user_buffers
)
1682 const struct dxgi_vk_funcs
*vk_funcs
= &swapchain
->vk_funcs
;
1686 if (swapchain
->command_queue
)
1688 if ((vk_queue
= vkd3d_acquire_vk_queue(swapchain
->command_queue
)))
1690 vk_funcs
->p_vkQueueWaitIdle(vk_queue
);
1692 vkd3d_release_vk_queue(swapchain
->command_queue
);
1696 WARN("Failed to acquire Vulkan queue.\n");
1700 for (i
= 0; i
< swapchain
->desc
.BufferCount
; ++i
)
1702 if (swapchain
->buffers
[i
] && (destroy_user_buffers
|| !d3d12_swapchain_has_user_images(swapchain
)))
1704 vkd3d_resource_decref(swapchain
->buffers
[i
]);
1705 swapchain
->buffers
[i
] = NULL
;
1707 if (swapchain
->vk_device
&& destroy_user_buffers
)
1709 vk_funcs
->p_vkDestroyImage(swapchain
->vk_device
, swapchain
->vk_images
[i
], NULL
);
1710 swapchain
->vk_images
[i
] = VK_NULL_HANDLE
;
1714 if (swapchain
->vk_device
)
1716 for (i
= 0; i
< swapchain
->buffer_count
; ++i
)
1718 vk_funcs
->p_vkDestroySemaphore(swapchain
->vk_device
, swapchain
->vk_semaphores
[i
], NULL
);
1719 swapchain
->vk_semaphores
[i
] = VK_NULL_HANDLE
;
1721 if (destroy_user_buffers
)
1723 vk_funcs
->p_vkFreeMemory(swapchain
->vk_device
, swapchain
->vk_memory
, NULL
);
1724 swapchain
->vk_memory
= VK_NULL_HANDLE
;
1726 vk_funcs
->p_vkDestroyCommandPool(swapchain
->vk_device
, swapchain
->vk_cmd_pool
, NULL
);
1727 swapchain
->vk_cmd_pool
= VK_NULL_HANDLE
;
1731 static HRESULT
d3d12_swapchain_create_vulkan_swapchain(struct d3d12_swapchain
*swapchain
)
1733 VkPhysicalDevice vk_physical_device
= swapchain
->vk_physical_device
;
1734 const struct dxgi_vk_funcs
*vk_funcs
= &swapchain
->vk_funcs
;
1735 VkSwapchainCreateInfoKHR vk_swapchain_desc
;
1736 VkDevice vk_device
= swapchain
->vk_device
;
1737 VkFormat vk_format
, vk_swapchain_format
;
1738 unsigned int width
, height
, image_count
;
1739 VkSurfaceCapabilitiesKHR surface_caps
;
1740 VkSwapchainKHR vk_swapchain
;
1741 VkImageUsageFlags usage
;
1745 if (!(vk_format
= vkd3d_get_vk_format(swapchain
->desc
.Format
)))
1747 WARN("Invalid format %#x.\n", swapchain
->desc
.Format
);
1748 return DXGI_ERROR_INVALID_CALL
;
1751 if (FAILED(hr
= select_vk_format(vk_funcs
, vk_physical_device
,
1752 swapchain
->vk_surface
, &swapchain
->desc
, &vk_swapchain_format
)))
1755 if ((vr
= vk_funcs
->p_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(vk_physical_device
,
1756 swapchain
->vk_surface
, &surface_caps
)) < 0)
1758 WARN("Failed to get surface capabilities, vr %d.\n", vr
);
1759 return hresult_from_vk_result(vr
);
1762 image_count
= swapchain
->desc
.BufferCount
;
1763 image_count
= max(image_count
, surface_caps
.minImageCount
);
1764 if (surface_caps
.maxImageCount
)
1765 image_count
= min(image_count
, surface_caps
.maxImageCount
);
1767 if (image_count
!= swapchain
->desc
.BufferCount
)
1769 WARN("Buffer count %u is not supported (%u-%u).\n", swapchain
->desc
.BufferCount
,
1770 surface_caps
.minImageCount
, surface_caps
.maxImageCount
);
1773 width
= swapchain
->desc
.Width
;
1774 height
= swapchain
->desc
.Height
;
1775 width
= max(width
, surface_caps
.minImageExtent
.width
);
1776 width
= min(width
, surface_caps
.maxImageExtent
.width
);
1777 height
= max(height
, surface_caps
.minImageExtent
.height
);
1778 height
= min(height
, surface_caps
.maxImageExtent
.height
);
1780 if (width
!= swapchain
->desc
.Width
|| height
!= swapchain
->desc
.Height
)
1782 WARN("Swapchain dimensions %ux%u are not supported (%u-%u x %u-%u).\n",
1783 swapchain
->desc
.Width
, swapchain
->desc
.Height
,
1784 surface_caps
.minImageExtent
.width
, surface_caps
.maxImageExtent
.width
,
1785 surface_caps
.minImageExtent
.height
, surface_caps
.maxImageExtent
.height
);
1788 TRACE("Vulkan swapchain extent %ux%u.\n", width
, height
);
1790 if (!(surface_caps
.supportedCompositeAlpha
& VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR
))
1792 FIXME("Unsupported alpha mode.\n");
1793 return DXGI_ERROR_UNSUPPORTED
;
1796 usage
= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT
;
1797 usage
|= surface_caps
.supportedUsageFlags
& VK_IMAGE_USAGE_TRANSFER_SRC_BIT
;
1798 usage
|= surface_caps
.supportedUsageFlags
& VK_IMAGE_USAGE_TRANSFER_DST_BIT
;
1799 if (!(usage
& VK_IMAGE_USAGE_TRANSFER_SRC_BIT
) || !(usage
& VK_IMAGE_USAGE_TRANSFER_DST_BIT
))
1800 WARN("Transfer not supported for swapchain images.\n");
1802 vk_swapchain_desc
.sType
= VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR
;
1803 vk_swapchain_desc
.pNext
= NULL
;
1804 vk_swapchain_desc
.flags
= 0;
1805 vk_swapchain_desc
.surface
= swapchain
->vk_surface
;
1806 vk_swapchain_desc
.minImageCount
= image_count
;
1807 vk_swapchain_desc
.imageFormat
= vk_swapchain_format
;
1808 vk_swapchain_desc
.imageColorSpace
= VK_COLOR_SPACE_SRGB_NONLINEAR_KHR
;
1809 vk_swapchain_desc
.imageExtent
.width
= width
;
1810 vk_swapchain_desc
.imageExtent
.height
= height
;
1811 vk_swapchain_desc
.imageArrayLayers
= 1;
1812 vk_swapchain_desc
.imageUsage
= usage
;
1813 vk_swapchain_desc
.imageSharingMode
= VK_SHARING_MODE_EXCLUSIVE
;
1814 vk_swapchain_desc
.queueFamilyIndexCount
= 0;
1815 vk_swapchain_desc
.pQueueFamilyIndices
= NULL
;
1816 vk_swapchain_desc
.preTransform
= surface_caps
.currentTransform
;
1817 vk_swapchain_desc
.compositeAlpha
= VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR
;
1818 vk_swapchain_desc
.presentMode
= swapchain
->present_mode
;
1819 vk_swapchain_desc
.clipped
= VK_TRUE
;
1820 vk_swapchain_desc
.oldSwapchain
= swapchain
->vk_swapchain
;
1821 if ((vr
= vk_funcs
->p_vkCreateSwapchainKHR(vk_device
, &vk_swapchain_desc
, NULL
, &vk_swapchain
)) < 0)
1823 WARN("Failed to create Vulkan swapchain, vr %d.\n", vr
);
1824 return hresult_from_vk_result(vr
);
1827 if (swapchain
->vk_swapchain
)
1828 vk_funcs
->p_vkDestroySwapchainKHR(swapchain
->vk_device
, swapchain
->vk_swapchain
, NULL
);
1830 swapchain
->vk_swapchain
= vk_swapchain
;
1831 swapchain
->vk_swapchain_width
= width
;
1832 swapchain
->vk_swapchain_height
= height
;
1834 swapchain
->vk_image_index
= INVALID_VK_IMAGE_INDEX
;
1836 return d3d12_swapchain_create_buffers(swapchain
, vk_swapchain_format
, vk_format
);
1839 static HRESULT
d3d12_swapchain_recreate_vulkan_swapchain(struct d3d12_swapchain
*swapchain
)
1844 if (SUCCEEDED(hr
= d3d12_swapchain_create_vulkan_swapchain(swapchain
)))
1846 vr
= d3d12_swapchain_acquire_next_back_buffer(swapchain
);
1847 hr
= hresult_from_vk_result(vr
);
1851 ERR("Failed to recreate Vulkan swapchain, hr %#x.\n", hr
);
1857 static inline struct d3d12_swapchain
*d3d12_swapchain_from_IDXGISwapChain4(IDXGISwapChain4
*iface
)
1859 return CONTAINING_RECORD(iface
, struct d3d12_swapchain
, IDXGISwapChain4_iface
);
1862 /* IUnknown methods */
1864 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_QueryInterface(IDXGISwapChain4
*iface
, REFIID iid
, void **object
)
1866 TRACE("iface %p, iid %s, object %p.\n", iface
, debugstr_guid(iid
), object
);
1868 if (IsEqualGUID(iid
, &IID_IUnknown
)
1869 || IsEqualGUID(iid
, &IID_IDXGIObject
)
1870 || IsEqualGUID(iid
, &IID_IDXGIDeviceSubObject
)
1871 || IsEqualGUID(iid
, &IID_IDXGISwapChain
)
1872 || IsEqualGUID(iid
, &IID_IDXGISwapChain1
)
1873 || IsEqualGUID(iid
, &IID_IDXGISwapChain2
)
1874 || IsEqualGUID(iid
, &IID_IDXGISwapChain3
)
1875 || IsEqualGUID(iid
, &IID_IDXGISwapChain4
))
1877 IUnknown_AddRef(iface
);
1882 WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid
));
1885 return E_NOINTERFACE
;
1888 static ULONG STDMETHODCALLTYPE
d3d12_swapchain_AddRef(IDXGISwapChain4
*iface
)
1890 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
1891 ULONG refcount
= InterlockedIncrement(&swapchain
->refcount
);
1893 TRACE("%p increasing refcount to %u.\n", swapchain
, refcount
);
1898 static void d3d12_swapchain_destroy(struct d3d12_swapchain
*swapchain
)
1900 const struct dxgi_vk_funcs
*vk_funcs
= &swapchain
->vk_funcs
;
1901 void *vulkan_module
= vk_funcs
->vulkan_module
;
1903 d3d12_swapchain_destroy_buffers(swapchain
, TRUE
);
1905 if (swapchain
->frame_latency_event
)
1906 CloseHandle(swapchain
->frame_latency_event
);
1908 if (swapchain
->frame_latency_fence
)
1909 ID3D12Fence_Release(swapchain
->frame_latency_fence
);
1911 if (swapchain
->command_queue
)
1912 ID3D12CommandQueue_Release(swapchain
->command_queue
);
1914 wined3d_private_store_cleanup(&swapchain
->private_store
);
1916 if (swapchain
->vk_device
)
1918 vk_funcs
->p_vkDestroyFence(swapchain
->vk_device
, swapchain
->vk_fence
, NULL
);
1919 vk_funcs
->p_vkDestroySwapchainKHR(swapchain
->vk_device
, swapchain
->vk_swapchain
, NULL
);
1922 if (swapchain
->vk_instance
)
1923 vk_funcs
->p_vkDestroySurfaceKHR(swapchain
->vk_instance
, swapchain
->vk_surface
, NULL
);
1925 if (swapchain
->target
)
1927 WARN("Destroying fullscreen swapchain.\n");
1928 IDXGIOutput_Release(swapchain
->target
);
1931 if (swapchain
->device
)
1932 ID3D12Device_Release(swapchain
->device
);
1934 if (swapchain
->factory
)
1935 IWineDXGIFactory_Release(swapchain
->factory
);
1937 close_library(vulkan_module
);
1939 wined3d_swapchain_state_destroy(swapchain
->state
);
1942 static ULONG STDMETHODCALLTYPE
d3d12_swapchain_Release(IDXGISwapChain4
*iface
)
1944 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
1945 ULONG refcount
= InterlockedDecrement(&swapchain
->refcount
);
1947 TRACE("%p decreasing refcount to %u.\n", swapchain
, refcount
);
1951 d3d12_swapchain_destroy(swapchain
);
1952 heap_free(swapchain
);
1958 /* IDXGIObject methods */
1960 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_SetPrivateData(IDXGISwapChain4
*iface
,
1961 REFGUID guid
, UINT data_size
, const void *data
)
1963 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
1965 TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface
, debugstr_guid(guid
), data_size
, data
);
1967 return dxgi_set_private_data(&swapchain
->private_store
, guid
, data_size
, data
);
1970 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_SetPrivateDataInterface(IDXGISwapChain4
*iface
,
1971 REFGUID guid
, const IUnknown
*object
)
1973 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
1975 TRACE("iface %p, guid %s, object %p.\n", iface
, debugstr_guid(guid
), object
);
1977 return dxgi_set_private_data_interface(&swapchain
->private_store
, guid
, object
);
1980 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetPrivateData(IDXGISwapChain4
*iface
,
1981 REFGUID guid
, UINT
*data_size
, void *data
)
1983 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
1985 TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface
, debugstr_guid(guid
), data_size
, data
);
1987 return dxgi_get_private_data(&swapchain
->private_store
, guid
, data_size
, data
);
1990 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetParent(IDXGISwapChain4
*iface
, REFIID iid
, void **parent
)
1992 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
1994 TRACE("iface %p, iid %s, parent %p.\n", iface
, debugstr_guid(iid
), parent
);
1996 return IWineDXGIFactory_QueryInterface(swapchain
->factory
, iid
, parent
);
1999 /* IDXGIDeviceSubObject methods */
2001 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetDevice(IDXGISwapChain4
*iface
, REFIID iid
, void **device
)
2003 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
2005 TRACE("iface %p, iid %s, device %p.\n", iface
, debugstr_guid(iid
), device
);
2007 return ID3D12Device_QueryInterface(swapchain
->device
, iid
, device
);
2010 /* IDXGISwapChain methods */
2012 static HRESULT
d3d12_swapchain_set_sync_interval(struct d3d12_swapchain
*swapchain
,
2013 unsigned int sync_interval
)
2015 VkPresentModeKHR present_mode
;
2017 switch (sync_interval
)
2020 present_mode
= VK_PRESENT_MODE_IMMEDIATE_KHR
;
2023 FIXME("Unsupported sync interval %u.\n", sync_interval
);
2025 present_mode
= VK_PRESENT_MODE_FIFO_KHR
;
2029 if (swapchain
->present_mode
== present_mode
)
2032 if (!d3d12_swapchain_has_user_images(swapchain
))
2034 FIXME("Cannot recreate swapchain without user images.\n");
2038 if (!d3d12_swapchain_is_present_mode_supported(swapchain
, present_mode
))
2040 FIXME("Vulkan present mode %#x is not supported.\n", present_mode
);
2044 d3d12_swapchain_destroy_buffers(swapchain
, FALSE
);
2045 swapchain
->present_mode
= present_mode
;
2046 return d3d12_swapchain_recreate_vulkan_swapchain(swapchain
);
2049 static VkResult
d3d12_swapchain_queue_present(struct d3d12_swapchain
*swapchain
, VkQueue vk_queue
)
2051 const struct dxgi_vk_funcs
*vk_funcs
= &swapchain
->vk_funcs
;
2052 VkPresentInfoKHR present_info
;
2053 VkSubmitInfo submit_info
;
2056 if (swapchain
->vk_image_index
== INVALID_VK_IMAGE_INDEX
)
2058 if ((vr
= d3d12_swapchain_acquire_next_vulkan_image(swapchain
)) < 0)
2062 assert(swapchain
->vk_image_index
< swapchain
->buffer_count
);
2064 present_info
.sType
= VK_STRUCTURE_TYPE_PRESENT_INFO_KHR
;
2065 present_info
.pNext
= NULL
;
2066 present_info
.waitSemaphoreCount
= 0;
2067 present_info
.pWaitSemaphores
= NULL
;
2068 present_info
.swapchainCount
= 1;
2069 present_info
.pSwapchains
= &swapchain
->vk_swapchain
;
2070 present_info
.pImageIndices
= &swapchain
->vk_image_index
;
2071 present_info
.pResults
= NULL
;
2073 if (d3d12_swapchain_has_user_images(swapchain
))
2076 VkCommandBuffer vk_cmd_buffer
= swapchain
->vk_cmd_buffers
[swapchain
->vk_image_index
];
2077 VkImage vk_dst_image
= swapchain
->vk_swapchain_images
[swapchain
->vk_image_index
];
2078 VkImage vk_src_image
= swapchain
->vk_images
[swapchain
->current_buffer_index
];
2080 if ((vr
= vk_funcs
->p_vkResetCommandBuffer(vk_cmd_buffer
, 0)) < 0)
2082 ERR("Failed to reset command buffer, vr %d.\n", vr
);
2086 if ((vr
= d3d12_swapchain_record_swapchain_blit(swapchain
,
2087 vk_cmd_buffer
, vk_dst_image
, vk_src_image
)) < 0 )
2090 submit_info
.sType
= VK_STRUCTURE_TYPE_SUBMIT_INFO
;
2091 submit_info
.pNext
= NULL
;
2092 submit_info
.waitSemaphoreCount
= 0;
2093 submit_info
.pWaitSemaphores
= NULL
;
2094 submit_info
.pWaitDstStageMask
= NULL
;
2095 submit_info
.commandBufferCount
= 1;
2096 submit_info
.pCommandBuffers
= &vk_cmd_buffer
;
2097 submit_info
.signalSemaphoreCount
= 1;
2098 submit_info
.pSignalSemaphores
= &swapchain
->vk_semaphores
[swapchain
->vk_image_index
];
2100 if ((vr
= vk_funcs
->p_vkQueueSubmit(vk_queue
, 1, &submit_info
, VK_NULL_HANDLE
)) < 0)
2102 ERR("Failed to blit swapchain buffer, vr %d.\n", vr
);
2106 present_info
.waitSemaphoreCount
= 1;
2107 present_info
.pWaitSemaphores
= &swapchain
->vk_semaphores
[swapchain
->vk_image_index
];
2110 if ((vr
= vk_funcs
->p_vkQueuePresentKHR(vk_queue
, &present_info
)) >= 0)
2111 swapchain
->vk_image_index
= INVALID_VK_IMAGE_INDEX
;
2116 static HRESULT
d3d12_swapchain_present(struct d3d12_swapchain
*swapchain
,
2117 unsigned int sync_interval
, unsigned int flags
)
2119 HANDLE frame_latency_event
;
2124 if (sync_interval
> 4)
2126 WARN("Invalid sync interval %u.\n", sync_interval
);
2127 return DXGI_ERROR_INVALID_CALL
;
2130 if (flags
& ~DXGI_PRESENT_TEST
)
2131 FIXME("Unimplemented flags %#x.\n", flags
);
2132 if (flags
& DXGI_PRESENT_TEST
)
2134 WARN("Returning S_OK for DXGI_PRESENT_TEST.\n");
2138 if (FAILED(hr
= d3d12_swapchain_set_sync_interval(swapchain
, sync_interval
)))
2141 if (!(vk_queue
= vkd3d_acquire_vk_queue(swapchain
->command_queue
)))
2143 ERR("Failed to acquire Vulkan queue.\n");
2147 vr
= d3d12_swapchain_queue_present(swapchain
, vk_queue
);
2148 if (vr
== VK_ERROR_OUT_OF_DATE_KHR
)
2150 vkd3d_release_vk_queue(swapchain
->command_queue
);
2152 if (!d3d12_swapchain_has_user_images(swapchain
))
2154 FIXME("Cannot recreate swapchain without user images.\n");
2155 return DXGI_STATUS_MODE_CHANGED
;
2158 TRACE("Recreating Vulkan swapchain.\n");
2160 d3d12_swapchain_destroy_buffers(swapchain
, FALSE
);
2161 if (FAILED(hr
= d3d12_swapchain_recreate_vulkan_swapchain(swapchain
)))
2164 if (!(vk_queue
= vkd3d_acquire_vk_queue(swapchain
->command_queue
)))
2166 ERR("Failed to acquire Vulkan queue.\n");
2170 if ((vr
= d3d12_swapchain_queue_present(swapchain
, vk_queue
)) < 0)
2171 ERR("Failed to present after recreating swapchain, vr %d.\n", vr
);
2174 vkd3d_release_vk_queue(swapchain
->command_queue
);
2178 ERR("Failed to queue present, vr %d.\n", vr
);
2179 return hresult_from_vk_result(vr
);
2182 if ((frame_latency_event
= swapchain
->frame_latency_event
))
2184 ++swapchain
->frame_number
;
2186 if (FAILED(hr
= ID3D12CommandQueue_Signal(swapchain
->command_queue
,
2187 swapchain
->frame_latency_fence
, swapchain
->frame_number
)))
2189 ERR("Failed to signal frame latency fence, hr %#x.\n", hr
);
2193 if (FAILED(hr
= ID3D12Fence_SetEventOnCompletion(swapchain
->frame_latency_fence
,
2194 swapchain
->frame_number
- swapchain
->frame_latency
, frame_latency_event
)))
2196 ERR("Failed to enqueue frame latency event, hr %#x.\n", hr
);
2201 swapchain
->current_buffer_index
= (swapchain
->current_buffer_index
+ 1) % swapchain
->desc
.BufferCount
;
2202 vr
= d3d12_swapchain_acquire_next_back_buffer(swapchain
);
2203 if (vr
== VK_ERROR_OUT_OF_DATE_KHR
)
2205 if (!d3d12_swapchain_has_user_images(swapchain
))
2207 FIXME("Cannot recreate swapchain without user images.\n");
2208 return DXGI_STATUS_MODE_CHANGED
;
2211 TRACE("Recreating Vulkan swapchain.\n");
2213 d3d12_swapchain_destroy_buffers(swapchain
, FALSE
);
2214 return d3d12_swapchain_recreate_vulkan_swapchain(swapchain
);
2217 ERR("Failed to acquire next Vulkan image, vr %d.\n", vr
);
2218 return hresult_from_vk_result(vr
);
2221 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_Present(IDXGISwapChain4
*iface
, UINT sync_interval
, UINT flags
)
2223 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
2225 TRACE("iface %p, sync_interval %u, flags %#x.\n", iface
, sync_interval
, flags
);
2227 return d3d12_swapchain_present(swapchain
, sync_interval
, flags
);
2230 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetBuffer(IDXGISwapChain4
*iface
,
2231 UINT buffer_idx
, REFIID iid
, void **surface
)
2233 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
2235 TRACE("iface %p, buffer_idx %u, iid %s, surface %p.\n",
2236 iface
, buffer_idx
, debugstr_guid(iid
), surface
);
2238 if (buffer_idx
>= swapchain
->desc
.BufferCount
)
2240 WARN("Invalid buffer index %u.\n", buffer_idx
);
2241 return DXGI_ERROR_INVALID_CALL
;
2244 assert(swapchain
->buffers
[buffer_idx
]);
2245 return ID3D12Resource_QueryInterface(swapchain
->buffers
[buffer_idx
], iid
, surface
);
2248 static HRESULT STDMETHODCALLTYPE DECLSPEC_HOTPATCH
d3d12_swapchain_SetFullscreenState(IDXGISwapChain4
*iface
,
2249 BOOL fullscreen
, IDXGIOutput
*target
)
2251 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
2252 DXGI_SWAP_CHAIN_FULLSCREEN_DESC
*fullscreen_desc
= &swapchain
->fullscreen_desc
;
2253 const DXGI_SWAP_CHAIN_DESC1
*swapchain_desc
= &swapchain
->desc
;
2254 struct wined3d_swapchain_desc wined3d_desc
;
2255 HWND window
= swapchain
->window
;
2258 TRACE("iface %p, fullscreen %#x, target %p.\n", iface
, fullscreen
, target
);
2260 if (!fullscreen
&& target
)
2262 WARN("Invalid call.\n");
2263 return DXGI_ERROR_INVALID_CALL
;
2268 IDXGIOutput_AddRef(target
);
2270 else if (FAILED(hr
= IDXGISwapChain4_GetContainingOutput(iface
, &target
)))
2272 WARN("Failed to get target output for swapchain, hr %#x.\n", hr
);
2276 if (FAILED(hr
= wined3d_swapchain_desc_from_dxgi(&wined3d_desc
, target
, window
, swapchain_desc
,
2279 wined3d_mutex_lock();
2280 wined3d_desc
.windowed
= !fullscreen
;
2281 hr
= wined3d_swapchain_state_set_fullscreen(swapchain
->state
, &wined3d_desc
, NULL
);
2282 wined3d_mutex_unlock();
2286 fullscreen_desc
->Windowed
= wined3d_desc
.windowed
;
2289 IDXGIOutput_Release(target
);
2293 if (swapchain
->target
)
2294 IDXGIOutput_Release(swapchain
->target
);
2295 swapchain
->target
= target
;
2300 IDXGIOutput_Release(target
);
2302 return DXGI_ERROR_NOT_CURRENTLY_AVAILABLE
;
2305 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetFullscreenState(IDXGISwapChain4
*iface
,
2306 BOOL
*fullscreen
, IDXGIOutput
**target
)
2308 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
2312 TRACE("iface %p, fullscreen %p, target %p.\n", iface
, fullscreen
, target
);
2314 if (fullscreen
|| target
)
2316 wined3d_mutex_lock();
2317 windowed
= wined3d_swapchain_state_is_windowed(swapchain
->state
);
2318 wined3d_mutex_unlock();
2322 *fullscreen
= !windowed
;
2328 if (!swapchain
->target
&& FAILED(hr
= IDXGISwapChain4_GetContainingOutput(iface
,
2329 &swapchain
->target
)))
2332 *target
= swapchain
->target
;
2333 IDXGIOutput_AddRef(*target
);
2344 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetDesc(IDXGISwapChain4
*iface
, DXGI_SWAP_CHAIN_DESC
*desc
)
2346 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
2347 const DXGI_SWAP_CHAIN_FULLSCREEN_DESC
*fullscreen_desc
= &swapchain
->fullscreen_desc
;
2348 const DXGI_SWAP_CHAIN_DESC1
*swapchain_desc
= &swapchain
->desc
;
2351 TRACE("iface %p, desc %p.\n", iface
, desc
);
2355 WARN("Invalid pointer.\n");
2356 return E_INVALIDARG
;
2359 wined3d_mutex_lock();
2360 windowed
= wined3d_swapchain_state_is_windowed(swapchain
->state
);
2361 wined3d_mutex_unlock();
2363 desc
->BufferDesc
.Width
= swapchain_desc
->Width
;
2364 desc
->BufferDesc
.Height
= swapchain_desc
->Height
;
2365 desc
->BufferDesc
.RefreshRate
= fullscreen_desc
->RefreshRate
;
2366 desc
->BufferDesc
.Format
= swapchain_desc
->Format
;
2367 desc
->BufferDesc
.ScanlineOrdering
= fullscreen_desc
->ScanlineOrdering
;
2368 desc
->BufferDesc
.Scaling
= fullscreen_desc
->Scaling
;
2369 desc
->SampleDesc
= swapchain_desc
->SampleDesc
;
2370 desc
->BufferUsage
= swapchain_desc
->BufferUsage
;
2371 desc
->BufferCount
= swapchain_desc
->BufferCount
;
2372 desc
->OutputWindow
= swapchain
->window
;
2373 desc
->Windowed
= windowed
;
2374 desc
->SwapEffect
= swapchain_desc
->SwapEffect
;
2375 desc
->Flags
= swapchain_desc
->Flags
;
2380 static HRESULT
d3d12_swapchain_resize_buffers(struct d3d12_swapchain
*swapchain
,
2381 UINT buffer_count
, UINT width
, UINT height
, DXGI_FORMAT format
, UINT flags
)
2383 DXGI_SWAP_CHAIN_DESC1
*desc
, new_desc
;
2388 FIXME("Ignoring flags %#x.\n", flags
);
2390 for (i
= 0; i
< swapchain
->desc
.BufferCount
; ++i
)
2392 ID3D12Resource_AddRef(swapchain
->buffers
[i
]);
2393 if ((refcount
= ID3D12Resource_Release(swapchain
->buffers
[i
])))
2395 WARN("Buffer %p has %u references left.\n", swapchain
->buffers
[i
], refcount
);
2396 return DXGI_ERROR_INVALID_CALL
;
2400 desc
= &swapchain
->desc
;
2401 new_desc
= swapchain
->desc
;
2404 new_desc
.BufferCount
= buffer_count
;
2405 if (!width
|| !height
)
2409 if (!GetClientRect(swapchain
->window
, &client_rect
))
2411 WARN("Failed to get client rect, last error %#x.\n", GetLastError());
2412 return DXGI_ERROR_INVALID_CALL
;
2416 width
= client_rect
.right
;
2418 height
= client_rect
.bottom
;
2420 new_desc
.Width
= width
;
2421 new_desc
.Height
= height
;
2424 new_desc
.Format
= format
;
2426 if (!dxgi_validate_swapchain_desc(&new_desc
))
2427 return DXGI_ERROR_INVALID_CALL
;
2429 if (desc
->Width
== new_desc
.Width
&& desc
->Height
== new_desc
.Height
2430 && desc
->Format
== new_desc
.Format
&& desc
->BufferCount
== new_desc
.BufferCount
)
2433 d3d12_swapchain_destroy_buffers(swapchain
, TRUE
);
2434 swapchain
->desc
= new_desc
;
2435 return d3d12_swapchain_recreate_vulkan_swapchain(swapchain
);
2438 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_ResizeBuffers(IDXGISwapChain4
*iface
,
2439 UINT buffer_count
, UINT width
, UINT height
, DXGI_FORMAT format
, UINT flags
)
2441 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
2443 TRACE("iface %p, buffer_count %u, width %u, height %u, format %s, flags %#x.\n",
2444 iface
, buffer_count
, width
, height
, debug_dxgi_format(format
), flags
);
2446 return d3d12_swapchain_resize_buffers(swapchain
, buffer_count
, width
, height
, format
, flags
);
2449 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_ResizeTarget(IDXGISwapChain4
*iface
,
2450 const DXGI_MODE_DESC
*target_mode_desc
)
2452 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
2454 TRACE("iface %p, target_mode_desc %p.\n", iface
, target_mode_desc
);
2456 return dxgi_swapchain_resize_target(swapchain
->state
, target_mode_desc
);
2459 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetContainingOutput(IDXGISwapChain4
*iface
,
2460 IDXGIOutput
**output
)
2462 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
2463 IUnknown
*device_parent
;
2464 IWineDXGIFactory
*factory
;
2465 IDXGIAdapter
*adapter
;
2468 TRACE("iface %p, output %p.\n", iface
, output
);
2470 if (swapchain
->target
)
2472 IDXGIOutput_AddRef(*output
= swapchain
->target
);
2476 device_parent
= vkd3d_get_device_parent(swapchain
->device
);
2478 if (FAILED(hr
= IUnknown_QueryInterface(device_parent
, &IID_IDXGIAdapter
, (void **)&adapter
)))
2480 WARN("Failed to get adapter, hr %#x.\n", hr
);
2484 if (FAILED(hr
= IDXGIAdapter_GetParent(adapter
, &IID_IWineDXGIFactory
, (void **)&factory
)))
2486 WARN("Failed to get factory, hr %#x.\n", hr
);
2487 IDXGIAdapter_Release(adapter
);
2491 hr
= dxgi_get_output_from_window(factory
, swapchain
->window
, output
);
2492 IWineDXGIFactory_Release(factory
);
2493 IDXGIAdapter_Release(adapter
);
2497 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetFrameStatistics(IDXGISwapChain4
*iface
,
2498 DXGI_FRAME_STATISTICS
*stats
)
2500 FIXME("iface %p, stats %p stub!\n", iface
, stats
);
2505 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetLastPresentCount(IDXGISwapChain4
*iface
,
2506 UINT
*last_present_count
)
2508 FIXME("iface %p, last_present_count %p stub!\n", iface
, last_present_count
);
2513 /* IDXGISwapChain1 methods */
2515 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetDesc1(IDXGISwapChain4
*iface
, DXGI_SWAP_CHAIN_DESC1
*desc
)
2517 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
2519 TRACE("iface %p, desc %p.\n", iface
, desc
);
2523 WARN("Invalid pointer.\n");
2524 return E_INVALIDARG
;
2527 *desc
= swapchain
->desc
;
2531 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetFullscreenDesc(IDXGISwapChain4
*iface
,
2532 DXGI_SWAP_CHAIN_FULLSCREEN_DESC
*desc
)
2534 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
2537 TRACE("iface %p, desc %p.\n", iface
, desc
);
2541 WARN("Invalid pointer.\n");
2542 return E_INVALIDARG
;
2545 wined3d_mutex_lock();
2546 windowed
= wined3d_swapchain_state_is_windowed(swapchain
->state
);
2547 wined3d_mutex_unlock();
2549 *desc
= swapchain
->fullscreen_desc
;
2550 desc
->Windowed
= windowed
;
2554 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetHwnd(IDXGISwapChain4
*iface
, HWND
*hwnd
)
2556 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
2558 TRACE("iface %p, hwnd %p.\n", iface
, hwnd
);
2562 WARN("Invalid pointer.\n");
2563 return DXGI_ERROR_INVALID_CALL
;
2566 *hwnd
= swapchain
->window
;
2570 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetCoreWindow(IDXGISwapChain4
*iface
,
2571 REFIID iid
, void **core_window
)
2573 FIXME("iface %p, iid %s, core_window %p stub!\n", iface
, debugstr_guid(iid
), core_window
);
2576 *core_window
= NULL
;
2578 return DXGI_ERROR_INVALID_CALL
;
2581 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_Present1(IDXGISwapChain4
*iface
,
2582 UINT sync_interval
, UINT flags
, const DXGI_PRESENT_PARAMETERS
*present_parameters
)
2584 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
2586 TRACE("iface %p, sync_interval %u, flags %#x, present_parameters %p.\n",
2587 iface
, sync_interval
, flags
, present_parameters
);
2589 if (present_parameters
)
2590 FIXME("Ignored present parameters %p.\n", present_parameters
);
2592 return d3d12_swapchain_present(swapchain
, sync_interval
, flags
);
2595 static BOOL STDMETHODCALLTYPE
d3d12_swapchain_IsTemporaryMonoSupported(IDXGISwapChain4
*iface
)
2597 FIXME("iface %p stub!\n", iface
);
2602 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetRestrictToOutput(IDXGISwapChain4
*iface
, IDXGIOutput
**output
)
2604 FIXME("iface %p, output %p stub!\n", iface
, output
);
2608 WARN("Invalid pointer.\n");
2609 return E_INVALIDARG
;
2616 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_SetBackgroundColor(IDXGISwapChain4
*iface
, const DXGI_RGBA
*color
)
2618 FIXME("iface %p, color %p stub!\n", iface
, color
);
2623 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetBackgroundColor(IDXGISwapChain4
*iface
, DXGI_RGBA
*color
)
2625 FIXME("iface %p, color %p stub!\n", iface
, color
);
2630 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_SetRotation(IDXGISwapChain4
*iface
, DXGI_MODE_ROTATION rotation
)
2632 FIXME("iface %p, rotation %#x stub!\n", iface
, rotation
);
2637 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetRotation(IDXGISwapChain4
*iface
, DXGI_MODE_ROTATION
*rotation
)
2639 FIXME("iface %p, rotation %p stub!\n", iface
, rotation
);
2644 /* IDXGISwapChain2 methods */
2646 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_SetSourceSize(IDXGISwapChain4
*iface
, UINT width
, UINT height
)
2648 FIXME("iface %p, width %u, height %u stub!\n", iface
, width
, height
);
2653 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetSourceSize(IDXGISwapChain4
*iface
, UINT
*width
, UINT
*height
)
2655 FIXME("iface %p, width %p, height %p stub!\n", iface
, width
, height
);
2660 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_SetMaximumFrameLatency(IDXGISwapChain4
*iface
, UINT max_latency
)
2662 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
2664 TRACE("iface %p, max_latency %u.\n", iface
, max_latency
);
2666 if (!(swapchain
->desc
.Flags
& DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT
))
2668 WARN("DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT not set for swap chain %p.\n", iface
);
2669 return DXGI_ERROR_INVALID_CALL
;
2674 WARN("Invalid maximum frame latency %u.\n", max_latency
);
2675 return DXGI_ERROR_INVALID_CALL
;
2678 swapchain
->frame_latency
= max_latency
;
2682 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetMaximumFrameLatency(IDXGISwapChain4
*iface
, UINT
*max_latency
)
2684 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
2686 TRACE("iface %p, max_latency %p.\n", iface
, max_latency
);
2688 if (!(swapchain
->desc
.Flags
& DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT
))
2690 WARN("DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT not set for swap chain %p.\n", iface
);
2691 return DXGI_ERROR_INVALID_CALL
;
2694 *max_latency
= swapchain
->frame_latency
;
2698 static HANDLE STDMETHODCALLTYPE
d3d12_swapchain_GetFrameLatencyWaitableObject(IDXGISwapChain4
*iface
)
2700 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
2702 TRACE("iface %p.\n", iface
);
2704 return swapchain
->frame_latency_event
;
2707 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_SetMatrixTransform(IDXGISwapChain4
*iface
,
2708 const DXGI_MATRIX_3X2_F
*matrix
)
2710 FIXME("iface %p, matrix %p stub!\n", iface
, matrix
);
2715 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetMatrixTransform(IDXGISwapChain4
*iface
,
2716 DXGI_MATRIX_3X2_F
*matrix
)
2718 FIXME("iface %p, matrix %p stub!\n", iface
, matrix
);
2723 /* IDXGISwapChain3 methods */
2725 static UINT STDMETHODCALLTYPE
d3d12_swapchain_GetCurrentBackBufferIndex(IDXGISwapChain4
*iface
)
2727 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
2729 TRACE("iface %p.\n", iface
);
2731 TRACE("Current back buffer index %u.\n", swapchain
->current_buffer_index
);
2732 assert(swapchain
->current_buffer_index
< swapchain
->desc
.BufferCount
);
2733 return swapchain
->current_buffer_index
;
2736 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_CheckColorSpaceSupport(IDXGISwapChain4
*iface
,
2737 DXGI_COLOR_SPACE_TYPE colour_space
, UINT
*colour_space_support
)
2739 UINT support_flags
= 0;
2741 FIXME("iface %p, colour_space %#x, colour_space_support %p semi-stub!\n",
2742 iface
, colour_space
, colour_space_support
);
2744 if (!colour_space_support
)
2745 return E_INVALIDARG
;
2747 if (colour_space
== DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709
)
2748 support_flags
|= DXGI_SWAP_CHAIN_COLOR_SPACE_SUPPORT_FLAG_PRESENT
;
2750 *colour_space_support
= support_flags
;
2754 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_SetColorSpace1(IDXGISwapChain4
*iface
,
2755 DXGI_COLOR_SPACE_TYPE colour_space
)
2757 FIXME("iface %p, colour_space %#x semi-stub!\n", iface
, colour_space
);
2759 if (colour_space
!= DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709
)
2761 WARN("Colour space %u not supported.\n", colour_space
);
2762 return E_INVALIDARG
;
2768 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_ResizeBuffers1(IDXGISwapChain4
*iface
,
2769 UINT buffer_count
, UINT width
, UINT height
, DXGI_FORMAT format
, UINT flags
,
2770 const UINT
*node_mask
, IUnknown
* const *present_queue
)
2772 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
2775 TRACE("iface %p, buffer_count %u, width %u, height %u, format %s, flags %#x, "
2776 "node_mask %p, present_queue %p.\n",
2777 iface
, buffer_count
, width
, height
, debug_dxgi_format(format
), flags
, node_mask
, present_queue
);
2779 if (!node_mask
|| !present_queue
)
2780 return DXGI_ERROR_INVALID_CALL
;
2782 count
= buffer_count
? buffer_count
: swapchain
->desc
.BufferCount
;
2783 for (i
= 0; i
< count
; ++i
)
2785 if (node_mask
[i
] > 1 || !present_queue
[i
])
2786 return DXGI_ERROR_INVALID_CALL
;
2787 if ((ID3D12CommandQueue
*)present_queue
[i
] != swapchain
->command_queue
)
2788 FIXME("Ignoring present queue %p.\n", present_queue
[i
]);
2791 return d3d12_swapchain_resize_buffers(swapchain
, buffer_count
, width
, height
, format
, flags
);
2794 /* IDXGISwapChain4 methods */
2796 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_SetHDRMetaData(IDXGISwapChain4
*iface
,
2797 DXGI_HDR_METADATA_TYPE type
, UINT size
, void *metadata
)
2799 FIXME("iface %p, type %#x, size %#x, metadata %p stub!\n", iface
, type
, size
, metadata
);
2804 static const struct IDXGISwapChain4Vtbl d3d12_swapchain_vtbl
=
2806 /* IUnknown methods */
2807 d3d12_swapchain_QueryInterface
,
2808 d3d12_swapchain_AddRef
,
2809 d3d12_swapchain_Release
,
2810 /* IDXGIObject methods */
2811 d3d12_swapchain_SetPrivateData
,
2812 d3d12_swapchain_SetPrivateDataInterface
,
2813 d3d12_swapchain_GetPrivateData
,
2814 d3d12_swapchain_GetParent
,
2815 /* IDXGIDeviceSubObject methods */
2816 d3d12_swapchain_GetDevice
,
2817 /* IDXGISwapChain methods */
2818 d3d12_swapchain_Present
,
2819 d3d12_swapchain_GetBuffer
,
2820 d3d12_swapchain_SetFullscreenState
,
2821 d3d12_swapchain_GetFullscreenState
,
2822 d3d12_swapchain_GetDesc
,
2823 d3d12_swapchain_ResizeBuffers
,
2824 d3d12_swapchain_ResizeTarget
,
2825 d3d12_swapchain_GetContainingOutput
,
2826 d3d12_swapchain_GetFrameStatistics
,
2827 d3d12_swapchain_GetLastPresentCount
,
2828 /* IDXGISwapChain1 methods */
2829 d3d12_swapchain_GetDesc1
,
2830 d3d12_swapchain_GetFullscreenDesc
,
2831 d3d12_swapchain_GetHwnd
,
2832 d3d12_swapchain_GetCoreWindow
,
2833 d3d12_swapchain_Present1
,
2834 d3d12_swapchain_IsTemporaryMonoSupported
,
2835 d3d12_swapchain_GetRestrictToOutput
,
2836 d3d12_swapchain_SetBackgroundColor
,
2837 d3d12_swapchain_GetBackgroundColor
,
2838 d3d12_swapchain_SetRotation
,
2839 d3d12_swapchain_GetRotation
,
2840 /* IDXGISwapChain2 methods */
2841 d3d12_swapchain_SetSourceSize
,
2842 d3d12_swapchain_GetSourceSize
,
2843 d3d12_swapchain_SetMaximumFrameLatency
,
2844 d3d12_swapchain_GetMaximumFrameLatency
,
2845 d3d12_swapchain_GetFrameLatencyWaitableObject
,
2846 d3d12_swapchain_SetMatrixTransform
,
2847 d3d12_swapchain_GetMatrixTransform
,
2848 /* IDXGISwapChain3 methods */
2849 d3d12_swapchain_GetCurrentBackBufferIndex
,
2850 d3d12_swapchain_CheckColorSpaceSupport
,
2851 d3d12_swapchain_SetColorSpace1
,
2852 d3d12_swapchain_ResizeBuffers1
,
2853 /* IDXGISwapChain4 methods */
2854 d3d12_swapchain_SetHDRMetaData
,
2857 static BOOL
load_vkd3d_functions(void *vkd3d_handle
)
2859 #define LOAD_FUNCPTR(f) if (!(f = get_library_proc(vkd3d_handle, #f))) return FALSE;
2860 LOAD_FUNCPTR(vkd3d_acquire_vk_queue
)
2861 LOAD_FUNCPTR(vkd3d_create_image_resource
)
2862 LOAD_FUNCPTR(vkd3d_get_device_parent
)
2863 LOAD_FUNCPTR(vkd3d_get_vk_device
)
2864 LOAD_FUNCPTR(vkd3d_get_vk_format
)
2865 LOAD_FUNCPTR(vkd3d_get_vk_physical_device
)
2866 LOAD_FUNCPTR(vkd3d_get_vk_queue_family_index
)
2867 LOAD_FUNCPTR(vkd3d_instance_from_device
)
2868 LOAD_FUNCPTR(vkd3d_instance_get_vk_instance
)
2869 LOAD_FUNCPTR(vkd3d_release_vk_queue
)
2870 LOAD_FUNCPTR(vkd3d_resource_decref
)
2871 LOAD_FUNCPTR(vkd3d_resource_incref
)
2877 static void *vkd3d_handle
;
2879 static BOOL WINAPI
init_vkd3d_once(INIT_ONCE
*once
, void *param
, void **context
)
2881 TRACE("Loading vkd3d %s.\n", SONAME_LIBVKD3D
);
2883 if (!(vkd3d_handle
= load_library(SONAME_LIBVKD3D
)))
2886 if (!load_vkd3d_functions(vkd3d_handle
))
2888 ERR("Failed to load vkd3d functions.\n");
2889 close_library(vkd3d_handle
);
2890 vkd3d_handle
= NULL
;
2897 static BOOL
init_vkd3d(void)
2899 static INIT_ONCE init_once
= INIT_ONCE_STATIC_INIT
;
2900 InitOnceExecuteOnce(&init_once
, init_vkd3d_once
, NULL
, NULL
);
2901 return !!vkd3d_handle
;
2904 static BOOL
init_vk_funcs(struct dxgi_vk_funcs
*dxgi
, VkInstance vk_instance
, VkDevice vk_device
)
2906 PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr
;
2907 PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr
;
2909 dxgi
->vulkan_module
= NULL
;
2911 if (!(vkGetInstanceProcAddr
= load_vulkan(&dxgi
->vulkan_module
)))
2913 ERR_(winediag
)("Failed to load Vulkan.\n");
2917 vkGetDeviceProcAddr
= (void *)vkGetInstanceProcAddr(vk_instance
, "vkGetDeviceProcAddr");
2919 #define LOAD_INSTANCE_PFN(name) \
2920 if (!(dxgi->p_##name = (void *)vkGetInstanceProcAddr(vk_instance, #name))) \
2922 ERR("Failed to get instance proc "#name".\n"); \
2923 close_library(dxgi->vulkan_module); \
2926 LOAD_INSTANCE_PFN(vkCreateWin32SurfaceKHR
)
2927 LOAD_INSTANCE_PFN(vkDestroySurfaceKHR
)
2928 LOAD_INSTANCE_PFN(vkGetPhysicalDeviceMemoryProperties
)
2929 LOAD_INSTANCE_PFN(vkGetPhysicalDeviceSurfaceCapabilitiesKHR
)
2930 LOAD_INSTANCE_PFN(vkGetPhysicalDeviceSurfaceFormatsKHR
)
2931 LOAD_INSTANCE_PFN(vkGetPhysicalDeviceSurfacePresentModesKHR
)
2932 LOAD_INSTANCE_PFN(vkGetPhysicalDeviceSurfaceSupportKHR
)
2933 LOAD_INSTANCE_PFN(vkGetPhysicalDeviceWin32PresentationSupportKHR
)
2934 #undef LOAD_INSTANCE_PFN
2936 #define LOAD_DEVICE_PFN(name) \
2937 if (!(dxgi->p_##name = (void *)vkGetDeviceProcAddr(vk_device, #name))) \
2939 ERR("Failed to get device proc "#name".\n"); \
2940 close_library(dxgi->vulkan_module); \
2943 LOAD_DEVICE_PFN(vkAcquireNextImageKHR
)
2944 LOAD_DEVICE_PFN(vkAllocateCommandBuffers
)
2945 LOAD_DEVICE_PFN(vkAllocateMemory
)
2946 LOAD_DEVICE_PFN(vkBeginCommandBuffer
)
2947 LOAD_DEVICE_PFN(vkBindImageMemory
)
2948 LOAD_DEVICE_PFN(vkCmdBlitImage
)
2949 LOAD_DEVICE_PFN(vkCmdPipelineBarrier
)
2950 LOAD_DEVICE_PFN(vkCreateCommandPool
)
2951 LOAD_DEVICE_PFN(vkCreateFence
)
2952 LOAD_DEVICE_PFN(vkCreateImage
)
2953 LOAD_DEVICE_PFN(vkCreateSemaphore
)
2954 LOAD_DEVICE_PFN(vkCreateSwapchainKHR
)
2955 LOAD_DEVICE_PFN(vkDestroyCommandPool
)
2956 LOAD_DEVICE_PFN(vkDestroyFence
)
2957 LOAD_DEVICE_PFN(vkDestroyImage
)
2958 LOAD_DEVICE_PFN(vkDestroySemaphore
)
2959 LOAD_DEVICE_PFN(vkDestroySwapchainKHR
)
2960 LOAD_DEVICE_PFN(vkEndCommandBuffer
)
2961 LOAD_DEVICE_PFN(vkFreeMemory
)
2962 LOAD_DEVICE_PFN(vkResetCommandBuffer
)
2963 LOAD_DEVICE_PFN(vkGetImageMemoryRequirements
)
2964 LOAD_DEVICE_PFN(vkGetSwapchainImagesKHR
)
2965 LOAD_DEVICE_PFN(vkQueuePresentKHR
)
2966 LOAD_DEVICE_PFN(vkQueueSubmit
)
2967 LOAD_DEVICE_PFN(vkQueueWaitIdle
)
2968 LOAD_DEVICE_PFN(vkResetFences
)
2969 LOAD_DEVICE_PFN(vkWaitForFences
)
2970 #undef LOAD_DEVICE_PFN
2975 static inline struct d3d12_swapchain
*d3d12_swapchain_from_wined3d_swapchain_state_parent(struct wined3d_swapchain_state_parent
*parent
)
2977 return CONTAINING_RECORD(parent
, struct d3d12_swapchain
, state_parent
);
2980 static void CDECL
d3d12_swapchain_windowed_state_changed(struct wined3d_swapchain_state_parent
*parent
,
2983 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_wined3d_swapchain_state_parent(parent
);
2985 TRACE("parent %p, windowed %d.\n", parent
, windowed
);
2987 if (windowed
&& swapchain
->target
)
2989 IDXGIOutput_Release(swapchain
->target
);
2990 swapchain
->target
= NULL
;
2994 static const struct wined3d_swapchain_state_parent_ops d3d12_swapchain_state_parent_ops
=
2996 d3d12_swapchain_windowed_state_changed
,
2999 static HRESULT
d3d12_swapchain_init(struct d3d12_swapchain
*swapchain
, IWineDXGIFactory
*factory
,
3000 ID3D12Device
*device
, ID3D12CommandQueue
*queue
, HWND window
,
3001 const DXGI_SWAP_CHAIN_DESC1
*swapchain_desc
, const DXGI_SWAP_CHAIN_FULLSCREEN_DESC
*fullscreen_desc
)
3003 const struct dxgi_vk_funcs
*vk_funcs
= &swapchain
->vk_funcs
;
3004 struct wined3d_swapchain_desc wined3d_desc
;
3005 VkWin32SurfaceCreateInfoKHR surface_desc
;
3006 VkPhysicalDevice vk_physical_device
;
3007 struct dxgi_factory
*dxgi_factory
;
3008 VkFenceCreateInfo fence_desc
;
3009 uint32_t queue_family_index
;
3010 VkSurfaceKHR vk_surface
;
3011 VkInstance vk_instance
;
3012 IDXGIOutput
*output
;
3019 if (window
== GetDesktopWindow())
3021 WARN("D3D12 swapchain cannot be created on desktop window.\n");
3022 return E_ACCESSDENIED
;
3025 swapchain
->IDXGISwapChain4_iface
.lpVtbl
= &d3d12_swapchain_vtbl
;
3026 swapchain
->state_parent
.ops
= &d3d12_swapchain_state_parent_ops
;
3027 swapchain
->refcount
= 1;
3029 swapchain
->window
= window
;
3030 swapchain
->desc
= *swapchain_desc
;
3031 swapchain
->fullscreen_desc
= *fullscreen_desc
;
3033 swapchain
->present_mode
= VK_PRESENT_MODE_FIFO_KHR
;
3035 switch (swapchain_desc
->SwapEffect
)
3037 case DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL
:
3038 case DXGI_SWAP_EFFECT_FLIP_DISCARD
:
3039 FIXME("Ignoring swap effect %#x.\n", swapchain_desc
->SwapEffect
);
3042 WARN("Invalid swap effect %#x.\n", swapchain_desc
->SwapEffect
);
3043 return DXGI_ERROR_INVALID_CALL
;
3048 ERR_(winediag
)("libvkd3d could not be loaded.\n");
3049 return DXGI_ERROR_UNSUPPORTED
;
3052 if (FAILED(hr
= dxgi_get_output_from_window(factory
, window
, &output
)))
3054 WARN("Failed to get output from window %p, hr %#x.\n", window
, hr
);
3058 hr
= wined3d_swapchain_desc_from_dxgi(&wined3d_desc
, output
, window
, swapchain_desc
,
3062 IDXGIOutput_Release(output
);
3066 dxgi_factory
= unsafe_impl_from_IDXGIFactory((IDXGIFactory
*)factory
);
3067 if (FAILED(hr
= wined3d_swapchain_state_create(&wined3d_desc
, window
, dxgi_factory
->wined3d
,
3068 &swapchain
->state_parent
, &swapchain
->state
)))
3070 IDXGIOutput_Release(output
);
3074 if (!fullscreen_desc
->Windowed
)
3076 hr
= wined3d_swapchain_state_set_fullscreen(swapchain
->state
, &wined3d_desc
, NULL
);
3079 wined3d_swapchain_state_destroy(swapchain
->state
);
3080 IDXGIOutput_Release(output
);
3084 swapchain
->target
= output
;
3088 IDXGIOutput_Release(output
);
3091 if (swapchain_desc
->BufferUsage
&& swapchain_desc
->BufferUsage
!= DXGI_USAGE_RENDER_TARGET_OUTPUT
)
3092 FIXME("Ignoring buffer usage %#x.\n", swapchain_desc
->BufferUsage
);
3093 if (swapchain_desc
->Scaling
!= DXGI_SCALING_STRETCH
&& swapchain_desc
->Scaling
!= DXGI_SCALING_NONE
)
3094 FIXME("Ignoring scaling %#x.\n", swapchain_desc
->Scaling
);
3095 if (swapchain_desc
->AlphaMode
&& swapchain_desc
->AlphaMode
!= DXGI_ALPHA_MODE_IGNORE
)
3096 FIXME("Ignoring alpha mode %#x.\n", swapchain_desc
->AlphaMode
);
3097 if (swapchain_desc
->Flags
& ~(DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT
))
3098 FIXME("Ignoring swapchain flags %#x.\n", swapchain_desc
->Flags
);
3100 if (fullscreen_desc
->RefreshRate
.Numerator
|| fullscreen_desc
->RefreshRate
.Denominator
)
3101 FIXME("Ignoring refresh rate.\n");
3102 if (fullscreen_desc
->ScanlineOrdering
)
3103 FIXME("Unhandled scanline ordering %#x.\n", fullscreen_desc
->ScanlineOrdering
);
3104 if (fullscreen_desc
->Scaling
)
3105 FIXME("Unhandled mode scaling %#x.\n", fullscreen_desc
->Scaling
);
3107 vk_instance
= vkd3d_instance_get_vk_instance(vkd3d_instance_from_device(device
));
3108 vk_physical_device
= vkd3d_get_vk_physical_device(device
);
3109 vk_device
= vkd3d_get_vk_device(device
);
3111 swapchain
->vk_instance
= vk_instance
;
3112 swapchain
->vk_device
= vk_device
;
3113 swapchain
->vk_physical_device
= vk_physical_device
;
3115 if (!init_vk_funcs(&swapchain
->vk_funcs
, vk_instance
, vk_device
))
3117 wined3d_swapchain_state_destroy(swapchain
->state
);
3121 wined3d_private_store_init(&swapchain
->private_store
);
3123 surface_desc
.sType
= VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR
;
3124 surface_desc
.pNext
= NULL
;
3125 surface_desc
.flags
= 0;
3126 surface_desc
.hinstance
= GetModuleHandleA("dxgi.dll");
3127 surface_desc
.hwnd
= window
;
3128 if ((vr
= vk_funcs
->p_vkCreateWin32SurfaceKHR(vk_instance
, &surface_desc
, NULL
, &vk_surface
)) < 0)
3130 WARN("Failed to create Vulkan surface, vr %d.\n", vr
);
3131 d3d12_swapchain_destroy(swapchain
);
3132 return hresult_from_vk_result(vr
);
3134 swapchain
->vk_surface
= vk_surface
;
3136 queue_family_index
= vkd3d_get_vk_queue_family_index(queue
);
3137 if ((vr
= vk_funcs
->p_vkGetPhysicalDeviceSurfaceSupportKHR(vk_physical_device
,
3138 queue_family_index
, vk_surface
, &supported
)) < 0 || !supported
)
3140 FIXME("Queue family does not support presentation, vr %d.\n", vr
);
3141 d3d12_swapchain_destroy(swapchain
);
3142 return DXGI_ERROR_UNSUPPORTED
;
3145 ID3D12CommandQueue_AddRef(swapchain
->command_queue
= queue
);
3146 ID3D12Device_AddRef(swapchain
->device
= device
);
3148 if (FAILED(hr
= d3d12_swapchain_create_vulkan_swapchain(swapchain
)))
3150 d3d12_swapchain_destroy(swapchain
);
3154 fence_desc
.sType
= VK_STRUCTURE_TYPE_FENCE_CREATE_INFO
;
3155 fence_desc
.pNext
= NULL
;
3156 fence_desc
.flags
= 0;
3157 if ((vr
= vk_funcs
->p_vkCreateFence(vk_device
, &fence_desc
, NULL
, &vk_fence
)) < 0)
3159 WARN("Failed to create Vulkan fence, vr %d.\n", vr
);
3160 d3d12_swapchain_destroy(swapchain
);
3161 return hresult_from_vk_result(vr
);
3163 swapchain
->vk_fence
= vk_fence
;
3165 swapchain
->current_buffer_index
= 0;
3166 if ((vr
= d3d12_swapchain_acquire_next_back_buffer(swapchain
)) < 0)
3168 d3d12_swapchain_destroy(swapchain
);
3169 return hresult_from_vk_result(vr
);
3172 if (swapchain_desc
->Flags
& DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT
)
3174 swapchain
->frame_number
= DXGI_MAX_SWAP_CHAIN_BUFFERS
;
3175 swapchain
->frame_latency
= 1;
3177 if (FAILED(hr
= ID3D12Device_CreateFence(device
, DXGI_MAX_SWAP_CHAIN_BUFFERS
,
3178 0, &IID_ID3D12Fence
, (void **)&swapchain
->frame_latency_fence
)))
3180 WARN("Failed to create frame latency fence, hr %#x.\n", hr
);
3181 d3d12_swapchain_destroy(swapchain
);
3185 if (!(swapchain
->frame_latency_event
= CreateEventW(NULL
, FALSE
, TRUE
, NULL
)))
3187 hr
= HRESULT_FROM_WIN32(GetLastError());
3188 WARN("Failed to create frame latency event, hr %#x.\n", hr
);
3189 d3d12_swapchain_destroy(swapchain
);
3194 IWineDXGIFactory_AddRef(swapchain
->factory
= factory
);
3199 HRESULT
d3d12_swapchain_create(IWineDXGIFactory
*factory
, ID3D12CommandQueue
*queue
, HWND window
,
3200 const DXGI_SWAP_CHAIN_DESC1
*swapchain_desc
, const DXGI_SWAP_CHAIN_FULLSCREEN_DESC
*fullscreen_desc
,
3201 IDXGISwapChain1
**swapchain
)
3203 DXGI_SWAP_CHAIN_FULLSCREEN_DESC default_fullscreen_desc
;
3204 struct d3d12_swapchain
*object
;
3205 ID3D12Device
*device
;
3208 if (swapchain_desc
->Format
== DXGI_FORMAT_UNKNOWN
)
3209 return DXGI_ERROR_INVALID_CALL
;
3211 if (!fullscreen_desc
)
3213 memset(&default_fullscreen_desc
, 0, sizeof(default_fullscreen_desc
));
3214 default_fullscreen_desc
.Windowed
= TRUE
;
3215 fullscreen_desc
= &default_fullscreen_desc
;
3218 if (!(object
= heap_alloc_zero(sizeof(*object
))))
3219 return E_OUTOFMEMORY
;
3221 if (FAILED(hr
= ID3D12CommandQueue_GetDevice(queue
, &IID_ID3D12Device
, (void **)&device
)))
3223 ERR("Failed to get D3D12 device, hr %#x.\n", hr
);
3228 hr
= d3d12_swapchain_init(object
, factory
, device
, queue
, window
, swapchain_desc
, fullscreen_desc
);
3229 ID3D12Device_Release(device
);
3236 TRACE("Created swapchain %p.\n", object
);
3238 *swapchain
= (IDXGISwapChain1
*)&object
->IDXGISwapChain4_iface
;
3245 HRESULT
d3d12_swapchain_create(IWineDXGIFactory
*factory
, ID3D12CommandQueue
*queue
, HWND window
,
3246 const DXGI_SWAP_CHAIN_DESC1
*swapchain_desc
, const DXGI_SWAP_CHAIN_FULLSCREEN_DESC
*fullscreen_desc
,
3247 IDXGISwapChain1
**swapchain
)
3249 ERR_(winediag
)("Wine was built without Direct3D 12 support.\n");
3250 return DXGI_ERROR_UNSUPPORTED
;
3253 #endif /* SONAME_LIBVKD3D */