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
20 #include "dxgi_private.h"
22 #define VKD3D_NO_VULKAN_H
23 #define VKD3D_NO_WIN32_TYPES
24 #include "wine/vulkan.h"
27 WINE_DEFAULT_DEBUG_CHANNEL(dxgi
);
28 WINE_DECLARE_DEBUG_CHANNEL(winediag
);
30 static DXGI_SWAP_EFFECT
dxgi_swap_effect_from_wined3d(enum wined3d_swap_effect swap_effect
)
34 case WINED3D_SWAP_EFFECT_DISCARD
:
35 return DXGI_SWAP_EFFECT_DISCARD
;
36 case WINED3D_SWAP_EFFECT_SEQUENTIAL
:
37 return DXGI_SWAP_EFFECT_SEQUENTIAL
;
38 case WINED3D_SWAP_EFFECT_FLIP_DISCARD
:
39 return DXGI_SWAP_EFFECT_FLIP_DISCARD
;
40 case WINED3D_SWAP_EFFECT_FLIP_SEQUENTIAL
:
41 return DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL
;
43 FIXME("Invalid swap effect %#x.\n", swap_effect
);
44 return DXGI_SWAP_EFFECT_DISCARD
;
48 static BOOL
dxgi_validate_flip_swap_effect_format(DXGI_FORMAT format
)
52 case DXGI_FORMAT_R16G16B16A16_FLOAT
:
53 case DXGI_FORMAT_R10G10B10A2_UNORM
:
54 case DXGI_FORMAT_R8G8B8A8_UNORM
:
55 case DXGI_FORMAT_B8G8R8A8_UNORM
:
58 WARN("Invalid swapchain format %#x for flip presentation model.\n", format
);
63 BOOL
dxgi_validate_swapchain_desc(const DXGI_SWAP_CHAIN_DESC1
*desc
)
65 unsigned int min_buffer_count
;
67 switch (desc
->SwapEffect
)
69 case DXGI_SWAP_EFFECT_DISCARD
:
70 case DXGI_SWAP_EFFECT_SEQUENTIAL
:
74 case DXGI_SWAP_EFFECT_FLIP_DISCARD
:
75 case DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL
:
78 if (desc
->Format
&& !dxgi_validate_flip_swap_effect_format(desc
->Format
))
81 if (desc
->SampleDesc
.Count
!= 1 || desc
->SampleDesc
.Quality
)
83 WARN("Invalid sample desc %u, %u for swap effect %#x.\n",
84 desc
->SampleDesc
.Count
, desc
->SampleDesc
.Quality
, desc
->SwapEffect
);
90 WARN("Invalid swap effect %u used.\n", desc
->SwapEffect
);
94 if (desc
->BufferCount
< min_buffer_count
|| desc
->BufferCount
> DXGI_MAX_SWAP_CHAIN_BUFFERS
)
96 WARN("BufferCount is %u.\n", desc
->BufferCount
);
103 HRESULT
dxgi_get_output_from_window(IWineDXGIFactory
*factory
, HWND window
, IDXGIOutput
**dxgi_output
)
105 unsigned int adapter_idx
, output_idx
;
106 DXGI_OUTPUT_DESC desc
;
107 IDXGIAdapter
*adapter
;
112 if (!(monitor
= MonitorFromWindow(window
, MONITOR_DEFAULTTONEAREST
)))
114 WARN("Failed to get monitor from window.\n");
115 return DXGI_ERROR_INVALID_CALL
;
118 for (adapter_idx
= 0; SUCCEEDED(hr
= IWineDXGIFactory_EnumAdapters(factory
, adapter_idx
, &adapter
));
121 for (output_idx
= 0; SUCCEEDED(hr
= IDXGIAdapter_EnumOutputs(adapter
, output_idx
,
122 &output
)); ++output_idx
)
124 if (FAILED(hr
= IDXGIOutput_GetDesc(output
, &desc
)))
126 WARN("Adapter %u output %u: Failed to get output desc, hr %#lx.\n", adapter_idx
,
128 IDXGIOutput_Release(output
);
132 if (desc
.Monitor
== monitor
)
134 *dxgi_output
= output
;
135 IDXGIAdapter_Release(adapter
);
139 IDXGIOutput_Release(output
);
141 IDXGIAdapter_Release(adapter
);
144 if (hr
!= DXGI_ERROR_NOT_FOUND
)
145 WARN("Failed to enumerate outputs, hr %#lx.\n", hr
);
147 WARN("Output could not be found.\n");
148 return DXGI_ERROR_NOT_FOUND
;
151 static HRESULT
dxgi_swapchain_resize_target(struct wined3d_swapchain_state
*state
,
152 const DXGI_MODE_DESC
*target_mode_desc
)
154 struct wined3d_display_mode mode
;
156 if (!target_mode_desc
)
158 WARN("Invalid pointer.\n");
159 return DXGI_ERROR_INVALID_CALL
;
162 TRACE("Mode: %s.\n", debug_dxgi_mode(target_mode_desc
));
164 if (target_mode_desc
->Scaling
)
165 FIXME("Ignoring scaling %#x.\n", target_mode_desc
->Scaling
);
167 wined3d_display_mode_from_dxgi(&mode
, target_mode_desc
);
169 return wined3d_swapchain_state_resize_target(state
, &mode
);
172 static HWND
d3d11_swapchain_get_hwnd(struct d3d11_swapchain
*swapchain
)
174 struct wined3d_swapchain_desc wined3d_desc
;
176 wined3d_mutex_lock();
177 wined3d_swapchain_get_desc(swapchain
->wined3d_swapchain
, &wined3d_desc
);
178 wined3d_mutex_unlock();
180 return wined3d_desc
.device_window
;
183 static inline struct d3d11_swapchain
*d3d11_swapchain_from_IDXGISwapChain1(IDXGISwapChain1
*iface
)
185 return CONTAINING_RECORD(iface
, struct d3d11_swapchain
, IDXGISwapChain1_iface
);
188 /* IUnknown methods */
190 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_QueryInterface(IDXGISwapChain1
*iface
, REFIID riid
, void **object
)
192 TRACE("iface %p, riid %s, object %p\n", iface
, debugstr_guid(riid
), object
);
194 if (IsEqualGUID(riid
, &IID_IUnknown
)
195 || IsEqualGUID(riid
, &IID_IDXGIObject
)
196 || IsEqualGUID(riid
, &IID_IDXGIDeviceSubObject
)
197 || IsEqualGUID(riid
, &IID_IDXGISwapChain
)
198 || IsEqualGUID(riid
, &IID_IDXGISwapChain1
))
200 IUnknown_AddRef(iface
);
205 WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid
));
208 return E_NOINTERFACE
;
211 static ULONG STDMETHODCALLTYPE
d3d11_swapchain_AddRef(IDXGISwapChain1
*iface
)
213 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
214 ULONG refcount
= InterlockedIncrement(&swapchain
->refcount
);
216 TRACE("%p increasing refcount to %lu.\n", swapchain
, refcount
);
219 wined3d_swapchain_incref(swapchain
->wined3d_swapchain
);
224 static ULONG STDMETHODCALLTYPE
d3d11_swapchain_Release(IDXGISwapChain1
*iface
)
226 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
227 ULONG refcount
= InterlockedDecrement(&swapchain
->refcount
);
229 TRACE("%p decreasing refcount to %lu.\n", swapchain
, refcount
);
233 IWineDXGIDevice
*device
= swapchain
->device
;
234 if (swapchain
->target
)
236 WARN("Releasing fullscreen swapchain.\n");
237 IDXGIOutput_Release(swapchain
->target
);
239 IWineDXGIFactory_Release(swapchain
->factory
);
240 wined3d_swapchain_decref(swapchain
->wined3d_swapchain
);
241 IWineDXGIDevice_Release(device
);
247 /* IDXGIObject methods */
249 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_SetPrivateData(IDXGISwapChain1
*iface
,
250 REFGUID guid
, UINT data_size
, const void *data
)
252 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
254 TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface
, debugstr_guid(guid
), data_size
, data
);
256 return dxgi_set_private_data(&swapchain
->private_store
, guid
, data_size
, data
);
259 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_SetPrivateDataInterface(IDXGISwapChain1
*iface
,
260 REFGUID guid
, const IUnknown
*object
)
262 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
264 TRACE("iface %p, guid %s, object %p.\n", iface
, debugstr_guid(guid
), object
);
266 return dxgi_set_private_data_interface(&swapchain
->private_store
, guid
, object
);
269 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetPrivateData(IDXGISwapChain1
*iface
,
270 REFGUID guid
, UINT
*data_size
, void *data
)
272 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
274 TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface
, debugstr_guid(guid
), data_size
, data
);
276 return dxgi_get_private_data(&swapchain
->private_store
, guid
, data_size
, data
);
279 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetParent(IDXGISwapChain1
*iface
, REFIID riid
, void **parent
)
281 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
283 TRACE("iface %p, riid %s, parent %p.\n", iface
, debugstr_guid(riid
), parent
);
285 return IWineDXGIFactory_QueryInterface(swapchain
->factory
, riid
, parent
);
288 /* IDXGIDeviceSubObject methods */
290 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetDevice(IDXGISwapChain1
*iface
, REFIID riid
, void **device
)
292 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
294 TRACE("iface %p, riid %s, device %p.\n", iface
, debugstr_guid(riid
), device
);
296 return IWineDXGIDevice_QueryInterface(swapchain
->device
, riid
, device
);
299 /* IDXGISwapChain1 methods */
301 static HRESULT
d3d11_swapchain_present(struct d3d11_swapchain
*swapchain
,
302 unsigned int sync_interval
, unsigned int flags
)
306 if (sync_interval
> 4)
308 WARN("Invalid sync interval %u.\n", sync_interval
);
309 return DXGI_ERROR_INVALID_CALL
;
312 if (IsIconic(d3d11_swapchain_get_hwnd(swapchain
)))
313 return DXGI_STATUS_OCCLUDED
;
315 if (flags
& ~DXGI_PRESENT_TEST
)
316 FIXME("Unimplemented flags %#x.\n", flags
);
317 if (flags
& DXGI_PRESENT_TEST
)
319 WARN("Returning S_OK for DXGI_PRESENT_TEST.\n");
323 if (SUCCEEDED(hr
= wined3d_swapchain_present(swapchain
->wined3d_swapchain
, NULL
, NULL
, NULL
, sync_interval
, 0)))
324 InterlockedIncrement(&swapchain
->present_count
);
328 static HRESULT STDMETHODCALLTYPE DECLSPEC_HOTPATCH
d3d11_swapchain_Present(IDXGISwapChain1
*iface
, UINT sync_interval
, UINT flags
)
330 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
332 TRACE("iface %p, sync_interval %u, flags %#x.\n", iface
, sync_interval
, flags
);
334 return d3d11_swapchain_present(swapchain
, sync_interval
, flags
);
337 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetBuffer(IDXGISwapChain1
*iface
,
338 UINT buffer_idx
, REFIID riid
, void **surface
)
340 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
341 struct wined3d_texture
*texture
;
345 TRACE("iface %p, buffer_idx %u, riid %s, surface %p\n",
346 iface
, buffer_idx
, debugstr_guid(riid
), surface
);
348 wined3d_mutex_lock();
350 if (!(texture
= wined3d_swapchain_get_back_buffer(swapchain
->wined3d_swapchain
, buffer_idx
)))
352 wined3d_mutex_unlock();
353 return DXGI_ERROR_INVALID_CALL
;
356 parent
= wined3d_texture_get_parent(texture
);
357 hr
= IUnknown_QueryInterface(parent
, riid
, surface
);
358 wined3d_mutex_unlock();
363 static HRESULT STDMETHODCALLTYPE DECLSPEC_HOTPATCH
d3d11_swapchain_SetFullscreenState(IDXGISwapChain1
*iface
,
364 BOOL fullscreen
, IDXGIOutput
*target
)
366 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
367 struct wined3d_swapchain_desc swapchain_desc
;
368 struct wined3d_swapchain_state
*state
;
369 struct dxgi_output
*dxgi_output
;
370 LONG in_set_fullscreen_state
;
374 TRACE("iface %p, fullscreen %#x, target %p.\n", iface
, fullscreen
, target
);
376 if (!fullscreen
&& target
)
378 WARN("Invalid call.\n");
379 return DXGI_ERROR_INVALID_CALL
;
384 IDXGIOutput_AddRef(target
);
386 else if (FAILED(hr
= IDXGISwapChain1_GetContainingOutput(iface
, &target
)))
388 WARN("Failed to get target output for swapchain, hr %#lx.\n", hr
);
391 dxgi_output
= unsafe_impl_from_IDXGIOutput(target
);
393 /* DXGI catches nested SetFullscreenState invocations, earlier versions of d3d
394 * do not. Final Fantasy XIV depends on this behavior. It tries to call SFS on
395 * WM_WINDOWPOSCHANGED messages. */
396 in_set_fullscreen_state
= InterlockedExchange(&swapchain
->in_set_fullscreen_state
, 1);
397 if (in_set_fullscreen_state
)
399 WARN("Nested invocation of SetFullscreenState.\n");
400 IDXGIOutput_Release(target
);
401 IDXGISwapChain1_GetFullscreenState(iface
, &old_fs
, NULL
);
402 return old_fs
== fullscreen
? S_OK
: DXGI_STATUS_MODE_CHANGE_IN_PROGRESS
;
405 wined3d_mutex_lock();
406 state
= wined3d_swapchain_get_state(swapchain
->wined3d_swapchain
);
407 wined3d_swapchain_get_desc(swapchain
->wined3d_swapchain
, &swapchain_desc
);
408 swapchain_desc
.output
= dxgi_output
->wined3d_output
;
409 swapchain_desc
.windowed
= !fullscreen
;
410 hr
= wined3d_swapchain_state_set_fullscreen(state
, &swapchain_desc
, NULL
);
413 IDXGIOutput_Release(target
);
414 hr
= DXGI_ERROR_NOT_CURRENTLY_AVAILABLE
;
420 IDXGIOutput_Release(target
);
424 if (swapchain
->target
)
425 IDXGIOutput_Release(swapchain
->target
);
426 swapchain
->target
= target
;
429 wined3d_mutex_unlock();
430 InterlockedExchange(&swapchain
->in_set_fullscreen_state
, 0);
434 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetFullscreenState(IDXGISwapChain1
*iface
,
435 BOOL
*fullscreen
, IDXGIOutput
**target
)
437 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
438 struct wined3d_swapchain_desc swapchain_desc
;
441 TRACE("iface %p, fullscreen %p, target %p.\n", iface
, fullscreen
, target
);
443 if (fullscreen
|| target
)
445 wined3d_mutex_lock();
446 wined3d_swapchain_get_desc(swapchain
->wined3d_swapchain
, &swapchain_desc
);
447 wined3d_mutex_unlock();
451 *fullscreen
= !swapchain_desc
.windowed
;
455 if (!swapchain_desc
.windowed
)
457 if (!swapchain
->target
&& FAILED(hr
= IDXGISwapChain1_GetContainingOutput(iface
, &swapchain
->target
)))
460 *target
= swapchain
->target
;
461 IDXGIOutput_AddRef(*target
);
472 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetDesc(IDXGISwapChain1
*iface
, DXGI_SWAP_CHAIN_DESC
*desc
)
474 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
475 struct wined3d_swapchain_desc wined3d_desc
;
477 TRACE("iface %p, desc %p.\n", iface
, desc
);
481 WARN("Invalid pointer.\n");
485 wined3d_mutex_lock();
486 wined3d_swapchain_get_desc(swapchain
->wined3d_swapchain
, &wined3d_desc
);
487 wined3d_mutex_unlock();
489 FIXME("Ignoring ScanlineOrdering and Scaling.\n");
491 desc
->BufferDesc
.Width
= wined3d_desc
.backbuffer_width
;
492 desc
->BufferDesc
.Height
= wined3d_desc
.backbuffer_height
;
493 desc
->BufferDesc
.RefreshRate
.Numerator
= wined3d_desc
.refresh_rate
;
494 desc
->BufferDesc
.RefreshRate
.Denominator
= 1;
495 desc
->BufferDesc
.Format
= dxgi_format_from_wined3dformat(wined3d_desc
.backbuffer_format
);
496 desc
->BufferDesc
.ScanlineOrdering
= DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED
;
497 desc
->BufferDesc
.Scaling
= DXGI_MODE_SCALING_UNSPECIFIED
;
498 dxgi_sample_desc_from_wined3d(&desc
->SampleDesc
,
499 wined3d_desc
.multisample_type
, wined3d_desc
.multisample_quality
);
500 desc
->BufferUsage
= dxgi_usage_from_wined3d_bind_flags(wined3d_desc
.backbuffer_bind_flags
);
501 desc
->BufferCount
= wined3d_desc
.backbuffer_count
;
502 desc
->OutputWindow
= wined3d_desc
.device_window
;
503 desc
->Windowed
= wined3d_desc
.windowed
;
504 desc
->SwapEffect
= dxgi_swap_effect_from_wined3d(wined3d_desc
.swap_effect
);
505 desc
->Flags
= dxgi_swapchain_flags_from_wined3d(wined3d_desc
.flags
);
510 static HRESULT
d3d11_swapchain_create_d3d11_textures(struct d3d11_swapchain
*swapchain
,
511 IWineDXGIDevice
*device
, struct wined3d_swapchain_desc
*desc
);
513 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_ResizeBuffers(IDXGISwapChain1
*iface
,
514 UINT buffer_count
, UINT width
, UINT height
, DXGI_FORMAT format
, UINT flags
)
516 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
517 struct wined3d_swapchain_desc wined3d_desc
;
518 struct wined3d_texture
*texture
;
523 TRACE("iface %p, buffer_count %u, width %u, height %u, format %s, flags %#x.\n",
524 iface
, buffer_count
, width
, height
, debug_dxgi_format(format
), flags
);
527 FIXME("Ignoring flags %#x.\n", flags
);
529 wined3d_mutex_lock();
530 wined3d_swapchain_get_desc(swapchain
->wined3d_swapchain
, &wined3d_desc
);
531 for (i
= 0; i
< wined3d_desc
.backbuffer_count
; ++i
)
533 texture
= wined3d_swapchain_get_back_buffer(swapchain
->wined3d_swapchain
, i
);
534 parent
= wined3d_texture_get_parent(texture
);
535 IUnknown_AddRef(parent
);
536 if (IUnknown_Release(parent
))
538 wined3d_mutex_unlock();
539 return DXGI_ERROR_INVALID_CALL
;
542 if (format
!= DXGI_FORMAT_UNKNOWN
)
543 wined3d_desc
.backbuffer_format
= wined3dformat_from_dxgi_format(format
);
544 hr
= wined3d_swapchain_resize_buffers(swapchain
->wined3d_swapchain
, buffer_count
, width
, height
,
545 wined3d_desc
.backbuffer_format
, wined3d_desc
.multisample_type
, wined3d_desc
.multisample_quality
);
546 /* wined3d_swapchain_resize_buffers() may recreate swapchain textures.
547 * We do not need to remove the reference to the wined3d swapchain from the
548 * old d3d11 textures: we just validated above that they have 0 references,
549 * and therefore they are not actually holding a reference to the wined3d
550 * swapchain, and will not do anything with it when they are destroyed. */
551 d3d11_swapchain_create_d3d11_textures(swapchain
, swapchain
->device
, &wined3d_desc
);
552 wined3d_mutex_unlock();
557 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_ResizeTarget(IDXGISwapChain1
*iface
,
558 const DXGI_MODE_DESC
*target_mode_desc
)
560 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
561 struct wined3d_swapchain_state
*state
;
563 TRACE("iface %p, target_mode_desc %p.\n", iface
, target_mode_desc
);
565 state
= wined3d_swapchain_get_state(swapchain
->wined3d_swapchain
);
567 return dxgi_swapchain_resize_target(state
, target_mode_desc
);
570 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetContainingOutput(IDXGISwapChain1
*iface
, IDXGIOutput
**output
)
572 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
575 TRACE("iface %p, output %p.\n", iface
, output
);
577 if (swapchain
->target
)
579 IDXGIOutput_AddRef(*output
= swapchain
->target
);
583 window
= d3d11_swapchain_get_hwnd(swapchain
);
584 return dxgi_get_output_from_window(swapchain
->factory
, window
, output
);
587 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetFrameStatistics(IDXGISwapChain1
*iface
,
588 DXGI_FRAME_STATISTICS
*stats
)
590 FIXME("iface %p, stats %p stub!\n", iface
, stats
);
595 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetLastPresentCount(IDXGISwapChain1
*iface
,
596 UINT
*last_present_count
)
598 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
600 TRACE("iface %p, last_present_count %p.\n", iface
, last_present_count
);
602 *last_present_count
= swapchain
->present_count
;
607 /* IDXGISwapChain1 methods */
609 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetDesc1(IDXGISwapChain1
*iface
, DXGI_SWAP_CHAIN_DESC1
*desc
)
611 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
612 struct wined3d_swapchain_desc wined3d_desc
;
614 TRACE("iface %p, desc %p.\n", iface
, desc
);
618 WARN("Invalid pointer.\n");
622 wined3d_mutex_lock();
623 wined3d_swapchain_get_desc(swapchain
->wined3d_swapchain
, &wined3d_desc
);
624 wined3d_mutex_unlock();
626 FIXME("Ignoring Stereo, Scaling and AlphaMode.\n");
628 desc
->Width
= wined3d_desc
.backbuffer_width
;
629 desc
->Height
= wined3d_desc
.backbuffer_height
;
630 desc
->Format
= dxgi_format_from_wined3dformat(wined3d_desc
.backbuffer_format
);
631 desc
->Stereo
= FALSE
;
632 dxgi_sample_desc_from_wined3d(&desc
->SampleDesc
,
633 wined3d_desc
.multisample_type
, wined3d_desc
.multisample_quality
);
634 desc
->BufferUsage
= dxgi_usage_from_wined3d_bind_flags(wined3d_desc
.backbuffer_bind_flags
);
635 desc
->BufferCount
= wined3d_desc
.backbuffer_count
;
636 desc
->Scaling
= DXGI_SCALING_STRETCH
;
637 desc
->SwapEffect
= dxgi_swap_effect_from_wined3d(wined3d_desc
.swap_effect
);
638 desc
->AlphaMode
= DXGI_ALPHA_MODE_IGNORE
;
639 desc
->Flags
= dxgi_swapchain_flags_from_wined3d(wined3d_desc
.flags
);
644 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetFullscreenDesc(IDXGISwapChain1
*iface
,
645 DXGI_SWAP_CHAIN_FULLSCREEN_DESC
*desc
)
647 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
648 struct wined3d_swapchain_desc wined3d_desc
;
650 TRACE("iface %p, desc %p.\n", iface
, desc
);
654 WARN("Invalid pointer.\n");
658 wined3d_mutex_lock();
659 wined3d_swapchain_get_desc(swapchain
->wined3d_swapchain
, &wined3d_desc
);
660 wined3d_mutex_unlock();
662 FIXME("Ignoring ScanlineOrdering and Scaling.\n");
664 desc
->RefreshRate
.Numerator
= wined3d_desc
.refresh_rate
;
665 desc
->RefreshRate
.Denominator
= 1;
666 desc
->ScanlineOrdering
= DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED
;
667 desc
->Scaling
= DXGI_MODE_SCALING_UNSPECIFIED
;
668 desc
->Windowed
= wined3d_desc
.windowed
;
673 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetHwnd(IDXGISwapChain1
*iface
, HWND
*hwnd
)
675 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
677 TRACE("iface %p, hwnd %p.\n", iface
, hwnd
);
681 WARN("Invalid pointer.\n");
682 return DXGI_ERROR_INVALID_CALL
;
685 *hwnd
= d3d11_swapchain_get_hwnd(swapchain
);
689 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetCoreWindow(IDXGISwapChain1
*iface
,
690 REFIID iid
, void **core_window
)
692 FIXME("iface %p, iid %s, core_window %p stub!\n", iface
, debugstr_guid(iid
), core_window
);
697 return DXGI_ERROR_INVALID_CALL
;
700 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_Present1(IDXGISwapChain1
*iface
,
701 UINT sync_interval
, UINT flags
, const DXGI_PRESENT_PARAMETERS
*present_parameters
)
703 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
705 TRACE("iface %p, sync_interval %u, flags %#x, present_parameters %p.\n",
706 iface
, sync_interval
, flags
, present_parameters
);
708 if (present_parameters
)
709 FIXME("Ignored present parameters %p.\n", present_parameters
);
711 return d3d11_swapchain_present(swapchain
, sync_interval
, flags
);
714 static BOOL STDMETHODCALLTYPE
d3d11_swapchain_IsTemporaryMonoSupported(IDXGISwapChain1
*iface
)
716 FIXME("iface %p stub!\n", iface
);
721 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetRestrictToOutput(IDXGISwapChain1
*iface
, IDXGIOutput
**output
)
723 FIXME("iface %p, output %p stub!\n", iface
, output
);
727 WARN("Invalid pointer.\n");
735 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_SetBackgroundColor(IDXGISwapChain1
*iface
, const DXGI_RGBA
*color
)
737 FIXME("iface %p, color %p stub!\n", iface
, color
);
742 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetBackgroundColor(IDXGISwapChain1
*iface
, DXGI_RGBA
*color
)
744 FIXME("iface %p, color %p stub!\n", iface
, color
);
749 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_SetRotation(IDXGISwapChain1
*iface
, DXGI_MODE_ROTATION rotation
)
751 FIXME("iface %p, rotation %#x stub!\n", iface
, rotation
);
756 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetRotation(IDXGISwapChain1
*iface
, DXGI_MODE_ROTATION
*rotation
)
758 FIXME("iface %p, rotation %p stub!\n", iface
, rotation
);
763 static const struct IDXGISwapChain1Vtbl d3d11_swapchain_vtbl
=
765 /* IUnknown methods */
766 d3d11_swapchain_QueryInterface
,
767 d3d11_swapchain_AddRef
,
768 d3d11_swapchain_Release
,
769 /* IDXGIObject methods */
770 d3d11_swapchain_SetPrivateData
,
771 d3d11_swapchain_SetPrivateDataInterface
,
772 d3d11_swapchain_GetPrivateData
,
773 d3d11_swapchain_GetParent
,
774 /* IDXGIDeviceSubObject methods */
775 d3d11_swapchain_GetDevice
,
776 /* IDXGISwapChain methods */
777 d3d11_swapchain_Present
,
778 d3d11_swapchain_GetBuffer
,
779 d3d11_swapchain_SetFullscreenState
,
780 d3d11_swapchain_GetFullscreenState
,
781 d3d11_swapchain_GetDesc
,
782 d3d11_swapchain_ResizeBuffers
,
783 d3d11_swapchain_ResizeTarget
,
784 d3d11_swapchain_GetContainingOutput
,
785 d3d11_swapchain_GetFrameStatistics
,
786 d3d11_swapchain_GetLastPresentCount
,
787 /* IDXGISwapChain1 methods */
788 d3d11_swapchain_GetDesc1
,
789 d3d11_swapchain_GetFullscreenDesc
,
790 d3d11_swapchain_GetHwnd
,
791 d3d11_swapchain_GetCoreWindow
,
792 d3d11_swapchain_Present1
,
793 d3d11_swapchain_IsTemporaryMonoSupported
,
794 d3d11_swapchain_GetRestrictToOutput
,
795 d3d11_swapchain_SetBackgroundColor
,
796 d3d11_swapchain_GetBackgroundColor
,
797 d3d11_swapchain_SetRotation
,
798 d3d11_swapchain_GetRotation
,
801 static void STDMETHODCALLTYPE
d3d11_swapchain_wined3d_object_released(void *parent
)
803 struct d3d11_swapchain
*swapchain
= parent
;
805 wined3d_private_store_cleanup(&swapchain
->private_store
);
809 static const struct wined3d_parent_ops d3d11_swapchain_wined3d_parent_ops
=
811 d3d11_swapchain_wined3d_object_released
,
814 static inline struct d3d11_swapchain
*d3d11_swapchain_from_wined3d_swapchain_state_parent(struct wined3d_swapchain_state_parent
*parent
)
816 return CONTAINING_RECORD(parent
, struct d3d11_swapchain
, state_parent
);
819 static void CDECL
d3d11_swapchain_windowed_state_changed(struct wined3d_swapchain_state_parent
*parent
,
822 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_wined3d_swapchain_state_parent(parent
);
824 TRACE("parent %p, windowed %d.\n", parent
, windowed
);
826 if (windowed
&& swapchain
->target
)
828 IDXGIOutput_Release(swapchain
->target
);
829 swapchain
->target
= NULL
;
833 static const struct wined3d_swapchain_state_parent_ops d3d11_swapchain_state_parent_ops
=
835 d3d11_swapchain_windowed_state_changed
,
838 static HRESULT
d3d11_swapchain_create_d3d11_textures(struct d3d11_swapchain
*swapchain
,
839 IWineDXGIDevice
*device
, struct wined3d_swapchain_desc
*desc
)
841 IWineDXGIDeviceParent
*dxgi_device_parent
;
842 unsigned int texture_flags
= 0;
846 if (FAILED(hr
= IWineDXGIDevice_QueryInterface(device
,
847 &IID_IWineDXGIDeviceParent
, (void **)&dxgi_device_parent
)))
849 ERR("Device should implement IWineDXGIDeviceParent.\n");
853 if (desc
->flags
& WINED3D_SWAPCHAIN_GDI_COMPATIBLE
)
854 texture_flags
|= WINED3D_TEXTURE_CREATE_GET_DC
;
856 for (i
= 0; i
< desc
->backbuffer_count
; ++i
)
858 IDXGISurface
*surface
;
860 if (FAILED(hr
= IWineDXGIDeviceParent_register_swapchain_texture(dxgi_device_parent
,
861 wined3d_swapchain_get_back_buffer(swapchain
->wined3d_swapchain
, i
), texture_flags
, &surface
)))
863 ERR("Failed to create parent swapchain texture, hr %#lx.\n", hr
);
866 IDXGISurface_Release(surface
);
869 IWineDXGIDeviceParent_Release(dxgi_device_parent
);
873 HRESULT
d3d11_swapchain_init(struct d3d11_swapchain
*swapchain
, struct dxgi_device
*device
,
874 struct wined3d_swapchain_desc
*desc
)
876 struct wined3d_swapchain_state
*state
;
880 if (desc
->backbuffer_format
== WINED3DFMT_UNKNOWN
)
883 if (FAILED(hr
= IWineDXGIAdapter_GetParent(device
->adapter
,
884 &IID_IWineDXGIFactory
, (void **)&swapchain
->factory
)))
886 WARN("Failed to get adapter parent, hr %#lx.\n", hr
);
889 IWineDXGIDevice_AddRef(swapchain
->device
= &device
->IWineDXGIDevice_iface
);
891 swapchain
->IDXGISwapChain1_iface
.lpVtbl
= &d3d11_swapchain_vtbl
;
892 swapchain
->state_parent
.ops
= &d3d11_swapchain_state_parent_ops
;
893 swapchain
->refcount
= 1;
894 wined3d_mutex_lock();
895 wined3d_private_store_init(&swapchain
->private_store
);
897 if (!desc
->windowed
&& (!desc
->backbuffer_width
|| !desc
->backbuffer_height
))
898 FIXME("Fullscreen swapchain with back buffer width/height equal to 0 not supported properly.\n");
900 fullscreen
= !desc
->windowed
;
901 desc
->windowed
= TRUE
;
902 if (FAILED(hr
= wined3d_swapchain_create(device
->wined3d_device
, desc
, &swapchain
->state_parent
,
903 swapchain
, &d3d11_swapchain_wined3d_parent_ops
, &swapchain
->wined3d_swapchain
)))
905 WARN("Failed to create wined3d swapchain, hr %#lx.\n", hr
);
906 if (hr
== WINED3DERR_INVALIDCALL
)
911 state
= wined3d_swapchain_get_state(swapchain
->wined3d_swapchain
);
912 wined3d_swapchain_state_get_size(state
, &desc
->backbuffer_width
, &desc
->backbuffer_height
);
914 if (FAILED(hr
= d3d11_swapchain_create_d3d11_textures(swapchain
, &device
->IWineDXGIDevice_iface
, desc
)))
916 ERR("Failed to create d3d11 textures, hr %#lx.\n", hr
);
920 swapchain
->target
= NULL
;
923 desc
->windowed
= FALSE
;
925 if (FAILED(hr
= IDXGISwapChain1_GetContainingOutput(&swapchain
->IDXGISwapChain1_iface
,
926 &swapchain
->target
)))
928 WARN("Failed to get target output for fullscreen swapchain, hr %#lx.\n", hr
);
929 wined3d_swapchain_decref(swapchain
->wined3d_swapchain
);
933 if (FAILED(hr
= wined3d_swapchain_state_set_fullscreen(state
, desc
, NULL
)))
935 WARN("Failed to set fullscreen state, hr %#lx.\n", hr
);
936 IDXGIOutput_Release(swapchain
->target
);
937 wined3d_swapchain_decref(swapchain
->wined3d_swapchain
);
942 wined3d_mutex_unlock();
947 wined3d_private_store_cleanup(&swapchain
->private_store
);
948 wined3d_mutex_unlock();
949 IWineDXGIFactory_Release(swapchain
->factory
);
950 IWineDXGIDevice_Release(swapchain
->device
);
956 PFN_vkAcquireNextImageKHR p_vkAcquireNextImageKHR
;
957 PFN_vkAllocateCommandBuffers p_vkAllocateCommandBuffers
;
958 PFN_vkAllocateMemory p_vkAllocateMemory
;
959 PFN_vkBeginCommandBuffer p_vkBeginCommandBuffer
;
960 PFN_vkBindImageMemory p_vkBindImageMemory
;
961 PFN_vkCmdBlitImage p_vkCmdBlitImage
;
962 PFN_vkCmdPipelineBarrier p_vkCmdPipelineBarrier
;
963 PFN_vkCreateCommandPool p_vkCreateCommandPool
;
964 PFN_vkCreateFence p_vkCreateFence
;
965 PFN_vkCreateImage p_vkCreateImage
;
966 PFN_vkCreateSemaphore p_vkCreateSemaphore
;
967 PFN_vkCreateSwapchainKHR p_vkCreateSwapchainKHR
;
968 PFN_vkCreateWin32SurfaceKHR p_vkCreateWin32SurfaceKHR
;
969 PFN_vkDestroyCommandPool p_vkDestroyCommandPool
;
970 PFN_vkDestroyFence p_vkDestroyFence
;
971 PFN_vkDestroyImage p_vkDestroyImage
;
972 PFN_vkDestroySemaphore p_vkDestroySemaphore
;
973 PFN_vkDestroySurfaceKHR p_vkDestroySurfaceKHR
;
974 PFN_vkResetCommandBuffer p_vkResetCommandBuffer
;
975 PFN_vkDestroySwapchainKHR p_vkDestroySwapchainKHR
;
976 PFN_vkEndCommandBuffer p_vkEndCommandBuffer
;
977 PFN_vkFreeMemory p_vkFreeMemory
;
978 PFN_vkGetImageMemoryRequirements p_vkGetImageMemoryRequirements
;
979 PFN_vkGetInstanceProcAddr p_vkGetInstanceProcAddr
;
980 PFN_vkGetPhysicalDeviceMemoryProperties p_vkGetPhysicalDeviceMemoryProperties
;
981 PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR p_vkGetPhysicalDeviceSurfaceCapabilitiesKHR
;
982 PFN_vkGetPhysicalDeviceSurfaceFormatsKHR p_vkGetPhysicalDeviceSurfaceFormatsKHR
;
983 PFN_vkGetPhysicalDeviceSurfacePresentModesKHR p_vkGetPhysicalDeviceSurfacePresentModesKHR
;
984 PFN_vkGetPhysicalDeviceSurfaceSupportKHR p_vkGetPhysicalDeviceSurfaceSupportKHR
;
985 PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR p_vkGetPhysicalDeviceWin32PresentationSupportKHR
;
986 PFN_vkGetSwapchainImagesKHR p_vkGetSwapchainImagesKHR
;
987 PFN_vkQueuePresentKHR p_vkQueuePresentKHR
;
988 PFN_vkQueueSubmit p_vkQueueSubmit
;
989 PFN_vkQueueWaitIdle p_vkQueueWaitIdle
;
990 PFN_vkResetFences p_vkResetFences
;
991 PFN_vkWaitForFences p_vkWaitForFences
;
996 static HRESULT
hresult_from_vk_result(VkResult vr
)
1002 case VK_ERROR_OUT_OF_HOST_MEMORY
:
1003 case VK_ERROR_OUT_OF_DEVICE_MEMORY
:
1004 return E_OUTOFMEMORY
;
1006 FIXME("Unhandled VkResult %d.\n", vr
);
1011 #define INVALID_VK_IMAGE_INDEX (~(uint32_t)0)
1013 struct d3d12_swapchain
1015 IDXGISwapChain4 IDXGISwapChain4_iface
;
1017 struct wined3d_private_store private_store
;
1019 struct wined3d_swapchain_state
*state
;
1020 struct wined3d_swapchain_state_parent state_parent
;
1022 VkSurfaceKHR vk_surface
;
1024 VkInstance vk_instance
;
1026 VkPhysicalDevice vk_physical_device
;
1028 HANDLE worker_thread
;
1029 CRITICAL_SECTION worker_cs
;
1030 CONDITION_VARIABLE worker_cv
;
1031 bool worker_running
;
1032 struct list worker_ops
;
1034 /* D3D12 side of the swapchain (frontend): these objects are
1035 * visible to the IDXGISwapChain client, so they must never be
1036 * recreated, except when ResizeBuffers*() is called. */
1037 unsigned int buffer_count
;
1038 VkDeviceMemory vk_memory
;
1039 VkImage vk_images
[DXGI_MAX_SWAP_CHAIN_BUFFERS
];
1040 ID3D12Resource
*buffers
[DXGI_MAX_SWAP_CHAIN_BUFFERS
];
1041 unsigned int current_buffer_index
;
1044 /* Vulkan side of the swapchain (backend): these objects are also
1045 * destroyed and recreated when the Vulkan swapchain becomes out
1046 * of date or when the synchronization interval is changed; this
1047 * operation should be transparent to the IDXGISwapChain client
1048 * (except for timings: recreating the Vulkan swapchain creates a
1049 * noticeable delay, unfortunately). */
1050 VkSwapchainKHR vk_swapchain
;
1051 VkCommandPool vk_cmd_pool
;
1052 VkImage vk_swapchain_images
[DXGI_MAX_SWAP_CHAIN_BUFFERS
];
1053 VkCommandBuffer vk_cmd_buffers
[DXGI_MAX_SWAP_CHAIN_BUFFERS
];
1054 VkSemaphore vk_semaphores
[DXGI_MAX_SWAP_CHAIN_BUFFERS
];
1055 unsigned int vk_swapchain_width
;
1056 unsigned int vk_swapchain_height
;
1057 VkPresentModeKHR present_mode
;
1058 DXGI_SWAP_CHAIN_DESC1 backend_desc
;
1060 ID3D12Fence
*present_fence
;
1062 uint32_t vk_image_index
;
1064 struct dxgi_vk_funcs vk_funcs
;
1066 ID3D12CommandQueue
*command_queue
;
1067 ID3D12Device
*device
;
1068 IWineDXGIFactory
*factory
;
1071 IDXGIOutput
*target
;
1072 DXGI_SWAP_CHAIN_DESC1 desc
;
1073 DXGI_SWAP_CHAIN_FULLSCREEN_DESC fullscreen_desc
;
1074 LONG in_set_fullscreen_state
;
1076 ID3D12Fence
*frame_latency_fence
;
1077 HANDLE frame_latency_event
;
1079 uint64_t frame_number
;
1080 uint32_t frame_latency
;
1083 enum d3d12_swapchain_op_type
1085 D3D12_SWAPCHAIN_OP_PRESENT
,
1086 D3D12_SWAPCHAIN_OP_RESIZE_BUFFERS
,
1089 struct d3d12_swapchain_op
1092 enum d3d12_swapchain_op_type type
;
1097 unsigned int sync_interval
;
1099 unsigned int frame_number
;
1103 /* The resize buffers op takes ownership of the memory and
1104 * images used to back the previous ID3D12Resource
1105 * objects, so that they're only released once the worker
1106 * thread is done with them. */
1107 VkDeviceMemory vk_memory
;
1108 VkImage vk_images
[DXGI_MAX_SWAP_CHAIN_BUFFERS
];
1109 DXGI_SWAP_CHAIN_DESC1 desc
;
1114 static void d3d12_swapchain_op_destroy(struct d3d12_swapchain
*swapchain
, struct d3d12_swapchain_op
*op
)
1116 const struct dxgi_vk_funcs
*vk_funcs
= &swapchain
->vk_funcs
;
1119 if (op
->type
== D3D12_SWAPCHAIN_OP_RESIZE_BUFFERS
)
1121 assert(swapchain
->vk_device
);
1123 for (i
= 0; i
< DXGI_MAX_SWAP_CHAIN_BUFFERS
; ++i
)
1124 vk_funcs
->p_vkDestroyImage(swapchain
->vk_device
, op
->resize_buffers
.vk_images
[i
], NULL
);
1126 vk_funcs
->p_vkFreeMemory(swapchain
->vk_device
, op
->resize_buffers
.vk_memory
, NULL
);
1132 static HRESULT
d3d12_swapchain_op_present_execute(struct d3d12_swapchain
*swapchain
, struct d3d12_swapchain_op
*op
);
1133 static HRESULT
d3d12_swapchain_op_resize_buffers_execute(struct d3d12_swapchain
*swapchain
, struct d3d12_swapchain_op
*op
);
1135 static DWORD WINAPI
d3d12_swapchain_worker_proc(void *data
)
1137 struct d3d12_swapchain
*swapchain
= data
;
1139 EnterCriticalSection(&swapchain
->worker_cs
);
1141 while (swapchain
->worker_running
)
1143 if (!list_empty(&swapchain
->worker_ops
))
1145 struct d3d12_swapchain_op
*op
= LIST_ENTRY(list_head(&swapchain
->worker_ops
), struct d3d12_swapchain_op
, entry
);
1147 list_remove(&op
->entry
);
1149 LeaveCriticalSection(&swapchain
->worker_cs
);
1153 case D3D12_SWAPCHAIN_OP_PRESENT
:
1154 d3d12_swapchain_op_present_execute(swapchain
, op
);
1157 case D3D12_SWAPCHAIN_OP_RESIZE_BUFFERS
:
1158 d3d12_swapchain_op_resize_buffers_execute(swapchain
, op
);
1162 d3d12_swapchain_op_destroy(swapchain
, op
);
1164 EnterCriticalSection(&swapchain
->worker_cs
);
1166 else if (!SleepConditionVariableCS(&swapchain
->worker_cv
, &swapchain
->worker_cs
, INFINITE
))
1168 ERR("Cannot sleep on condition variable, last error %ld.\n", GetLastError());
1173 LeaveCriticalSection(&swapchain
->worker_cs
);
1178 static DXGI_FORMAT
dxgi_format_from_vk_format(VkFormat vk_format
)
1182 case VK_FORMAT_B8G8R8A8_UNORM
: return DXGI_FORMAT_B8G8R8A8_UNORM
;
1183 case VK_FORMAT_R8G8B8A8_UNORM
: return DXGI_FORMAT_R8G8B8A8_UNORM
;
1184 case VK_FORMAT_A2B10G10R10_UNORM_PACK32
: return DXGI_FORMAT_R10G10B10A2_UNORM
;
1185 case VK_FORMAT_R16G16B16A16_SFLOAT
: return DXGI_FORMAT_R16G16B16A16_FLOAT
;
1187 WARN("Unhandled format %#x.\n", vk_format
);
1188 return DXGI_FORMAT_UNKNOWN
;
1192 static VkFormat
get_swapchain_fallback_format(VkFormat vk_format
)
1196 case VK_FORMAT_R8G8B8A8_UNORM
:
1197 case VK_FORMAT_A2B10G10R10_UNORM_PACK32
:
1198 case VK_FORMAT_R16G16B16A16_SFLOAT
:
1199 return VK_FORMAT_B8G8R8A8_UNORM
;
1201 WARN("Unhandled format %#x.\n", vk_format
);
1202 return VK_FORMAT_UNDEFINED
;
1206 static HRESULT
select_vk_format(const struct dxgi_vk_funcs
*vk_funcs
,
1207 VkPhysicalDevice vk_physical_device
, VkSurfaceKHR vk_surface
,
1208 const DXGI_SWAP_CHAIN_DESC1
*swapchain_desc
, VkFormat
*vk_format
)
1210 VkSurfaceFormatKHR
*formats
;
1211 uint32_t format_count
;
1216 *vk_format
= VK_FORMAT_UNDEFINED
;
1218 format
= vkd3d_get_vk_format(swapchain_desc
->Format
);
1220 vr
= vk_funcs
->p_vkGetPhysicalDeviceSurfaceFormatsKHR(vk_physical_device
, vk_surface
, &format_count
, NULL
);
1221 if (vr
< 0 || !format_count
)
1223 WARN("Failed to get supported surface formats, vr %d.\n", vr
);
1224 return DXGI_ERROR_INVALID_CALL
;
1227 if (!(formats
= calloc(format_count
, sizeof(*formats
))))
1228 return E_OUTOFMEMORY
;
1230 if ((vr
= vk_funcs
->p_vkGetPhysicalDeviceSurfaceFormatsKHR(vk_physical_device
,
1231 vk_surface
, &format_count
, formats
)) < 0)
1233 WARN("Failed to enumerate supported surface formats, vr %d.\n", vr
);
1235 return hresult_from_vk_result(vr
);
1238 for (i
= 0; i
< format_count
; ++i
)
1240 if (formats
[i
].format
== format
&& formats
[i
].colorSpace
== VK_COLOR_SPACE_SRGB_NONLINEAR_KHR
)
1243 if (i
== format_count
)
1245 /* Try to create a swapchain with format conversion. */
1246 format
= get_swapchain_fallback_format(format
);
1247 WARN("Failed to find Vulkan swapchain format for %s.\n", debug_dxgi_format(swapchain_desc
->Format
));
1248 for (i
= 0; i
< format_count
; ++i
)
1250 if (formats
[i
].format
== format
&& formats
[i
].colorSpace
== VK_COLOR_SPACE_SRGB_NONLINEAR_KHR
)
1252 format
= formats
[i
].format
;
1258 if (i
== format_count
)
1260 FIXME("Failed to find Vulkan swapchain format for %s.\n", debug_dxgi_format(swapchain_desc
->Format
));
1261 return DXGI_ERROR_UNSUPPORTED
;
1264 TRACE("Using Vulkan swapchain format %#x.\n", format
);
1266 *vk_format
= format
;
1270 static HRESULT
vk_select_memory_type(const struct dxgi_vk_funcs
*vk_funcs
,
1271 VkPhysicalDevice vk_physical_device
, uint32_t memory_type_mask
,
1272 VkMemoryPropertyFlags flags
, uint32_t *memory_type_index
)
1274 VkPhysicalDeviceMemoryProperties memory_properties
;
1277 vk_funcs
->p_vkGetPhysicalDeviceMemoryProperties(vk_physical_device
, &memory_properties
);
1278 for (i
= 0; i
< memory_properties
.memoryTypeCount
; ++i
)
1280 if (!(memory_type_mask
& (1u << i
)))
1283 if ((memory_properties
.memoryTypes
[i
].propertyFlags
& flags
) == flags
)
1285 *memory_type_index
= i
;
1290 FIXME("Failed to find memory type (allowed types %#x).\n", memory_type_mask
);
1294 static BOOL
d3d12_swapchain_is_present_mode_supported(struct d3d12_swapchain
*swapchain
,
1295 VkPresentModeKHR present_mode
)
1297 VkPhysicalDevice vk_physical_device
= swapchain
->vk_physical_device
;
1298 const struct dxgi_vk_funcs
*vk_funcs
= &swapchain
->vk_funcs
;
1299 VkPresentModeKHR
*modes
;
1304 if (present_mode
== VK_PRESENT_MODE_FIFO_KHR
)
1307 if ((vr
= vk_funcs
->p_vkGetPhysicalDeviceSurfacePresentModesKHR(vk_physical_device
,
1308 swapchain
->vk_surface
, &count
, NULL
)) < 0)
1310 WARN("Failed to get count of available present modes, vr %d.\n", vr
);
1316 if (!(modes
= calloc(count
, sizeof(*modes
))))
1318 if ((vr
= vk_funcs
->p_vkGetPhysicalDeviceSurfacePresentModesKHR(vk_physical_device
,
1319 swapchain
->vk_surface
, &count
, modes
)) >= 0)
1321 for (i
= 0; i
< count
; ++i
)
1323 if (modes
[i
] == present_mode
)
1332 WARN("Failed to get available present modes, vr %d.\n", vr
);
1339 static HRESULT
d3d12_swapchain_create_user_buffers(struct d3d12_swapchain
*swapchain
)
1341 const struct dxgi_vk_funcs
*vk_funcs
= &swapchain
->vk_funcs
;
1342 VkDeviceSize image_offset
[DXGI_MAX_SWAP_CHAIN_BUFFERS
];
1343 VkDevice vk_device
= swapchain
->vk_device
;
1344 VkMemoryAllocateInfo allocate_info
;
1345 VkMemoryRequirements requirements
;
1346 VkImageCreateInfo image_info
;
1347 uint32_t memory_type_mask
;
1348 VkDeviceSize memory_size
;
1353 memset(&image_info
, 0, sizeof(image_info
));
1354 image_info
.sType
= VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO
;
1355 image_info
.flags
= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT
;
1356 image_info
.imageType
= VK_IMAGE_TYPE_2D
;
1357 image_info
.format
= swapchain
->vk_format
;
1358 image_info
.extent
.width
= swapchain
->desc
.Width
;
1359 image_info
.extent
.height
= swapchain
->desc
.Height
;
1360 image_info
.extent
.depth
= 1;
1361 image_info
.mipLevels
= 1;
1362 image_info
.arrayLayers
= 1;
1363 image_info
.samples
= VK_SAMPLE_COUNT_1_BIT
;
1364 image_info
.tiling
= VK_IMAGE_TILING_OPTIMAL
;
1365 image_info
.usage
= VK_IMAGE_USAGE_TRANSFER_SRC_BIT
1366 | VK_IMAGE_USAGE_TRANSFER_DST_BIT
1367 | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT
;
1368 if (swapchain
->desc
.BufferUsage
& DXGI_USAGE_SHADER_INPUT
)
1369 image_info
.usage
|= VK_IMAGE_USAGE_SAMPLED_BIT
;
1370 image_info
.sharingMode
= VK_SHARING_MODE_EXCLUSIVE
;
1371 image_info
.queueFamilyIndexCount
= 0;
1372 image_info
.pQueueFamilyIndices
= NULL
;
1373 image_info
.initialLayout
= VK_IMAGE_LAYOUT_UNDEFINED
;
1375 for (i
= 0; i
< swapchain
->desc
.BufferCount
; ++i
)
1377 assert(swapchain
->vk_images
[i
] == VK_NULL_HANDLE
);
1378 if ((vr
= vk_funcs
->p_vkCreateImage(vk_device
, &image_info
, NULL
, &swapchain
->vk_images
[i
])) < 0)
1380 WARN("Failed to create Vulkan image, vr %d.\n", vr
);
1381 swapchain
->vk_images
[i
] = VK_NULL_HANDLE
;
1382 return hresult_from_vk_result(vr
);
1387 memory_type_mask
= ~0u;
1388 for (i
= 0; i
< swapchain
->desc
.BufferCount
; ++i
)
1390 vk_funcs
->p_vkGetImageMemoryRequirements(vk_device
, swapchain
->vk_images
[i
], &requirements
);
1392 TRACE("Size %s, alignment %s, memory types %#x.\n",
1393 wine_dbgstr_longlong(requirements
.size
), wine_dbgstr_longlong(requirements
.alignment
),
1394 requirements
.memoryTypeBits
);
1396 image_offset
[i
] = (memory_size
+ (requirements
.alignment
- 1)) & ~(requirements
.alignment
- 1);
1397 memory_size
= image_offset
[i
] + requirements
.size
;
1399 memory_type_mask
&= requirements
.memoryTypeBits
;
1402 TRACE("Allocating %s bytes for user images.\n", wine_dbgstr_longlong(memory_size
));
1404 allocate_info
.sType
= VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO
;
1405 allocate_info
.pNext
= NULL
;
1406 allocate_info
.allocationSize
= memory_size
;
1408 if (FAILED(hr
= vk_select_memory_type(vk_funcs
, swapchain
->vk_physical_device
,
1409 memory_type_mask
, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT
, &allocate_info
.memoryTypeIndex
)))
1412 assert(swapchain
->vk_memory
== VK_NULL_HANDLE
);
1413 if ((vr
= vk_funcs
->p_vkAllocateMemory(vk_device
, &allocate_info
, NULL
, &swapchain
->vk_memory
)) < 0)
1415 WARN("Failed to allocate device memory, vr %d.\n", vr
);
1416 swapchain
->vk_memory
= VK_NULL_HANDLE
;
1417 return hresult_from_vk_result(vr
);
1420 for (i
= 0; i
< swapchain
->desc
.BufferCount
; ++i
)
1422 if ((vr
= vk_funcs
->p_vkBindImageMemory(vk_device
, swapchain
->vk_images
[i
],
1423 swapchain
->vk_memory
, image_offset
[i
])) < 0)
1425 WARN("Failed to bind image memory, vr %d.\n", vr
);
1426 return hresult_from_vk_result(vr
);
1433 static void vk_cmd_image_barrier(const struct dxgi_vk_funcs
*vk_funcs
, VkCommandBuffer cmd_buffer
,
1434 VkPipelineStageFlags src_stage_mask
, VkPipelineStageFlags dst_stage_mask
,
1435 VkAccessFlags src_access_mask
, VkAccessFlags dst_access_mask
,
1436 VkImageLayout old_layout
, VkImageLayout new_layout
, VkImage image
)
1438 VkImageMemoryBarrier barrier
;
1440 barrier
.sType
= VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER
;
1441 barrier
.pNext
= NULL
;
1442 barrier
.srcAccessMask
= src_access_mask
;
1443 barrier
.dstAccessMask
= dst_access_mask
;
1444 barrier
.oldLayout
= old_layout
;
1445 barrier
.newLayout
= new_layout
;
1446 barrier
.srcQueueFamilyIndex
= VK_QUEUE_FAMILY_IGNORED
;
1447 barrier
.dstQueueFamilyIndex
= VK_QUEUE_FAMILY_IGNORED
;
1448 barrier
.image
= image
;
1449 barrier
.subresourceRange
.aspectMask
= VK_IMAGE_ASPECT_COLOR_BIT
;
1450 barrier
.subresourceRange
.baseMipLevel
= 0;
1451 barrier
.subresourceRange
.levelCount
= VK_REMAINING_MIP_LEVELS
;
1452 barrier
.subresourceRange
.baseArrayLayer
= 0;
1453 barrier
.subresourceRange
.layerCount
= VK_REMAINING_ARRAY_LAYERS
;
1455 vk_funcs
->p_vkCmdPipelineBarrier(cmd_buffer
,
1456 src_stage_mask
, dst_stage_mask
, 0, 0, NULL
, 0, NULL
, 1, &barrier
);
1459 static VkResult
d3d12_swapchain_record_swapchain_blit(struct d3d12_swapchain
*swapchain
,
1460 VkCommandBuffer vk_cmd_buffer
, VkImage vk_dst_image
, VkImage vk_src_image
)
1462 const struct dxgi_vk_funcs
*vk_funcs
= &swapchain
->vk_funcs
;
1463 VkCommandBufferBeginInfo begin_info
;
1468 if (swapchain
->desc
.Width
!= swapchain
->vk_swapchain_width
1469 || swapchain
->desc
.Height
!= swapchain
->vk_swapchain_height
)
1470 filter
= VK_FILTER_LINEAR
;
1472 filter
= VK_FILTER_NEAREST
;
1474 begin_info
.sType
= VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO
;
1475 begin_info
.pNext
= NULL
;
1476 begin_info
.flags
= 0;
1477 begin_info
.pInheritanceInfo
= NULL
;
1479 if ((vr
= vk_funcs
->p_vkBeginCommandBuffer(vk_cmd_buffer
, &begin_info
)) < 0)
1481 WARN("Failed to begin command buffer, vr %d.\n", vr
);
1485 vk_cmd_image_barrier(vk_funcs
, vk_cmd_buffer
,
1486 VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT
, VK_PIPELINE_STAGE_TRANSFER_BIT
,
1487 0, VK_ACCESS_TRANSFER_WRITE_BIT
,
1488 VK_IMAGE_LAYOUT_UNDEFINED
, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
, vk_dst_image
);
1490 blit
.srcSubresource
.aspectMask
= VK_IMAGE_ASPECT_COLOR_BIT
;
1491 blit
.srcSubresource
.mipLevel
= 0;
1492 blit
.srcSubresource
.baseArrayLayer
= 0;
1493 blit
.srcSubresource
.layerCount
= 1;
1494 blit
.srcOffsets
[0].x
= 0;
1495 blit
.srcOffsets
[0].y
= 0;
1496 blit
.srcOffsets
[0].z
= 0;
1497 blit
.srcOffsets
[1].x
= swapchain
->desc
.Width
;
1498 blit
.srcOffsets
[1].y
= swapchain
->desc
.Height
;
1499 blit
.srcOffsets
[1].z
= 1;
1500 blit
.dstSubresource
= blit
.srcSubresource
;
1501 blit
.dstOffsets
[0].x
= 0;
1502 blit
.dstOffsets
[0].y
= 0;
1503 blit
.dstOffsets
[0].z
= 0;
1504 if (swapchain
->desc
.Scaling
== DXGI_SCALING_NONE
)
1506 blit
.srcOffsets
[1].x
= min(swapchain
->vk_swapchain_width
, blit
.srcOffsets
[1].x
);
1507 blit
.srcOffsets
[1].y
= min(swapchain
->vk_swapchain_height
, blit
.srcOffsets
[1].y
);
1508 blit
.dstOffsets
[1].x
= blit
.srcOffsets
[1].x
;
1509 blit
.dstOffsets
[1].y
= blit
.srcOffsets
[1].y
;
1513 /* FIXME: handle DXGI_SCALING_ASPECT_RATIO_STRETCH. */
1514 blit
.dstOffsets
[1].x
= swapchain
->vk_swapchain_width
;
1515 blit
.dstOffsets
[1].y
= swapchain
->vk_swapchain_height
;
1517 blit
.dstOffsets
[1].z
= 1;
1519 vk_funcs
->p_vkCmdBlitImage(vk_cmd_buffer
,
1520 vk_src_image
, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL
,
1521 vk_dst_image
, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
,
1524 vk_cmd_image_barrier(vk_funcs
, vk_cmd_buffer
,
1525 VK_PIPELINE_STAGE_TRANSFER_BIT
, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT
,
1526 VK_ACCESS_TRANSFER_WRITE_BIT
, 0,
1527 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR
, vk_dst_image
);
1529 if ((vr
= vk_funcs
->p_vkEndCommandBuffer(vk_cmd_buffer
)) < 0)
1530 WARN("Failed to end command buffer, vr %d.\n", vr
);
1535 static HRESULT
d3d12_swapchain_create_command_buffers(struct d3d12_swapchain
*swapchain
)
1537 const struct dxgi_vk_funcs
*vk_funcs
= &swapchain
->vk_funcs
;
1538 VkDevice vk_device
= swapchain
->vk_device
;
1539 VkCommandBufferAllocateInfo allocate_info
;
1540 VkSemaphoreCreateInfo semaphore_info
;
1541 VkCommandPoolCreateInfo pool_info
;
1545 pool_info
.sType
= VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO
;
1546 pool_info
.pNext
= NULL
;
1547 pool_info
.flags
= VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT
;
1548 pool_info
.queueFamilyIndex
= vkd3d_get_vk_queue_family_index(swapchain
->command_queue
);
1550 assert(swapchain
->vk_cmd_pool
== VK_NULL_HANDLE
);
1551 if ((vr
= vk_funcs
->p_vkCreateCommandPool(vk_device
, &pool_info
,
1552 NULL
, &swapchain
->vk_cmd_pool
)) < 0)
1554 WARN("Failed to create command pool, vr %d.\n", vr
);
1555 swapchain
->vk_cmd_pool
= VK_NULL_HANDLE
;
1556 return hresult_from_vk_result(vr
);
1559 allocate_info
.sType
= VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO
;
1560 allocate_info
.pNext
= NULL
;
1561 allocate_info
.commandPool
= swapchain
->vk_cmd_pool
;
1562 allocate_info
.level
= VK_COMMAND_BUFFER_LEVEL_PRIMARY
;
1563 allocate_info
.commandBufferCount
= swapchain
->buffer_count
;
1565 if ((vr
= vk_funcs
->p_vkAllocateCommandBuffers(vk_device
, &allocate_info
,
1566 swapchain
->vk_cmd_buffers
)) < 0)
1568 WARN("Failed to allocate command buffers, vr %d.\n", vr
);
1569 return hresult_from_vk_result(vr
);
1572 for (i
= 0; i
< swapchain
->buffer_count
; ++i
)
1574 semaphore_info
.sType
= VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO
;
1575 semaphore_info
.pNext
= NULL
;
1576 semaphore_info
.flags
= 0;
1578 assert(swapchain
->vk_semaphores
[i
] == VK_NULL_HANDLE
);
1579 if ((vr
= vk_funcs
->p_vkCreateSemaphore(vk_device
, &semaphore_info
,
1580 NULL
, &swapchain
->vk_semaphores
[i
])) < 0)
1582 WARN("Failed to create semaphore, vr %d.\n", vr
);
1583 swapchain
->vk_semaphores
[i
] = VK_NULL_HANDLE
;
1584 return hresult_from_vk_result(vr
);
1591 static HRESULT
d3d12_swapchain_create_image_resources(struct d3d12_swapchain
*swapchain
)
1593 struct vkd3d_image_resource_create_info resource_info
;
1594 ID3D12Device
*device
= swapchain
->device
;
1598 resource_info
.type
= VKD3D_STRUCTURE_TYPE_IMAGE_RESOURCE_CREATE_INFO
;
1599 resource_info
.next
= NULL
;
1600 resource_info
.desc
.Dimension
= D3D12_RESOURCE_DIMENSION_TEXTURE2D
;
1601 resource_info
.desc
.Alignment
= 0;
1602 resource_info
.desc
.Width
= swapchain
->desc
.Width
;
1603 resource_info
.desc
.Height
= swapchain
->desc
.Height
;
1604 resource_info
.desc
.DepthOrArraySize
= 1;
1605 resource_info
.desc
.MipLevels
= 1;
1606 resource_info
.desc
.Format
= dxgi_format_from_vk_format(swapchain
->vk_format
);
1607 resource_info
.desc
.SampleDesc
.Count
= 1;
1608 resource_info
.desc
.SampleDesc
.Quality
= 0;
1609 resource_info
.desc
.Layout
= D3D12_TEXTURE_LAYOUT_UNKNOWN
;
1610 resource_info
.desc
.Flags
= D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET
;
1611 resource_info
.flags
= VKD3D_RESOURCE_INITIAL_STATE_TRANSITION
| VKD3D_RESOURCE_PRESENT_STATE_TRANSITION
;
1612 resource_info
.present_state
= D3D12_RESOURCE_STATE_COPY_SOURCE
;
1614 for (i
= 0; i
< swapchain
->desc
.BufferCount
; ++i
)
1616 assert(swapchain
->vk_images
[i
]);
1617 assert(!swapchain
->buffers
[i
]);
1619 resource_info
.vk_image
= swapchain
->vk_images
[i
];
1621 if (FAILED(hr
= vkd3d_create_image_resource(device
, &resource_info
, &swapchain
->buffers
[i
])))
1623 WARN("Failed to create vkd3d resource for Vulkan image %u, hr %#lx.\n", i
, hr
);
1627 vkd3d_resource_incref(swapchain
->buffers
[i
]);
1628 ID3D12Resource_Release(swapchain
->buffers
[i
]);
1634 static VkResult
d3d12_swapchain_acquire_next_vulkan_image(struct d3d12_swapchain
*swapchain
)
1636 const struct dxgi_vk_funcs
*vk_funcs
= &swapchain
->vk_funcs
;
1637 VkDevice vk_device
= swapchain
->vk_device
;
1638 VkFence vk_fence
= swapchain
->vk_fence
;
1641 swapchain
->vk_image_index
= INVALID_VK_IMAGE_INDEX
;
1643 if ((vr
= vk_funcs
->p_vkAcquireNextImageKHR(vk_device
, swapchain
->vk_swapchain
, UINT64_MAX
,
1644 VK_NULL_HANDLE
, vk_fence
, &swapchain
->vk_image_index
)) < 0)
1646 WARN("Failed to acquire next Vulkan image, vr %d.\n", vr
);
1650 if ((vr
= vk_funcs
->p_vkWaitForFences(vk_device
, 1, &vk_fence
, VK_TRUE
, UINT64_MAX
)) != VK_SUCCESS
)
1652 ERR("Failed to wait for fence, vr %d.\n", vr
);
1655 if ((vr
= vk_funcs
->p_vkResetFences(vk_device
, 1, &vk_fence
)) < 0)
1656 ERR("Failed to reset fence, vr %d.\n", vr
);
1661 static void d3d12_swapchain_destroy_vulkan_resources(struct d3d12_swapchain
*swapchain
)
1663 const struct dxgi_vk_funcs
*vk_funcs
= &swapchain
->vk_funcs
;
1667 if (swapchain
->command_queue
)
1669 vk_queue
= vkd3d_acquire_vk_queue(swapchain
->command_queue
);
1670 vk_funcs
->p_vkQueueWaitIdle(vk_queue
);
1671 vkd3d_release_vk_queue(swapchain
->command_queue
);
1674 if (swapchain
->vk_device
)
1676 for (i
= 0; i
< swapchain
->buffer_count
; ++i
)
1678 vk_funcs
->p_vkDestroySemaphore(swapchain
->vk_device
, swapchain
->vk_semaphores
[i
], NULL
);
1679 swapchain
->vk_semaphores
[i
] = VK_NULL_HANDLE
;
1682 vk_funcs
->p_vkDestroyCommandPool(swapchain
->vk_device
, swapchain
->vk_cmd_pool
, NULL
);
1683 swapchain
->vk_cmd_pool
= VK_NULL_HANDLE
;
1687 static void d3d12_swapchain_destroy_d3d12_resources(struct d3d12_swapchain
*swapchain
)
1689 const struct dxgi_vk_funcs
*vk_funcs
= &swapchain
->vk_funcs
;
1692 for (i
= 0; i
< swapchain
->desc
.BufferCount
; ++i
)
1694 if (swapchain
->buffers
[i
])
1696 vkd3d_resource_decref(swapchain
->buffers
[i
]);
1697 swapchain
->buffers
[i
] = NULL
;
1699 if (swapchain
->vk_device
)
1701 vk_funcs
->p_vkDestroyImage(swapchain
->vk_device
, swapchain
->vk_images
[i
], NULL
);
1702 swapchain
->vk_images
[i
] = VK_NULL_HANDLE
;
1705 if (swapchain
->vk_device
)
1707 vk_funcs
->p_vkFreeMemory(swapchain
->vk_device
, swapchain
->vk_memory
, NULL
);
1708 swapchain
->vk_memory
= VK_NULL_HANDLE
;
1712 static HRESULT
d3d12_swapchain_create_vulkan_swapchain(struct d3d12_swapchain
*swapchain
)
1714 VkPhysicalDevice vk_physical_device
= swapchain
->vk_physical_device
;
1715 const struct dxgi_vk_funcs
*vk_funcs
= &swapchain
->vk_funcs
;
1716 VkSwapchainCreateInfoKHR vk_swapchain_desc
;
1717 VkDevice vk_device
= swapchain
->vk_device
;
1718 unsigned int width
, height
, image_count
;
1719 VkSurfaceCapabilitiesKHR surface_caps
;
1720 VkFormat vk_swapchain_format
;
1721 VkSwapchainKHR vk_swapchain
;
1722 VkImageUsageFlags usage
;
1726 if (FAILED(hr
= select_vk_format(vk_funcs
, vk_physical_device
,
1727 swapchain
->vk_surface
, &swapchain
->backend_desc
, &vk_swapchain_format
)))
1730 if ((vr
= vk_funcs
->p_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(vk_physical_device
,
1731 swapchain
->vk_surface
, &surface_caps
)) < 0)
1733 WARN("Failed to get surface capabilities, vr %d.\n", vr
);
1734 return hresult_from_vk_result(vr
);
1737 image_count
= swapchain
->backend_desc
.BufferCount
;
1738 image_count
= max(image_count
, surface_caps
.minImageCount
);
1739 if (surface_caps
.maxImageCount
)
1740 image_count
= min(image_count
, surface_caps
.maxImageCount
);
1742 if (image_count
!= swapchain
->backend_desc
.BufferCount
)
1744 WARN("Buffer count %u is not supported (%u-%u).\n", swapchain
->backend_desc
.BufferCount
,
1745 surface_caps
.minImageCount
, surface_caps
.maxImageCount
);
1748 width
= swapchain
->backend_desc
.Width
;
1749 height
= swapchain
->backend_desc
.Height
;
1750 width
= max(width
, surface_caps
.minImageExtent
.width
);
1751 width
= min(width
, surface_caps
.maxImageExtent
.width
);
1752 height
= max(height
, surface_caps
.minImageExtent
.height
);
1753 height
= min(height
, surface_caps
.maxImageExtent
.height
);
1755 if (width
!= swapchain
->backend_desc
.Width
|| height
!= swapchain
->backend_desc
.Height
)
1757 WARN("Swapchain dimensions %ux%u are not supported (%u-%u x %u-%u).\n",
1758 swapchain
->backend_desc
.Width
, swapchain
->backend_desc
.Height
,
1759 surface_caps
.minImageExtent
.width
, surface_caps
.maxImageExtent
.width
,
1760 surface_caps
.minImageExtent
.height
, surface_caps
.maxImageExtent
.height
);
1763 TRACE("Vulkan swapchain extent %ux%u.\n", width
, height
);
1765 if (!(surface_caps
.supportedCompositeAlpha
& VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR
))
1767 FIXME("Unsupported alpha mode.\n");
1768 return DXGI_ERROR_UNSUPPORTED
;
1771 usage
= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT
;
1772 usage
|= surface_caps
.supportedUsageFlags
& VK_IMAGE_USAGE_TRANSFER_SRC_BIT
;
1773 usage
|= surface_caps
.supportedUsageFlags
& VK_IMAGE_USAGE_TRANSFER_DST_BIT
;
1774 if (!(usage
& VK_IMAGE_USAGE_TRANSFER_SRC_BIT
) || !(usage
& VK_IMAGE_USAGE_TRANSFER_DST_BIT
))
1775 WARN("Transfer not supported for swapchain images.\n");
1776 if (swapchain
->backend_desc
.BufferUsage
& DXGI_USAGE_SHADER_INPUT
)
1778 usage
|= surface_caps
.supportedUsageFlags
& VK_IMAGE_USAGE_SAMPLED_BIT
;
1779 if (!(usage
& VK_IMAGE_USAGE_SAMPLED_BIT
))
1780 WARN("Sampling not supported for swapchain images.\n");
1783 vk_swapchain_desc
.sType
= VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR
;
1784 vk_swapchain_desc
.pNext
= NULL
;
1785 vk_swapchain_desc
.flags
= 0;
1786 vk_swapchain_desc
.surface
= swapchain
->vk_surface
;
1787 vk_swapchain_desc
.minImageCount
= image_count
;
1788 vk_swapchain_desc
.imageFormat
= vk_swapchain_format
;
1789 vk_swapchain_desc
.imageColorSpace
= VK_COLOR_SPACE_SRGB_NONLINEAR_KHR
;
1790 vk_swapchain_desc
.imageExtent
.width
= width
;
1791 vk_swapchain_desc
.imageExtent
.height
= height
;
1792 vk_swapchain_desc
.imageArrayLayers
= 1;
1793 vk_swapchain_desc
.imageUsage
= usage
;
1794 vk_swapchain_desc
.imageSharingMode
= VK_SHARING_MODE_EXCLUSIVE
;
1795 vk_swapchain_desc
.queueFamilyIndexCount
= 0;
1796 vk_swapchain_desc
.pQueueFamilyIndices
= NULL
;
1797 vk_swapchain_desc
.preTransform
= surface_caps
.currentTransform
;
1798 vk_swapchain_desc
.compositeAlpha
= VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR
;
1799 vk_swapchain_desc
.presentMode
= swapchain
->present_mode
;
1800 vk_swapchain_desc
.clipped
= VK_TRUE
;
1801 vk_swapchain_desc
.oldSwapchain
= swapchain
->vk_swapchain
;
1802 if ((vr
= vk_funcs
->p_vkCreateSwapchainKHR(vk_device
, &vk_swapchain_desc
, NULL
, &vk_swapchain
)) < 0)
1804 WARN("Failed to create Vulkan swapchain, vr %d.\n", vr
);
1805 return hresult_from_vk_result(vr
);
1808 if (swapchain
->vk_swapchain
)
1809 vk_funcs
->p_vkDestroySwapchainKHR(swapchain
->vk_device
, swapchain
->vk_swapchain
, NULL
);
1811 if ((vr
= vk_funcs
->p_vkGetSwapchainImagesKHR(vk_device
, vk_swapchain
, &image_count
, NULL
)) < 0)
1813 WARN("Failed to get Vulkan swapchain images, vr %d.\n", vr
);
1814 return hresult_from_vk_result(vr
);
1816 if (image_count
> ARRAY_SIZE(swapchain
->vk_swapchain_images
))
1818 FIXME("Unsupported Vulkan swapchain image count %u.\n", image_count
);
1821 swapchain
->buffer_count
= image_count
;
1822 if ((vr
= vk_funcs
->p_vkGetSwapchainImagesKHR(vk_device
, vk_swapchain
,
1823 &image_count
, swapchain
->vk_swapchain_images
)) < 0)
1825 WARN("Failed to get Vulkan swapchain images, vr %d.\n", vr
);
1826 return hresult_from_vk_result(vr
);
1829 swapchain
->vk_swapchain
= vk_swapchain
;
1830 swapchain
->vk_swapchain_width
= width
;
1831 swapchain
->vk_swapchain_height
= height
;
1833 swapchain
->vk_image_index
= INVALID_VK_IMAGE_INDEX
;
1838 static HRESULT
d3d12_swapchain_create_vulkan_resources(struct d3d12_swapchain
*swapchain
)
1842 if (FAILED(hr
= d3d12_swapchain_create_vulkan_swapchain(swapchain
)))
1845 return d3d12_swapchain_create_command_buffers(swapchain
);
1848 static HRESULT
d3d12_swapchain_create_d3d12_resources(struct d3d12_swapchain
*swapchain
)
1852 if (!(swapchain
->vk_format
= vkd3d_get_vk_format(swapchain
->desc
.Format
)))
1854 WARN("Invalid format %#x.\n", swapchain
->desc
.Format
);
1855 return DXGI_ERROR_INVALID_CALL
;
1858 if (FAILED(hr
= d3d12_swapchain_create_user_buffers(swapchain
)))
1861 return d3d12_swapchain_create_image_resources(swapchain
);
1864 static inline struct d3d12_swapchain
*d3d12_swapchain_from_IDXGISwapChain4(IDXGISwapChain4
*iface
)
1866 return CONTAINING_RECORD(iface
, struct d3d12_swapchain
, IDXGISwapChain4_iface
);
1869 /* IUnknown methods */
1871 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_QueryInterface(IDXGISwapChain4
*iface
, REFIID iid
, void **object
)
1873 TRACE("iface %p, iid %s, object %p.\n", iface
, debugstr_guid(iid
), object
);
1875 if (IsEqualGUID(iid
, &IID_IUnknown
)
1876 || IsEqualGUID(iid
, &IID_IDXGIObject
)
1877 || IsEqualGUID(iid
, &IID_IDXGIDeviceSubObject
)
1878 || IsEqualGUID(iid
, &IID_IDXGISwapChain
)
1879 || IsEqualGUID(iid
, &IID_IDXGISwapChain1
)
1880 || IsEqualGUID(iid
, &IID_IDXGISwapChain2
)
1881 || IsEqualGUID(iid
, &IID_IDXGISwapChain3
)
1882 || IsEqualGUID(iid
, &IID_IDXGISwapChain4
))
1884 IUnknown_AddRef(iface
);
1889 WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid
));
1892 return E_NOINTERFACE
;
1895 static ULONG STDMETHODCALLTYPE
d3d12_swapchain_AddRef(IDXGISwapChain4
*iface
)
1897 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
1898 ULONG refcount
= InterlockedIncrement(&swapchain
->refcount
);
1900 TRACE("%p increasing refcount to %lu.\n", swapchain
, refcount
);
1905 static void d3d12_swapchain_destroy(struct d3d12_swapchain
*swapchain
)
1907 const struct dxgi_vk_funcs
*vk_funcs
= &swapchain
->vk_funcs
;
1908 void *vulkan_module
= vk_funcs
->vulkan_module
;
1909 struct d3d12_swapchain_op
*op
, *op2
;
1912 EnterCriticalSection(&swapchain
->worker_cs
);
1913 swapchain
->worker_running
= false;
1914 WakeAllConditionVariable(&swapchain
->worker_cv
);
1915 LeaveCriticalSection(&swapchain
->worker_cs
);
1917 if (swapchain
->worker_thread
)
1919 if ((ret
= WaitForSingleObject(swapchain
->worker_thread
, INFINITE
)) != WAIT_OBJECT_0
)
1920 ERR("Failed to wait for worker thread, return value %ld.\n", ret
);
1922 if (!CloseHandle(swapchain
->worker_thread
))
1923 ERR("Failed to close worker thread, last error %ld.\n", GetLastError());
1926 DeleteCriticalSection(&swapchain
->worker_cs
);
1928 LIST_FOR_EACH_ENTRY_SAFE(op
, op2
, &swapchain
->worker_ops
, struct d3d12_swapchain_op
, entry
)
1930 d3d12_swapchain_op_destroy(swapchain
, op
);
1933 d3d12_swapchain_destroy_vulkan_resources(swapchain
);
1934 d3d12_swapchain_destroy_d3d12_resources(swapchain
);
1936 if (swapchain
->present_fence
)
1937 ID3D12Fence_Release(swapchain
->present_fence
);
1939 if (swapchain
->frame_latency_event
)
1940 CloseHandle(swapchain
->frame_latency_event
);
1942 if (swapchain
->frame_latency_fence
)
1943 ID3D12Fence_Release(swapchain
->frame_latency_fence
);
1945 if (swapchain
->command_queue
)
1946 ID3D12CommandQueue_Release(swapchain
->command_queue
);
1948 wined3d_private_store_cleanup(&swapchain
->private_store
);
1950 if (swapchain
->vk_device
)
1952 vk_funcs
->p_vkDestroyFence(swapchain
->vk_device
, swapchain
->vk_fence
, NULL
);
1953 vk_funcs
->p_vkDestroySwapchainKHR(swapchain
->vk_device
, swapchain
->vk_swapchain
, NULL
);
1956 if (swapchain
->vk_instance
)
1957 vk_funcs
->p_vkDestroySurfaceKHR(swapchain
->vk_instance
, swapchain
->vk_surface
, NULL
);
1959 if (swapchain
->target
)
1961 WARN("Destroying fullscreen swapchain.\n");
1962 IDXGIOutput_Release(swapchain
->target
);
1965 if (swapchain
->device
)
1966 ID3D12Device_Release(swapchain
->device
);
1968 if (swapchain
->factory
)
1969 IWineDXGIFactory_Release(swapchain
->factory
);
1971 FreeLibrary(vulkan_module
);
1973 wined3d_swapchain_state_destroy(swapchain
->state
);
1976 static ULONG STDMETHODCALLTYPE
d3d12_swapchain_Release(IDXGISwapChain4
*iface
)
1978 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
1979 ULONG refcount
= InterlockedDecrement(&swapchain
->refcount
);
1981 TRACE("%p decreasing refcount to %lu.\n", swapchain
, refcount
);
1985 d3d12_swapchain_destroy(swapchain
);
1992 /* IDXGIObject methods */
1994 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_SetPrivateData(IDXGISwapChain4
*iface
,
1995 REFGUID guid
, UINT data_size
, const void *data
)
1997 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
1999 TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface
, debugstr_guid(guid
), data_size
, data
);
2001 return dxgi_set_private_data(&swapchain
->private_store
, guid
, data_size
, data
);
2004 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_SetPrivateDataInterface(IDXGISwapChain4
*iface
,
2005 REFGUID guid
, const IUnknown
*object
)
2007 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
2009 TRACE("iface %p, guid %s, object %p.\n", iface
, debugstr_guid(guid
), object
);
2011 return dxgi_set_private_data_interface(&swapchain
->private_store
, guid
, object
);
2014 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetPrivateData(IDXGISwapChain4
*iface
,
2015 REFGUID guid
, UINT
*data_size
, void *data
)
2017 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
2019 TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface
, debugstr_guid(guid
), data_size
, data
);
2021 return dxgi_get_private_data(&swapchain
->private_store
, guid
, data_size
, data
);
2024 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetParent(IDXGISwapChain4
*iface
, REFIID iid
, void **parent
)
2026 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
2028 TRACE("iface %p, iid %s, parent %p.\n", iface
, debugstr_guid(iid
), parent
);
2030 return IWineDXGIFactory_QueryInterface(swapchain
->factory
, iid
, parent
);
2033 /* IDXGIDeviceSubObject methods */
2035 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetDevice(IDXGISwapChain4
*iface
, REFIID iid
, void **device
)
2037 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
2039 TRACE("iface %p, iid %s, device %p.\n", iface
, debugstr_guid(iid
), device
);
2041 return ID3D12Device_QueryInterface(swapchain
->device
, iid
, device
);
2044 /* IDXGISwapChain methods */
2046 static HRESULT
d3d12_swapchain_set_sync_interval(struct d3d12_swapchain
*swapchain
,
2047 unsigned int sync_interval
)
2049 VkPresentModeKHR present_mode
;
2051 switch (sync_interval
)
2054 present_mode
= VK_PRESENT_MODE_IMMEDIATE_KHR
;
2057 FIXME("Unsupported sync interval %u.\n", sync_interval
);
2059 present_mode
= VK_PRESENT_MODE_FIFO_KHR
;
2063 if (swapchain
->present_mode
== present_mode
)
2066 if (!d3d12_swapchain_is_present_mode_supported(swapchain
, present_mode
))
2068 FIXME("Vulkan present mode %#x is not supported.\n", present_mode
);
2072 d3d12_swapchain_destroy_vulkan_resources(swapchain
);
2073 swapchain
->present_mode
= present_mode
;
2074 return d3d12_swapchain_create_vulkan_resources(swapchain
);
2077 static VkResult
d3d12_swapchain_queue_present(struct d3d12_swapchain
*swapchain
, VkImage vk_src_image
,
2078 uint64_t frame_number
)
2080 const struct dxgi_vk_funcs
*vk_funcs
= &swapchain
->vk_funcs
;
2081 VkPresentInfoKHR present_info
;
2082 VkCommandBuffer vk_cmd_buffer
;
2083 VkSubmitInfo submit_info
;
2084 VkImage vk_dst_image
;
2089 if (swapchain
->vk_image_index
== INVALID_VK_IMAGE_INDEX
)
2091 if ((vr
= d3d12_swapchain_acquire_next_vulkan_image(swapchain
)) < 0)
2095 assert(swapchain
->vk_image_index
< swapchain
->buffer_count
);
2097 vk_cmd_buffer
= swapchain
->vk_cmd_buffers
[swapchain
->vk_image_index
];
2098 vk_dst_image
= swapchain
->vk_swapchain_images
[swapchain
->vk_image_index
];
2100 if ((vr
= vk_funcs
->p_vkResetCommandBuffer(vk_cmd_buffer
, 0)) < 0)
2102 ERR("Failed to reset command buffer, vr %d.\n", vr
);
2106 if ((vr
= d3d12_swapchain_record_swapchain_blit(swapchain
,
2107 vk_cmd_buffer
, vk_dst_image
, vk_src_image
)) < 0 )
2110 if (FAILED(hr
= ID3D12Fence_SetEventOnCompletion(swapchain
->present_fence
, frame_number
+ 1, NULL
)))
2112 ERR("Failed to wait for present event, hr %#lx.\n", hr
);
2113 return VK_ERROR_UNKNOWN
;
2116 vk_queue
= vkd3d_acquire_vk_queue(swapchain
->command_queue
);
2118 submit_info
.sType
= VK_STRUCTURE_TYPE_SUBMIT_INFO
;
2119 submit_info
.pNext
= NULL
;
2120 submit_info
.waitSemaphoreCount
= 0;
2121 submit_info
.pWaitSemaphores
= NULL
;
2122 submit_info
.pWaitDstStageMask
= NULL
;
2123 submit_info
.commandBufferCount
= 1;
2124 submit_info
.pCommandBuffers
= &vk_cmd_buffer
;
2125 submit_info
.signalSemaphoreCount
= 1;
2126 submit_info
.pSignalSemaphores
= &swapchain
->vk_semaphores
[swapchain
->vk_image_index
];
2128 if ((vr
= vk_funcs
->p_vkQueueSubmit(vk_queue
, 1, &submit_info
, VK_NULL_HANDLE
)) < 0)
2130 ERR("Failed to blit swapchain buffer, vr %d.\n", vr
);
2131 vkd3d_release_vk_queue(swapchain
->command_queue
);
2135 present_info
.sType
= VK_STRUCTURE_TYPE_PRESENT_INFO_KHR
;
2136 present_info
.pNext
= NULL
;
2137 present_info
.waitSemaphoreCount
= 0;
2138 present_info
.pWaitSemaphores
= NULL
;
2139 present_info
.swapchainCount
= 1;
2140 present_info
.pSwapchains
= &swapchain
->vk_swapchain
;
2141 present_info
.pImageIndices
= &swapchain
->vk_image_index
;
2142 present_info
.pResults
= NULL
;
2143 present_info
.waitSemaphoreCount
= 1;
2144 present_info
.pWaitSemaphores
= &swapchain
->vk_semaphores
[swapchain
->vk_image_index
];
2146 if ((vr
= vk_funcs
->p_vkQueuePresentKHR(vk_queue
, &present_info
)) >= 0)
2147 swapchain
->vk_image_index
= INVALID_VK_IMAGE_INDEX
;
2149 vkd3d_release_vk_queue(swapchain
->command_queue
);
2154 static HRESULT
d3d12_swapchain_op_present_execute(struct d3d12_swapchain
*swapchain
, struct d3d12_swapchain_op
*op
)
2159 if (FAILED(hr
= d3d12_swapchain_set_sync_interval(swapchain
, op
->present
.sync_interval
)))
2162 vr
= d3d12_swapchain_queue_present(swapchain
, op
->present
.vk_image
, op
->present
.frame_number
);
2163 if (vr
== VK_ERROR_OUT_OF_DATE_KHR
)
2165 TRACE("Recreating Vulkan swapchain.\n");
2167 d3d12_swapchain_destroy_vulkan_resources(swapchain
);
2168 if (FAILED(hr
= d3d12_swapchain_create_vulkan_resources(swapchain
)))
2171 if ((vr
= d3d12_swapchain_queue_present(swapchain
, op
->present
.vk_image
, op
->present
.frame_number
)) < 0)
2172 ERR("Failed to present after recreating swapchain, vr %d.\n", vr
);
2177 ERR("Failed to queue present, vr %d.\n", vr
);
2178 return hresult_from_vk_result(vr
);
2181 if (swapchain
->frame_latency_fence
)
2183 /* Use the same bias as d3d12_swapchain_present(). Add one to
2184 * account for the "++swapchain->frame_number" there. */
2185 uint64_t number
= op
->present
.frame_number
+ DXGI_MAX_SWAP_CHAIN_BUFFERS
+ 1;
2187 if (FAILED(hr
= ID3D12CommandQueue_Signal(swapchain
->command_queue
,
2188 swapchain
->frame_latency_fence
, number
)))
2190 ERR("Failed to signal frame latency fence, hr %#lx.\n", hr
);
2198 static HRESULT
d3d12_swapchain_present(struct d3d12_swapchain
*swapchain
,
2199 unsigned int sync_interval
, unsigned int flags
)
2201 struct d3d12_swapchain_op
*op
;
2202 HANDLE frame_latency_event
;
2205 if (sync_interval
> 4)
2207 WARN("Invalid sync interval %u.\n", sync_interval
);
2208 return DXGI_ERROR_INVALID_CALL
;
2211 if (flags
& ~DXGI_PRESENT_TEST
)
2212 FIXME("Unimplemented flags %#x.\n", flags
);
2213 if (flags
& DXGI_PRESENT_TEST
)
2215 WARN("Returning S_OK for DXGI_PRESENT_TEST.\n");
2219 if (!(op
= calloc(1, sizeof(*op
))))
2221 WARN("Cannot allocate memory.\n");
2222 return E_OUTOFMEMORY
;
2225 op
->type
= D3D12_SWAPCHAIN_OP_PRESENT
;
2226 op
->present
.sync_interval
= sync_interval
;
2227 op
->present
.vk_image
= swapchain
->vk_images
[swapchain
->current_buffer_index
];
2228 op
->present
.frame_number
= swapchain
->frame_number
;
2230 EnterCriticalSection(&swapchain
->worker_cs
);
2231 list_add_tail(&swapchain
->worker_ops
, &op
->entry
);
2232 WakeAllConditionVariable(&swapchain
->worker_cv
);
2233 LeaveCriticalSection(&swapchain
->worker_cs
);
2235 ++swapchain
->frame_number
;
2236 if ((frame_latency_event
= swapchain
->frame_latency_event
))
2238 /* Bias the frame number to avoid underflowing in
2239 * SetEventOnCompletion(). */
2240 uint64_t number
= swapchain
->frame_number
+ DXGI_MAX_SWAP_CHAIN_BUFFERS
;
2242 if (FAILED(hr
= ID3D12Fence_SetEventOnCompletion(swapchain
->frame_latency_fence
,
2243 number
- swapchain
->frame_latency
, frame_latency_event
)))
2245 ERR("Failed to enqueue frame latency event, hr %#lx.\n", hr
);
2250 if (FAILED(hr
= ID3D12CommandQueue_Signal(swapchain
->command_queue
,
2251 swapchain
->present_fence
, swapchain
->frame_number
)))
2253 ERR("Failed to signal present fence, hf %#lx.\n", hr
);
2257 swapchain
->current_buffer_index
= (swapchain
->current_buffer_index
+ 1) % swapchain
->desc
.BufferCount
;
2261 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_Present(IDXGISwapChain4
*iface
, UINT sync_interval
, UINT flags
)
2263 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
2265 TRACE("iface %p, sync_interval %u, flags %#x.\n", iface
, sync_interval
, flags
);
2267 return d3d12_swapchain_present(swapchain
, sync_interval
, flags
);
2270 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetBuffer(IDXGISwapChain4
*iface
,
2271 UINT buffer_idx
, REFIID iid
, void **surface
)
2273 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
2275 TRACE("iface %p, buffer_idx %u, iid %s, surface %p.\n",
2276 iface
, buffer_idx
, debugstr_guid(iid
), surface
);
2278 if (buffer_idx
>= swapchain
->desc
.BufferCount
)
2280 WARN("Invalid buffer index %u.\n", buffer_idx
);
2281 return DXGI_ERROR_INVALID_CALL
;
2284 assert(swapchain
->buffers
[buffer_idx
]);
2285 return ID3D12Resource_QueryInterface(swapchain
->buffers
[buffer_idx
], iid
, surface
);
2288 static HRESULT STDMETHODCALLTYPE DECLSPEC_HOTPATCH
d3d12_swapchain_SetFullscreenState(IDXGISwapChain4
*iface
,
2289 BOOL fullscreen
, IDXGIOutput
*target
)
2291 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
2292 DXGI_SWAP_CHAIN_FULLSCREEN_DESC
*fullscreen_desc
= &swapchain
->fullscreen_desc
;
2293 const DXGI_SWAP_CHAIN_DESC1
*swapchain_desc
= &swapchain
->desc
;
2294 struct wined3d_swapchain_desc wined3d_desc
;
2295 HWND window
= swapchain
->window
;
2296 LONG in_set_fullscreen_state
;
2300 TRACE("iface %p, fullscreen %#x, target %p.\n", iface
, fullscreen
, target
);
2302 if (!fullscreen
&& target
)
2304 WARN("Invalid call.\n");
2305 return DXGI_ERROR_INVALID_CALL
;
2310 IDXGIOutput_AddRef(target
);
2312 else if (FAILED(hr
= IDXGISwapChain4_GetContainingOutput(iface
, &target
)))
2314 WARN("Failed to get target output for swapchain, hr %#lx.\n", hr
);
2318 if (FAILED(hr
= wined3d_swapchain_desc_from_dxgi(&wined3d_desc
, target
, window
, swapchain_desc
,
2321 IDXGIOutput_Release(target
);
2325 in_set_fullscreen_state
= InterlockedExchange(&swapchain
->in_set_fullscreen_state
, 1);
2326 if (in_set_fullscreen_state
)
2328 WARN("Nested invocation of SetFullscreenState.\n");
2329 IDXGIOutput_Release(target
);
2330 IDXGISwapChain4_GetFullscreenState(iface
, &old_fs
, NULL
);
2331 return old_fs
== fullscreen
? S_OK
: DXGI_STATUS_MODE_CHANGE_IN_PROGRESS
;
2334 wined3d_mutex_lock();
2335 wined3d_desc
.windowed
= !fullscreen
;
2336 hr
= wined3d_swapchain_state_set_fullscreen(swapchain
->state
, &wined3d_desc
, NULL
);
2339 IDXGIOutput_Release(target
);
2340 hr
= DXGI_ERROR_NOT_CURRENTLY_AVAILABLE
;
2344 fullscreen_desc
->Windowed
= wined3d_desc
.windowed
;
2347 IDXGIOutput_Release(target
);
2351 if (swapchain
->target
)
2352 IDXGIOutput_Release(swapchain
->target
);
2353 swapchain
->target
= target
;
2356 wined3d_mutex_unlock();
2357 InterlockedExchange(&swapchain
->in_set_fullscreen_state
, 0);
2361 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetFullscreenState(IDXGISwapChain4
*iface
,
2362 BOOL
*fullscreen
, IDXGIOutput
**target
)
2364 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
2368 TRACE("iface %p, fullscreen %p, target %p.\n", iface
, fullscreen
, target
);
2370 if (fullscreen
|| target
)
2372 wined3d_mutex_lock();
2373 windowed
= wined3d_swapchain_state_is_windowed(swapchain
->state
);
2374 wined3d_mutex_unlock();
2378 *fullscreen
= !windowed
;
2384 if (!swapchain
->target
&& FAILED(hr
= IDXGISwapChain4_GetContainingOutput(iface
,
2385 &swapchain
->target
)))
2388 *target
= swapchain
->target
;
2389 IDXGIOutput_AddRef(*target
);
2400 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetDesc(IDXGISwapChain4
*iface
, DXGI_SWAP_CHAIN_DESC
*desc
)
2402 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
2403 const DXGI_SWAP_CHAIN_FULLSCREEN_DESC
*fullscreen_desc
= &swapchain
->fullscreen_desc
;
2404 const DXGI_SWAP_CHAIN_DESC1
*swapchain_desc
= &swapchain
->desc
;
2407 TRACE("iface %p, desc %p.\n", iface
, desc
);
2411 WARN("Invalid pointer.\n");
2412 return E_INVALIDARG
;
2415 wined3d_mutex_lock();
2416 windowed
= wined3d_swapchain_state_is_windowed(swapchain
->state
);
2417 wined3d_mutex_unlock();
2419 desc
->BufferDesc
.Width
= swapchain_desc
->Width
;
2420 desc
->BufferDesc
.Height
= swapchain_desc
->Height
;
2421 desc
->BufferDesc
.RefreshRate
= fullscreen_desc
->RefreshRate
;
2422 desc
->BufferDesc
.Format
= swapchain_desc
->Format
;
2423 desc
->BufferDesc
.ScanlineOrdering
= fullscreen_desc
->ScanlineOrdering
;
2424 desc
->BufferDesc
.Scaling
= fullscreen_desc
->Scaling
;
2425 desc
->SampleDesc
= swapchain_desc
->SampleDesc
;
2426 desc
->BufferUsage
= swapchain_desc
->BufferUsage
;
2427 desc
->BufferCount
= swapchain_desc
->BufferCount
;
2428 desc
->OutputWindow
= swapchain
->window
;
2429 desc
->Windowed
= windowed
;
2430 desc
->SwapEffect
= swapchain_desc
->SwapEffect
;
2431 desc
->Flags
= swapchain_desc
->Flags
;
2436 static HRESULT
d3d12_swapchain_op_resize_buffers_execute(struct d3d12_swapchain
*swapchain
, struct d3d12_swapchain_op
*op
)
2438 d3d12_swapchain_destroy_vulkan_resources(swapchain
);
2440 swapchain
->backend_desc
= op
->resize_buffers
.desc
;
2442 return d3d12_swapchain_create_vulkan_resources(swapchain
);
2445 static HRESULT
d3d12_swapchain_resize_buffers(struct d3d12_swapchain
*swapchain
,
2446 UINT buffer_count
, UINT width
, UINT height
, DXGI_FORMAT format
, UINT flags
)
2448 DXGI_SWAP_CHAIN_DESC1
*desc
, new_desc
;
2449 struct d3d12_swapchain_op
*op
;
2454 FIXME("Ignoring flags %#x.\n", flags
);
2456 for (i
= 0; i
< swapchain
->desc
.BufferCount
; ++i
)
2458 ID3D12Resource_AddRef(swapchain
->buffers
[i
]);
2459 if ((refcount
= ID3D12Resource_Release(swapchain
->buffers
[i
])))
2461 WARN("Buffer %p has %lu references left.\n", swapchain
->buffers
[i
], refcount
);
2462 return DXGI_ERROR_INVALID_CALL
;
2466 desc
= &swapchain
->desc
;
2467 new_desc
= swapchain
->desc
;
2470 new_desc
.BufferCount
= buffer_count
;
2471 if (!width
|| !height
)
2475 if (!GetClientRect(swapchain
->window
, &client_rect
))
2477 WARN("Failed to get client rect, last error %#lx.\n", GetLastError());
2478 return DXGI_ERROR_INVALID_CALL
;
2482 width
= client_rect
.right
;
2484 height
= client_rect
.bottom
;
2486 new_desc
.Width
= width
;
2487 new_desc
.Height
= height
;
2490 new_desc
.Format
= format
;
2492 if (!dxgi_validate_swapchain_desc(&new_desc
))
2493 return DXGI_ERROR_INVALID_CALL
;
2495 if (desc
->Width
== new_desc
.Width
&& desc
->Height
== new_desc
.Height
2496 && desc
->Format
== new_desc
.Format
&& desc
->BufferCount
== new_desc
.BufferCount
)
2498 swapchain
->current_buffer_index
= 0;
2502 if (!(op
= calloc(1, sizeof(*op
))))
2504 WARN("Cannot allocate memory.\n");
2505 return E_OUTOFMEMORY
;
2508 op
->type
= D3D12_SWAPCHAIN_OP_RESIZE_BUFFERS
;
2509 op
->resize_buffers
.vk_memory
= swapchain
->vk_memory
;
2510 swapchain
->vk_memory
= VK_NULL_HANDLE
;
2511 memcpy(&op
->resize_buffers
.vk_images
, &swapchain
->vk_images
, sizeof(swapchain
->vk_images
));
2512 memset(&swapchain
->vk_images
, 0, sizeof(swapchain
->vk_images
));
2513 op
->resize_buffers
.desc
= new_desc
;
2515 EnterCriticalSection(&swapchain
->worker_cs
);
2516 list_add_tail(&swapchain
->worker_ops
, &op
->entry
);
2517 WakeAllConditionVariable(&swapchain
->worker_cv
);
2518 LeaveCriticalSection(&swapchain
->worker_cs
);
2520 swapchain
->current_buffer_index
= 0;
2522 d3d12_swapchain_destroy_d3d12_resources(swapchain
);
2524 swapchain
->desc
= new_desc
;
2526 return d3d12_swapchain_create_d3d12_resources(swapchain
);
2529 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_ResizeBuffers(IDXGISwapChain4
*iface
,
2530 UINT buffer_count
, UINT width
, UINT height
, DXGI_FORMAT format
, UINT flags
)
2532 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
2534 TRACE("iface %p, buffer_count %u, width %u, height %u, format %s, flags %#x.\n",
2535 iface
, buffer_count
, width
, height
, debug_dxgi_format(format
), flags
);
2537 return d3d12_swapchain_resize_buffers(swapchain
, buffer_count
, width
, height
, format
, flags
);
2540 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_ResizeTarget(IDXGISwapChain4
*iface
,
2541 const DXGI_MODE_DESC
*target_mode_desc
)
2543 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
2545 TRACE("iface %p, target_mode_desc %p.\n", iface
, target_mode_desc
);
2547 return dxgi_swapchain_resize_target(swapchain
->state
, target_mode_desc
);
2550 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetContainingOutput(IDXGISwapChain4
*iface
,
2551 IDXGIOutput
**output
)
2553 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
2554 IUnknown
*device_parent
;
2555 IWineDXGIFactory
*factory
;
2556 IDXGIAdapter
*adapter
;
2559 TRACE("iface %p, output %p.\n", iface
, output
);
2561 if (swapchain
->target
)
2563 IDXGIOutput_AddRef(*output
= swapchain
->target
);
2567 device_parent
= vkd3d_get_device_parent(swapchain
->device
);
2569 if (FAILED(hr
= IUnknown_QueryInterface(device_parent
, &IID_IDXGIAdapter
, (void **)&adapter
)))
2571 WARN("Failed to get adapter, hr %#lx.\n", hr
);
2575 if (FAILED(hr
= IDXGIAdapter_GetParent(adapter
, &IID_IWineDXGIFactory
, (void **)&factory
)))
2577 WARN("Failed to get factory, hr %#lx.\n", hr
);
2578 IDXGIAdapter_Release(adapter
);
2582 hr
= dxgi_get_output_from_window(factory
, swapchain
->window
, output
);
2583 IWineDXGIFactory_Release(factory
);
2584 IDXGIAdapter_Release(adapter
);
2588 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetFrameStatistics(IDXGISwapChain4
*iface
,
2589 DXGI_FRAME_STATISTICS
*stats
)
2591 FIXME("iface %p, stats %p stub!\n", iface
, stats
);
2596 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetLastPresentCount(IDXGISwapChain4
*iface
,
2597 UINT
*last_present_count
)
2599 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
2601 TRACE("iface %p, last_present_count %p.\n", iface
, last_present_count
);
2603 *last_present_count
= swapchain
->frame_number
;
2608 /* IDXGISwapChain1 methods */
2610 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetDesc1(IDXGISwapChain4
*iface
, DXGI_SWAP_CHAIN_DESC1
*desc
)
2612 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
2614 TRACE("iface %p, desc %p.\n", iface
, desc
);
2618 WARN("Invalid pointer.\n");
2619 return E_INVALIDARG
;
2622 *desc
= swapchain
->desc
;
2626 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetFullscreenDesc(IDXGISwapChain4
*iface
,
2627 DXGI_SWAP_CHAIN_FULLSCREEN_DESC
*desc
)
2629 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
2632 TRACE("iface %p, desc %p.\n", iface
, desc
);
2636 WARN("Invalid pointer.\n");
2637 return E_INVALIDARG
;
2640 wined3d_mutex_lock();
2641 windowed
= wined3d_swapchain_state_is_windowed(swapchain
->state
);
2642 wined3d_mutex_unlock();
2644 *desc
= swapchain
->fullscreen_desc
;
2645 desc
->Windowed
= windowed
;
2649 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetHwnd(IDXGISwapChain4
*iface
, HWND
*hwnd
)
2651 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
2653 TRACE("iface %p, hwnd %p.\n", iface
, hwnd
);
2657 WARN("Invalid pointer.\n");
2658 return DXGI_ERROR_INVALID_CALL
;
2661 *hwnd
= swapchain
->window
;
2665 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetCoreWindow(IDXGISwapChain4
*iface
,
2666 REFIID iid
, void **core_window
)
2668 FIXME("iface %p, iid %s, core_window %p stub!\n", iface
, debugstr_guid(iid
), core_window
);
2671 *core_window
= NULL
;
2673 return DXGI_ERROR_INVALID_CALL
;
2676 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_Present1(IDXGISwapChain4
*iface
,
2677 UINT sync_interval
, UINT flags
, const DXGI_PRESENT_PARAMETERS
*present_parameters
)
2679 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
2681 TRACE("iface %p, sync_interval %u, flags %#x, present_parameters %p.\n",
2682 iface
, sync_interval
, flags
, present_parameters
);
2684 if (present_parameters
)
2685 FIXME("Ignored present parameters %p.\n", present_parameters
);
2687 return d3d12_swapchain_present(swapchain
, sync_interval
, flags
);
2690 static BOOL STDMETHODCALLTYPE
d3d12_swapchain_IsTemporaryMonoSupported(IDXGISwapChain4
*iface
)
2692 FIXME("iface %p stub!\n", iface
);
2697 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetRestrictToOutput(IDXGISwapChain4
*iface
, IDXGIOutput
**output
)
2699 FIXME("iface %p, output %p stub!\n", iface
, output
);
2703 WARN("Invalid pointer.\n");
2704 return E_INVALIDARG
;
2711 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_SetBackgroundColor(IDXGISwapChain4
*iface
, const DXGI_RGBA
*color
)
2713 FIXME("iface %p, color %p stub!\n", iface
, color
);
2718 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetBackgroundColor(IDXGISwapChain4
*iface
, DXGI_RGBA
*color
)
2720 FIXME("iface %p, color %p stub!\n", iface
, color
);
2725 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_SetRotation(IDXGISwapChain4
*iface
, DXGI_MODE_ROTATION rotation
)
2727 FIXME("iface %p, rotation %#x stub!\n", iface
, rotation
);
2732 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetRotation(IDXGISwapChain4
*iface
, DXGI_MODE_ROTATION
*rotation
)
2734 FIXME("iface %p, rotation %p stub!\n", iface
, rotation
);
2739 /* IDXGISwapChain2 methods */
2741 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_SetSourceSize(IDXGISwapChain4
*iface
, UINT width
, UINT height
)
2743 FIXME("iface %p, width %u, height %u stub!\n", iface
, width
, height
);
2748 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetSourceSize(IDXGISwapChain4
*iface
, UINT
*width
, UINT
*height
)
2750 FIXME("iface %p, width %p, height %p stub!\n", iface
, width
, height
);
2755 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_SetMaximumFrameLatency(IDXGISwapChain4
*iface
, UINT max_latency
)
2757 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
2759 TRACE("iface %p, max_latency %u.\n", iface
, max_latency
);
2761 if (!(swapchain
->desc
.Flags
& DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT
))
2763 WARN("DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT not set for swap chain %p.\n", iface
);
2764 return DXGI_ERROR_INVALID_CALL
;
2769 WARN("Invalid maximum frame latency %u.\n", max_latency
);
2770 return DXGI_ERROR_INVALID_CALL
;
2773 swapchain
->frame_latency
= max_latency
;
2777 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetMaximumFrameLatency(IDXGISwapChain4
*iface
, UINT
*max_latency
)
2779 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
2781 TRACE("iface %p, max_latency %p.\n", iface
, max_latency
);
2783 if (!(swapchain
->desc
.Flags
& DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT
))
2785 WARN("DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT not set for swap chain %p.\n", iface
);
2786 return DXGI_ERROR_INVALID_CALL
;
2789 *max_latency
= swapchain
->frame_latency
;
2793 static HANDLE STDMETHODCALLTYPE
d3d12_swapchain_GetFrameLatencyWaitableObject(IDXGISwapChain4
*iface
)
2795 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
2799 TRACE("iface %p.\n", iface
);
2801 if (!swapchain
->frame_latency_event
)
2804 ret
= DuplicateHandle(GetCurrentProcess(), swapchain
->frame_latency_event
, GetCurrentProcess(),
2805 &dup
, 0, FALSE
, DUPLICATE_SAME_ACCESS
);
2809 ERR("Cannot duplicate handle, last error %lu.\n", GetLastError());
2816 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_SetMatrixTransform(IDXGISwapChain4
*iface
,
2817 const DXGI_MATRIX_3X2_F
*matrix
)
2819 FIXME("iface %p, matrix %p stub!\n", iface
, matrix
);
2824 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetMatrixTransform(IDXGISwapChain4
*iface
,
2825 DXGI_MATRIX_3X2_F
*matrix
)
2827 FIXME("iface %p, matrix %p stub!\n", iface
, matrix
);
2832 /* IDXGISwapChain3 methods */
2834 static UINT STDMETHODCALLTYPE
d3d12_swapchain_GetCurrentBackBufferIndex(IDXGISwapChain4
*iface
)
2836 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
2838 TRACE("iface %p.\n", iface
);
2840 TRACE("Current back buffer index %u.\n", swapchain
->current_buffer_index
);
2841 assert(swapchain
->current_buffer_index
< swapchain
->desc
.BufferCount
);
2842 return swapchain
->current_buffer_index
;
2845 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_CheckColorSpaceSupport(IDXGISwapChain4
*iface
,
2846 DXGI_COLOR_SPACE_TYPE colour_space
, UINT
*colour_space_support
)
2848 UINT support_flags
= 0;
2850 FIXME("iface %p, colour_space %#x, colour_space_support %p semi-stub!\n",
2851 iface
, colour_space
, colour_space_support
);
2853 if (!colour_space_support
)
2854 return E_INVALIDARG
;
2856 if (colour_space
== DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709
)
2857 support_flags
|= DXGI_SWAP_CHAIN_COLOR_SPACE_SUPPORT_FLAG_PRESENT
;
2859 *colour_space_support
= support_flags
;
2863 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_SetColorSpace1(IDXGISwapChain4
*iface
,
2864 DXGI_COLOR_SPACE_TYPE colour_space
)
2866 FIXME("iface %p, colour_space %#x semi-stub!\n", iface
, colour_space
);
2868 if (colour_space
!= DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709
)
2870 WARN("Colour space %u not supported.\n", colour_space
);
2871 return E_INVALIDARG
;
2877 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_ResizeBuffers1(IDXGISwapChain4
*iface
,
2878 UINT buffer_count
, UINT width
, UINT height
, DXGI_FORMAT format
, UINT flags
,
2879 const UINT
*node_mask
, IUnknown
* const *present_queue
)
2881 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain4(iface
);
2884 TRACE("iface %p, buffer_count %u, width %u, height %u, format %s, flags %#x, "
2885 "node_mask %p, present_queue %p.\n",
2886 iface
, buffer_count
, width
, height
, debug_dxgi_format(format
), flags
, node_mask
, present_queue
);
2888 if (!node_mask
|| !present_queue
)
2889 return DXGI_ERROR_INVALID_CALL
;
2891 count
= buffer_count
? buffer_count
: swapchain
->desc
.BufferCount
;
2892 for (i
= 0; i
< count
; ++i
)
2894 if (node_mask
[i
] > 1 || !present_queue
[i
])
2895 return DXGI_ERROR_INVALID_CALL
;
2896 if ((ID3D12CommandQueue
*)present_queue
[i
] != swapchain
->command_queue
)
2897 FIXME("Ignoring present queue %p.\n", present_queue
[i
]);
2900 return d3d12_swapchain_resize_buffers(swapchain
, buffer_count
, width
, height
, format
, flags
);
2903 /* IDXGISwapChain4 methods */
2905 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_SetHDRMetaData(IDXGISwapChain4
*iface
,
2906 DXGI_HDR_METADATA_TYPE type
, UINT size
, void *metadata
)
2908 FIXME("iface %p, type %#x, size %#x, metadata %p stub!\n", iface
, type
, size
, metadata
);
2913 static const struct IDXGISwapChain4Vtbl d3d12_swapchain_vtbl
=
2915 /* IUnknown methods */
2916 d3d12_swapchain_QueryInterface
,
2917 d3d12_swapchain_AddRef
,
2918 d3d12_swapchain_Release
,
2919 /* IDXGIObject methods */
2920 d3d12_swapchain_SetPrivateData
,
2921 d3d12_swapchain_SetPrivateDataInterface
,
2922 d3d12_swapchain_GetPrivateData
,
2923 d3d12_swapchain_GetParent
,
2924 /* IDXGIDeviceSubObject methods */
2925 d3d12_swapchain_GetDevice
,
2926 /* IDXGISwapChain methods */
2927 d3d12_swapchain_Present
,
2928 d3d12_swapchain_GetBuffer
,
2929 d3d12_swapchain_SetFullscreenState
,
2930 d3d12_swapchain_GetFullscreenState
,
2931 d3d12_swapchain_GetDesc
,
2932 d3d12_swapchain_ResizeBuffers
,
2933 d3d12_swapchain_ResizeTarget
,
2934 d3d12_swapchain_GetContainingOutput
,
2935 d3d12_swapchain_GetFrameStatistics
,
2936 d3d12_swapchain_GetLastPresentCount
,
2937 /* IDXGISwapChain1 methods */
2938 d3d12_swapchain_GetDesc1
,
2939 d3d12_swapchain_GetFullscreenDesc
,
2940 d3d12_swapchain_GetHwnd
,
2941 d3d12_swapchain_GetCoreWindow
,
2942 d3d12_swapchain_Present1
,
2943 d3d12_swapchain_IsTemporaryMonoSupported
,
2944 d3d12_swapchain_GetRestrictToOutput
,
2945 d3d12_swapchain_SetBackgroundColor
,
2946 d3d12_swapchain_GetBackgroundColor
,
2947 d3d12_swapchain_SetRotation
,
2948 d3d12_swapchain_GetRotation
,
2949 /* IDXGISwapChain2 methods */
2950 d3d12_swapchain_SetSourceSize
,
2951 d3d12_swapchain_GetSourceSize
,
2952 d3d12_swapchain_SetMaximumFrameLatency
,
2953 d3d12_swapchain_GetMaximumFrameLatency
,
2954 d3d12_swapchain_GetFrameLatencyWaitableObject
,
2955 d3d12_swapchain_SetMatrixTransform
,
2956 d3d12_swapchain_GetMatrixTransform
,
2957 /* IDXGISwapChain3 methods */
2958 d3d12_swapchain_GetCurrentBackBufferIndex
,
2959 d3d12_swapchain_CheckColorSpaceSupport
,
2960 d3d12_swapchain_SetColorSpace1
,
2961 d3d12_swapchain_ResizeBuffers1
,
2962 /* IDXGISwapChain4 methods */
2963 d3d12_swapchain_SetHDRMetaData
,
2966 static BOOL
init_vk_funcs(struct dxgi_vk_funcs
*dxgi
, VkInstance vk_instance
, VkDevice vk_device
)
2968 PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr
;
2969 PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr
;
2971 dxgi
->vulkan_module
= LoadLibraryA("vulkan-1.dll");
2972 if (!(vkGetInstanceProcAddr
= (void *)GetProcAddress(dxgi
->vulkan_module
, "vkGetInstanceProcAddr")))
2974 ERR_(winediag
)("Failed to load Vulkan.\n");
2978 vkGetDeviceProcAddr
= (void *)vkGetInstanceProcAddr(vk_instance
, "vkGetDeviceProcAddr");
2980 #define LOAD_INSTANCE_PFN(name) \
2981 if (!(dxgi->p_##name = (void *)vkGetInstanceProcAddr(vk_instance, #name))) \
2983 ERR("Failed to get instance proc "#name".\n"); \
2984 FreeLibrary(dxgi->vulkan_module); \
2987 LOAD_INSTANCE_PFN(vkCreateWin32SurfaceKHR
)
2988 LOAD_INSTANCE_PFN(vkDestroySurfaceKHR
)
2989 LOAD_INSTANCE_PFN(vkGetPhysicalDeviceMemoryProperties
)
2990 LOAD_INSTANCE_PFN(vkGetPhysicalDeviceSurfaceCapabilitiesKHR
)
2991 LOAD_INSTANCE_PFN(vkGetPhysicalDeviceSurfaceFormatsKHR
)
2992 LOAD_INSTANCE_PFN(vkGetPhysicalDeviceSurfacePresentModesKHR
)
2993 LOAD_INSTANCE_PFN(vkGetPhysicalDeviceSurfaceSupportKHR
)
2994 LOAD_INSTANCE_PFN(vkGetPhysicalDeviceWin32PresentationSupportKHR
)
2995 #undef LOAD_INSTANCE_PFN
2997 #define LOAD_DEVICE_PFN(name) \
2998 if (!(dxgi->p_##name = (void *)vkGetDeviceProcAddr(vk_device, #name))) \
3000 ERR("Failed to get device proc "#name".\n"); \
3001 FreeLibrary(dxgi->vulkan_module); \
3004 LOAD_DEVICE_PFN(vkAcquireNextImageKHR
)
3005 LOAD_DEVICE_PFN(vkAllocateCommandBuffers
)
3006 LOAD_DEVICE_PFN(vkAllocateMemory
)
3007 LOAD_DEVICE_PFN(vkBeginCommandBuffer
)
3008 LOAD_DEVICE_PFN(vkBindImageMemory
)
3009 LOAD_DEVICE_PFN(vkCmdBlitImage
)
3010 LOAD_DEVICE_PFN(vkCmdPipelineBarrier
)
3011 LOAD_DEVICE_PFN(vkCreateCommandPool
)
3012 LOAD_DEVICE_PFN(vkCreateFence
)
3013 LOAD_DEVICE_PFN(vkCreateImage
)
3014 LOAD_DEVICE_PFN(vkCreateSemaphore
)
3015 LOAD_DEVICE_PFN(vkCreateSwapchainKHR
)
3016 LOAD_DEVICE_PFN(vkDestroyCommandPool
)
3017 LOAD_DEVICE_PFN(vkDestroyFence
)
3018 LOAD_DEVICE_PFN(vkDestroyImage
)
3019 LOAD_DEVICE_PFN(vkDestroySemaphore
)
3020 LOAD_DEVICE_PFN(vkDestroySwapchainKHR
)
3021 LOAD_DEVICE_PFN(vkEndCommandBuffer
)
3022 LOAD_DEVICE_PFN(vkFreeMemory
)
3023 LOAD_DEVICE_PFN(vkResetCommandBuffer
)
3024 LOAD_DEVICE_PFN(vkGetImageMemoryRequirements
)
3025 LOAD_DEVICE_PFN(vkGetSwapchainImagesKHR
)
3026 LOAD_DEVICE_PFN(vkQueuePresentKHR
)
3027 LOAD_DEVICE_PFN(vkQueueSubmit
)
3028 LOAD_DEVICE_PFN(vkQueueWaitIdle
)
3029 LOAD_DEVICE_PFN(vkResetFences
)
3030 LOAD_DEVICE_PFN(vkWaitForFences
)
3031 #undef LOAD_DEVICE_PFN
3036 static inline struct d3d12_swapchain
*d3d12_swapchain_from_wined3d_swapchain_state_parent(struct wined3d_swapchain_state_parent
*parent
)
3038 return CONTAINING_RECORD(parent
, struct d3d12_swapchain
, state_parent
);
3041 static void CDECL
d3d12_swapchain_windowed_state_changed(struct wined3d_swapchain_state_parent
*parent
,
3044 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_wined3d_swapchain_state_parent(parent
);
3046 TRACE("parent %p, windowed %d.\n", parent
, windowed
);
3048 if (windowed
&& swapchain
->target
)
3050 IDXGIOutput_Release(swapchain
->target
);
3051 swapchain
->target
= NULL
;
3055 static const struct wined3d_swapchain_state_parent_ops d3d12_swapchain_state_parent_ops
=
3057 d3d12_swapchain_windowed_state_changed
,
3060 static HRESULT
d3d12_swapchain_init(struct d3d12_swapchain
*swapchain
, IWineDXGIFactory
*factory
,
3061 ID3D12Device
*device
, ID3D12CommandQueue
*queue
, HWND window
,
3062 const DXGI_SWAP_CHAIN_DESC1
*swapchain_desc
, const DXGI_SWAP_CHAIN_FULLSCREEN_DESC
*fullscreen_desc
)
3064 const struct dxgi_vk_funcs
*vk_funcs
= &swapchain
->vk_funcs
;
3065 struct wined3d_swapchain_desc wined3d_desc
;
3066 VkWin32SurfaceCreateInfoKHR surface_desc
;
3067 VkPhysicalDevice vk_physical_device
;
3068 struct dxgi_factory
*dxgi_factory
;
3069 VkFenceCreateInfo fence_desc
;
3070 uint32_t queue_family_index
;
3071 VkSurfaceKHR vk_surface
;
3072 VkInstance vk_instance
;
3073 IDXGIOutput
*output
;
3081 if (window
== GetDesktopWindow())
3083 WARN("D3D12 swapchain cannot be created on desktop window.\n");
3084 return E_ACCESSDENIED
;
3087 swapchain
->IDXGISwapChain4_iface
.lpVtbl
= &d3d12_swapchain_vtbl
;
3088 swapchain
->state_parent
.ops
= &d3d12_swapchain_state_parent_ops
;
3089 swapchain
->refcount
= 1;
3091 swapchain
->window
= window
;
3092 swapchain
->desc
= *swapchain_desc
;
3093 swapchain
->backend_desc
= *swapchain_desc
;
3094 swapchain
->fullscreen_desc
= *fullscreen_desc
;
3096 swapchain
->present_mode
= VK_PRESENT_MODE_FIFO_KHR
;
3098 switch (swapchain_desc
->SwapEffect
)
3100 case DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL
:
3101 case DXGI_SWAP_EFFECT_FLIP_DISCARD
:
3102 FIXME("Ignoring swap effect %#x.\n", swapchain_desc
->SwapEffect
);
3105 WARN("Invalid swap effect %#x.\n", swapchain_desc
->SwapEffect
);
3106 return DXGI_ERROR_INVALID_CALL
;
3109 if (FAILED(hr
= dxgi_get_output_from_window(factory
, window
, &output
)))
3111 WARN("Failed to get output from window %p, hr %#lx.\n", window
, hr
);
3115 hr
= wined3d_swapchain_desc_from_dxgi(&wined3d_desc
, output
, window
, swapchain_desc
,
3119 IDXGIOutput_Release(output
);
3123 fullscreen
= !wined3d_desc
.windowed
;
3124 wined3d_desc
.windowed
= TRUE
;
3126 dxgi_factory
= unsafe_impl_from_IDXGIFactory((IDXGIFactory
*)factory
);
3127 if (FAILED(hr
= wined3d_swapchain_state_create(&wined3d_desc
, window
, dxgi_factory
->wined3d
,
3128 &swapchain
->state_parent
, &swapchain
->state
)))
3130 IDXGIOutput_Release(output
);
3134 wined3d_swapchain_state_get_size(swapchain
->state
, &swapchain
->desc
.Width
, &swapchain
->desc
.Height
);
3138 wined3d_desc
.windowed
= FALSE
;
3139 hr
= wined3d_swapchain_state_set_fullscreen(swapchain
->state
, &wined3d_desc
, NULL
);
3142 wined3d_swapchain_state_destroy(swapchain
->state
);
3143 IDXGIOutput_Release(output
);
3147 swapchain
->target
= output
;
3151 IDXGIOutput_Release(output
);
3154 if (swapchain_desc
->BufferUsage
& ~(DXGI_USAGE_RENDER_TARGET_OUTPUT
| DXGI_USAGE_SHADER_INPUT
))
3155 FIXME("Ignoring buffer usage %#x.\n", swapchain_desc
->BufferUsage
& ~(DXGI_USAGE_RENDER_TARGET_OUTPUT
| DXGI_USAGE_SHADER_INPUT
));
3156 if (swapchain_desc
->Scaling
!= DXGI_SCALING_STRETCH
&& swapchain_desc
->Scaling
!= DXGI_SCALING_NONE
)
3157 FIXME("Ignoring scaling %#x.\n", swapchain_desc
->Scaling
);
3158 if (swapchain_desc
->AlphaMode
&& swapchain_desc
->AlphaMode
!= DXGI_ALPHA_MODE_IGNORE
)
3159 FIXME("Ignoring alpha mode %#x.\n", swapchain_desc
->AlphaMode
);
3160 if (swapchain_desc
->Flags
& ~(DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT
))
3161 FIXME("Ignoring swapchain flags %#x.\n", swapchain_desc
->Flags
);
3163 if (fullscreen_desc
->RefreshRate
.Numerator
|| fullscreen_desc
->RefreshRate
.Denominator
)
3164 FIXME("Ignoring refresh rate.\n");
3165 if (fullscreen_desc
->ScanlineOrdering
)
3166 FIXME("Unhandled scanline ordering %#x.\n", fullscreen_desc
->ScanlineOrdering
);
3167 if (fullscreen_desc
->Scaling
)
3168 FIXME("Unhandled mode scaling %#x.\n", fullscreen_desc
->Scaling
);
3170 vk_instance
= vkd3d_instance_get_vk_instance(vkd3d_instance_from_device(device
));
3171 vk_physical_device
= vkd3d_get_vk_physical_device(device
);
3172 vk_device
= vkd3d_get_vk_device(device
);
3174 swapchain
->vk_instance
= vk_instance
;
3175 swapchain
->vk_device
= vk_device
;
3176 swapchain
->vk_physical_device
= vk_physical_device
;
3178 if (!init_vk_funcs(&swapchain
->vk_funcs
, vk_instance
, vk_device
))
3180 wined3d_swapchain_state_destroy(swapchain
->state
);
3184 wined3d_private_store_init(&swapchain
->private_store
);
3186 InitializeCriticalSection(&swapchain
->worker_cs
);
3187 InitializeConditionVariable(&swapchain
->worker_cv
);
3188 swapchain
->worker_running
= true;
3189 list_init(&swapchain
->worker_ops
);
3191 surface_desc
.sType
= VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR
;
3192 surface_desc
.pNext
= NULL
;
3193 surface_desc
.flags
= 0;
3194 surface_desc
.hinstance
= GetModuleHandleA("dxgi.dll");
3195 surface_desc
.hwnd
= window
;
3196 if ((vr
= vk_funcs
->p_vkCreateWin32SurfaceKHR(vk_instance
, &surface_desc
, NULL
, &vk_surface
)) < 0)
3198 WARN("Failed to create Vulkan surface, vr %d.\n", vr
);
3199 d3d12_swapchain_destroy(swapchain
);
3200 return hresult_from_vk_result(vr
);
3202 swapchain
->vk_surface
= vk_surface
;
3204 queue_family_index
= vkd3d_get_vk_queue_family_index(queue
);
3205 if ((vr
= vk_funcs
->p_vkGetPhysicalDeviceSurfaceSupportKHR(vk_physical_device
,
3206 queue_family_index
, vk_surface
, &supported
)) < 0 || !supported
)
3208 FIXME("Queue family does not support presentation, vr %d.\n", vr
);
3209 d3d12_swapchain_destroy(swapchain
);
3210 return DXGI_ERROR_UNSUPPORTED
;
3213 ID3D12CommandQueue_AddRef(swapchain
->command_queue
= queue
);
3214 ID3D12Device_AddRef(swapchain
->device
= device
);
3216 if (FAILED(hr
= d3d12_swapchain_create_d3d12_resources(swapchain
)))
3218 d3d12_swapchain_destroy(swapchain
);
3222 if (FAILED(hr
= d3d12_swapchain_create_vulkan_resources(swapchain
)))
3224 d3d12_swapchain_destroy(swapchain
);
3228 fence_desc
.sType
= VK_STRUCTURE_TYPE_FENCE_CREATE_INFO
;
3229 fence_desc
.pNext
= NULL
;
3230 fence_desc
.flags
= 0;
3231 if ((vr
= vk_funcs
->p_vkCreateFence(vk_device
, &fence_desc
, NULL
, &vk_fence
)) < 0)
3233 WARN("Failed to create Vulkan fence, vr %d.\n", vr
);
3234 d3d12_swapchain_destroy(swapchain
);
3235 return hresult_from_vk_result(vr
);
3237 swapchain
->vk_fence
= vk_fence
;
3239 swapchain
->current_buffer_index
= 0;
3241 if (swapchain_desc
->Flags
& DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT
)
3243 swapchain
->frame_latency
= 1;
3245 if (FAILED(hr
= ID3D12Device_CreateFence(device
, DXGI_MAX_SWAP_CHAIN_BUFFERS
,
3246 0, &IID_ID3D12Fence
, (void **)&swapchain
->frame_latency_fence
)))
3248 WARN("Failed to create frame latency fence, hr %#lx.\n", hr
);
3249 d3d12_swapchain_destroy(swapchain
);
3253 if (!(swapchain
->frame_latency_event
= CreateEventW(NULL
, FALSE
, TRUE
, NULL
)))
3255 hr
= HRESULT_FROM_WIN32(GetLastError());
3256 WARN("Failed to create frame latency event, hr %#lx.\n", hr
);
3257 d3d12_swapchain_destroy(swapchain
);
3262 if (FAILED(hr
= ID3D12Device_CreateFence(device
, 0, 0,
3263 &IID_ID3D12Fence
, (void **)&swapchain
->present_fence
)))
3265 WARN("Failed to create present fence, hr %#lx.\n", hr
);
3266 d3d12_swapchain_destroy(swapchain
);
3270 IWineDXGIFactory_AddRef(swapchain
->factory
= factory
);
3272 if (!(swapchain
->worker_thread
= CreateThread(NULL
, 0, d3d12_swapchain_worker_proc
, swapchain
, 0, NULL
)))
3274 hr
= HRESULT_FROM_WIN32(GetLastError());
3275 WARN("Failed to create worker thread, hr %#lx.\n", hr
);
3276 d3d12_swapchain_destroy(swapchain
);
3283 HRESULT
d3d12_swapchain_create(IWineDXGIFactory
*factory
, ID3D12CommandQueue
*queue
, HWND window
,
3284 const DXGI_SWAP_CHAIN_DESC1
*swapchain_desc
, const DXGI_SWAP_CHAIN_FULLSCREEN_DESC
*fullscreen_desc
,
3285 IDXGISwapChain1
**swapchain
)
3287 DXGI_SWAP_CHAIN_FULLSCREEN_DESC default_fullscreen_desc
;
3288 struct D3D12_COMMAND_QUEUE_DESC queue_desc
;
3289 struct d3d12_swapchain
*object
;
3290 ID3D12Device
*device
;
3293 if (swapchain_desc
->Format
== DXGI_FORMAT_UNKNOWN
)
3294 return DXGI_ERROR_INVALID_CALL
;
3296 queue_desc
= ID3D12CommandQueue_GetDesc(queue
);
3297 if (queue_desc
.Type
!= D3D12_COMMAND_LIST_TYPE_DIRECT
)
3298 return DXGI_ERROR_INVALID_CALL
;
3300 if (!fullscreen_desc
)
3302 memset(&default_fullscreen_desc
, 0, sizeof(default_fullscreen_desc
));
3303 default_fullscreen_desc
.Windowed
= TRUE
;
3304 fullscreen_desc
= &default_fullscreen_desc
;
3307 if (!(object
= calloc(1, sizeof(*object
))))
3308 return E_OUTOFMEMORY
;
3310 if (FAILED(hr
= ID3D12CommandQueue_GetDevice(queue
, &IID_ID3D12Device
, (void **)&device
)))
3312 ERR("Failed to get d3d12 device, hr %#lx.\n", hr
);
3317 hr
= d3d12_swapchain_init(object
, factory
, device
, queue
, window
, swapchain_desc
, fullscreen_desc
);
3318 ID3D12Device_Release(device
);
3325 TRACE("Created swapchain %p.\n", object
);
3327 *swapchain
= (IDXGISwapChain1
*)&object
->IDXGISwapChain4_iface
;