2 * Copyright 2008 Henri Verbeet for CodeWeavers
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 #include "wine/port.h"
23 #include "dxgi_private.h"
25 #ifdef SONAME_LIBVKD3D
26 #define VK_NO_PROTOTYPES
27 #define VKD3D_NO_PROTOTYPES
28 #define VKD3D_NO_VULKAN_H
29 #define VKD3D_NO_WIN32_TYPES
30 #ifndef USE_WIN32_VULKAN
33 #include "wine/vulkan.h"
34 #include "wine/vulkan_driver.h"
38 WINE_DEFAULT_DEBUG_CHANNEL(dxgi
);
39 WINE_DECLARE_DEBUG_CHANNEL(winediag
);
41 static DXGI_SWAP_EFFECT
dxgi_swap_effect_from_wined3d(enum wined3d_swap_effect swap_effect
)
45 case WINED3D_SWAP_EFFECT_DISCARD
:
46 return DXGI_SWAP_EFFECT_DISCARD
;
47 case WINED3D_SWAP_EFFECT_SEQUENTIAL
:
48 return DXGI_SWAP_EFFECT_SEQUENTIAL
;
49 case WINED3D_SWAP_EFFECT_FLIP_DISCARD
:
50 return DXGI_SWAP_EFFECT_FLIP_DISCARD
;
51 case WINED3D_SWAP_EFFECT_FLIP_SEQUENTIAL
:
52 return DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL
;
54 FIXME("Invalid swap effect %#x.\n", swap_effect
);
55 return DXGI_SWAP_EFFECT_DISCARD
;
59 static BOOL
dxgi_validate_flip_swap_effect_format(DXGI_FORMAT format
)
63 case DXGI_FORMAT_R16G16B16A16_FLOAT
:
64 case DXGI_FORMAT_R10G10B10A2_UNORM
:
65 case DXGI_FORMAT_R8G8B8A8_UNORM
:
66 case DXGI_FORMAT_B8G8R8A8_UNORM
:
69 WARN("Invalid swapchain format %#x for flip presentation model.\n", format
);
74 BOOL
dxgi_validate_swapchain_desc(const DXGI_SWAP_CHAIN_DESC1
*desc
)
76 unsigned int min_buffer_count
;
78 switch (desc
->SwapEffect
)
80 case DXGI_SWAP_EFFECT_DISCARD
:
81 case DXGI_SWAP_EFFECT_SEQUENTIAL
:
85 case DXGI_SWAP_EFFECT_FLIP_DISCARD
:
86 case DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL
:
89 if (desc
->Format
&& !dxgi_validate_flip_swap_effect_format(desc
->Format
))
92 if (desc
->SampleDesc
.Count
!= 1 || desc
->SampleDesc
.Quality
)
94 WARN("Invalid sample desc %u, %u for swap effect %#x.\n",
95 desc
->SampleDesc
.Count
, desc
->SampleDesc
.Quality
, desc
->SwapEffect
);
101 WARN("Invalid swap effect %u used.\n", desc
->SwapEffect
);
105 if (desc
->BufferCount
< min_buffer_count
|| desc
->BufferCount
> DXGI_MAX_SWAP_CHAIN_BUFFERS
)
107 WARN("BufferCount is %u.\n", desc
->BufferCount
);
114 static HRESULT
dxgi_get_output_from_window(IDXGIAdapter
*adapter
, HWND window
, IDXGIOutput
**dxgi_output
)
116 DXGI_OUTPUT_DESC desc
;
122 if (!(monitor
= MonitorFromWindow(window
, MONITOR_DEFAULTTONEAREST
)))
124 WARN("Failed to get monitor from window.\n");
125 return DXGI_ERROR_INVALID_CALL
;
129 while ((hr
= IDXGIAdapter_EnumOutputs(adapter
, index
, &output
)) == S_OK
)
131 if (FAILED(hr
= IDXGIOutput_GetDesc(output
, &desc
)))
133 WARN("Failed to get output desc %u, hr %#x.\n", index
, hr
);
138 if (desc
.Monitor
== monitor
)
140 *dxgi_output
= output
;
144 IDXGIOutput_Release(output
);
147 if (hr
!= DXGI_ERROR_NOT_FOUND
)
148 WARN("Failed to enumerate outputs, hr %#x.\n", hr
);
150 WARN("Output could not be found.\n");
151 return DXGI_ERROR_NOT_FOUND
;
154 static HRESULT
dxgi_swapchain_set_fullscreen_state(struct wined3d_swapchain_state
*state
,
155 const struct wined3d_swapchain_desc
*swapchain_desc
, IDXGIOutput
*output
)
157 struct dxgi_output
*dxgi_output
;
160 dxgi_output
= unsafe_impl_from_IDXGIOutput(output
);
162 wined3d_mutex_lock();
163 hr
= wined3d_swapchain_state_set_fullscreen(state
, swapchain_desc
,
164 dxgi_output
->wined3d_output
, NULL
);
165 wined3d_mutex_unlock();
170 static HRESULT
dxgi_swapchain_resize_target(IDXGISwapChain1
*swapchain
,
171 struct wined3d_swapchain_state
*state
, const DXGI_MODE_DESC
*target_mode_desc
)
173 struct wined3d_display_mode mode
;
174 struct dxgi_output
*dxgi_output
;
178 if (!target_mode_desc
)
180 WARN("Invalid pointer.\n");
181 return DXGI_ERROR_INVALID_CALL
;
184 if (FAILED(hr
= IDXGISwapChain1_GetContainingOutput(swapchain
, &output
)))
186 dxgi_output
= unsafe_impl_from_IDXGIOutput(output
);
188 TRACE("Mode: %s.\n", debug_dxgi_mode(target_mode_desc
));
190 if (target_mode_desc
->Scaling
)
191 FIXME("Ignoring scaling %#x.\n", target_mode_desc
->Scaling
);
193 wined3d_display_mode_from_dxgi(&mode
, target_mode_desc
);
195 hr
= wined3d_swapchain_state_resize_target(state
, dxgi_output
->wined3d_output
, &mode
);
196 IDXGIOutput_Release(output
);
200 static HWND
d3d11_swapchain_get_hwnd(struct d3d11_swapchain
*swapchain
)
202 struct wined3d_swapchain_desc wined3d_desc
;
204 wined3d_mutex_lock();
205 wined3d_swapchain_get_desc(swapchain
->wined3d_swapchain
, &wined3d_desc
);
206 wined3d_mutex_unlock();
208 return wined3d_desc
.device_window
;
211 static inline struct d3d11_swapchain
*d3d11_swapchain_from_IDXGISwapChain1(IDXGISwapChain1
*iface
)
213 return CONTAINING_RECORD(iface
, struct d3d11_swapchain
, IDXGISwapChain1_iface
);
216 /* IUnknown methods */
218 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_QueryInterface(IDXGISwapChain1
*iface
, REFIID riid
, void **object
)
220 TRACE("iface %p, riid %s, object %p\n", iface
, debugstr_guid(riid
), object
);
222 if (IsEqualGUID(riid
, &IID_IUnknown
)
223 || IsEqualGUID(riid
, &IID_IDXGIObject
)
224 || IsEqualGUID(riid
, &IID_IDXGIDeviceSubObject
)
225 || IsEqualGUID(riid
, &IID_IDXGISwapChain
)
226 || IsEqualGUID(riid
, &IID_IDXGISwapChain1
))
228 IUnknown_AddRef(iface
);
233 WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid
));
236 return E_NOINTERFACE
;
239 static ULONG STDMETHODCALLTYPE
d3d11_swapchain_AddRef(IDXGISwapChain1
*iface
)
241 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
242 ULONG refcount
= InterlockedIncrement(&swapchain
->refcount
);
244 TRACE("%p increasing refcount to %u.\n", swapchain
, refcount
);
247 wined3d_swapchain_incref(swapchain
->wined3d_swapchain
);
252 static ULONG STDMETHODCALLTYPE
d3d11_swapchain_Release(IDXGISwapChain1
*iface
)
254 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
255 ULONG refcount
= InterlockedDecrement(&swapchain
->refcount
);
257 TRACE("%p decreasing refcount to %u.\n", swapchain
, refcount
);
261 IWineDXGIDevice
*device
= swapchain
->device
;
262 if (swapchain
->target
)
264 WARN("Releasing fullscreen swapchain.\n");
265 IDXGIOutput_Release(swapchain
->target
);
267 if (swapchain
->factory
)
268 IDXGIFactory_Release(swapchain
->factory
);
269 wined3d_swapchain_decref(swapchain
->wined3d_swapchain
);
271 IWineDXGIDevice_Release(device
);
277 /* IDXGIObject methods */
279 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_SetPrivateData(IDXGISwapChain1
*iface
,
280 REFGUID guid
, UINT data_size
, const void *data
)
282 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
284 TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface
, debugstr_guid(guid
), data_size
, data
);
286 return dxgi_set_private_data(&swapchain
->private_store
, guid
, data_size
, data
);
289 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_SetPrivateDataInterface(IDXGISwapChain1
*iface
,
290 REFGUID guid
, const IUnknown
*object
)
292 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
294 TRACE("iface %p, guid %s, object %p.\n", iface
, debugstr_guid(guid
), object
);
296 return dxgi_set_private_data_interface(&swapchain
->private_store
, guid
, object
);
299 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetPrivateData(IDXGISwapChain1
*iface
,
300 REFGUID guid
, UINT
*data_size
, void *data
)
302 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
304 TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface
, debugstr_guid(guid
), data_size
, data
);
306 return dxgi_get_private_data(&swapchain
->private_store
, guid
, data_size
, data
);
309 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetParent(IDXGISwapChain1
*iface
, REFIID riid
, void **parent
)
311 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
313 TRACE("iface %p, riid %s, parent %p.\n", iface
, debugstr_guid(riid
), parent
);
315 if (!swapchain
->factory
)
317 ERR("Implicit swapchain does not store reference to parent.\n");
319 return E_NOINTERFACE
;
322 return IDXGIFactory_QueryInterface(swapchain
->factory
, riid
, parent
);
325 /* IDXGIDeviceSubObject methods */
327 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetDevice(IDXGISwapChain1
*iface
, REFIID riid
, void **device
)
329 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
331 TRACE("iface %p, riid %s, device %p.\n", iface
, debugstr_guid(riid
), device
);
333 if (!swapchain
->device
)
335 ERR("Implicit swapchain does not store reference to device.\n");
337 return E_NOINTERFACE
;
340 return IWineDXGIDevice_QueryInterface(swapchain
->device
, riid
, device
);
343 /* IDXGISwapChain1 methods */
345 static HRESULT
d3d11_swapchain_present(struct d3d11_swapchain
*swapchain
,
346 unsigned int sync_interval
, unsigned int flags
)
348 if (sync_interval
> 4)
350 WARN("Invalid sync interval %u.\n", sync_interval
);
351 return DXGI_ERROR_INVALID_CALL
;
354 if (IsIconic(d3d11_swapchain_get_hwnd(swapchain
)))
355 return DXGI_STATUS_OCCLUDED
;
357 if (flags
& ~DXGI_PRESENT_TEST
)
358 FIXME("Unimplemented flags %#x.\n", flags
);
359 if (flags
& DXGI_PRESENT_TEST
)
361 WARN("Returning S_OK for DXGI_PRESENT_TEST.\n");
365 return wined3d_swapchain_present(swapchain
->wined3d_swapchain
, NULL
, NULL
, NULL
, sync_interval
, 0);
368 static HRESULT STDMETHODCALLTYPE DECLSPEC_HOTPATCH
d3d11_swapchain_Present(IDXGISwapChain1
*iface
, UINT sync_interval
, UINT flags
)
370 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
372 TRACE("iface %p, sync_interval %u, flags %#x.\n", iface
, sync_interval
, flags
);
374 return d3d11_swapchain_present(swapchain
, sync_interval
, flags
);
377 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetBuffer(IDXGISwapChain1
*iface
,
378 UINT buffer_idx
, REFIID riid
, void **surface
)
380 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
381 struct wined3d_texture
*texture
;
385 TRACE("iface %p, buffer_idx %u, riid %s, surface %p\n",
386 iface
, buffer_idx
, debugstr_guid(riid
), surface
);
388 wined3d_mutex_lock();
390 if (!(texture
= wined3d_swapchain_get_back_buffer(swapchain
->wined3d_swapchain
, buffer_idx
)))
392 wined3d_mutex_unlock();
393 return DXGI_ERROR_INVALID_CALL
;
396 parent
= wined3d_texture_get_parent(texture
);
397 hr
= IUnknown_QueryInterface(parent
, riid
, surface
);
398 wined3d_mutex_unlock();
403 static HRESULT STDMETHODCALLTYPE DECLSPEC_HOTPATCH
d3d11_swapchain_SetFullscreenState(IDXGISwapChain1
*iface
,
404 BOOL fullscreen
, IDXGIOutput
*target
)
406 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
407 struct wined3d_swapchain_desc swapchain_desc
;
408 struct wined3d_swapchain_state
*state
;
411 TRACE("iface %p, fullscreen %#x, target %p.\n", iface
, fullscreen
, target
);
413 if (!fullscreen
&& target
)
415 WARN("Invalid call.\n");
416 return DXGI_ERROR_INVALID_CALL
;
421 IDXGIOutput_AddRef(target
);
423 else if (FAILED(hr
= IDXGISwapChain1_GetContainingOutput(iface
, &target
)))
425 WARN("Failed to get target output for swapchain, hr %#x.\n", hr
);
429 wined3d_mutex_lock();
430 state
= wined3d_swapchain_get_state(swapchain
->wined3d_swapchain
);
431 wined3d_swapchain_get_desc(swapchain
->wined3d_swapchain
, &swapchain_desc
);
432 swapchain_desc
.windowed
= !fullscreen
;
433 hr
= dxgi_swapchain_set_fullscreen_state(state
, &swapchain_desc
, target
);
434 wined3d_mutex_unlock();
437 IDXGIOutput_Release(target
);
439 return DXGI_ERROR_NOT_CURRENTLY_AVAILABLE
;
444 IDXGIOutput_Release(target
);
448 if (swapchain
->target
)
449 IDXGIOutput_Release(swapchain
->target
);
450 swapchain
->target
= target
;
455 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetFullscreenState(IDXGISwapChain1
*iface
,
456 BOOL
*fullscreen
, IDXGIOutput
**target
)
458 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
459 struct wined3d_swapchain_desc swapchain_desc
;
462 TRACE("iface %p, fullscreen %p, target %p.\n", iface
, fullscreen
, target
);
464 if (fullscreen
|| target
)
466 wined3d_mutex_lock();
467 wined3d_swapchain_get_desc(swapchain
->wined3d_swapchain
, &swapchain_desc
);
468 wined3d_mutex_unlock();
472 *fullscreen
= !swapchain_desc
.windowed
;
476 if (!swapchain_desc
.windowed
)
478 if (!swapchain
->target
&& FAILED(hr
= IDXGISwapChain1_GetContainingOutput(iface
, &swapchain
->target
)))
481 *target
= swapchain
->target
;
482 IDXGIOutput_AddRef(*target
);
493 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetDesc(IDXGISwapChain1
*iface
, DXGI_SWAP_CHAIN_DESC
*desc
)
495 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
496 struct wined3d_swapchain_desc wined3d_desc
;
498 TRACE("iface %p, desc %p.\n", iface
, desc
);
502 WARN("Invalid pointer.\n");
506 wined3d_mutex_lock();
507 wined3d_swapchain_get_desc(swapchain
->wined3d_swapchain
, &wined3d_desc
);
508 wined3d_mutex_unlock();
510 FIXME("Ignoring ScanlineOrdering and Scaling.\n");
512 desc
->BufferDesc
.Width
= wined3d_desc
.backbuffer_width
;
513 desc
->BufferDesc
.Height
= wined3d_desc
.backbuffer_height
;
514 desc
->BufferDesc
.RefreshRate
.Numerator
= wined3d_desc
.refresh_rate
;
515 desc
->BufferDesc
.RefreshRate
.Denominator
= 1;
516 desc
->BufferDesc
.Format
= dxgi_format_from_wined3dformat(wined3d_desc
.backbuffer_format
);
517 desc
->BufferDesc
.ScanlineOrdering
= DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED
;
518 desc
->BufferDesc
.Scaling
= DXGI_MODE_SCALING_UNSPECIFIED
;
519 dxgi_sample_desc_from_wined3d(&desc
->SampleDesc
,
520 wined3d_desc
.multisample_type
, wined3d_desc
.multisample_quality
);
521 desc
->BufferUsage
= dxgi_usage_from_wined3d_bind_flags(wined3d_desc
.backbuffer_bind_flags
);
522 desc
->BufferCount
= wined3d_desc
.backbuffer_count
;
523 desc
->OutputWindow
= wined3d_desc
.device_window
;
524 desc
->Windowed
= wined3d_desc
.windowed
;
525 desc
->SwapEffect
= dxgi_swap_effect_from_wined3d(wined3d_desc
.swap_effect
);
526 desc
->Flags
= dxgi_swapchain_flags_from_wined3d(wined3d_desc
.flags
);
531 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_ResizeBuffers(IDXGISwapChain1
*iface
,
532 UINT buffer_count
, UINT width
, UINT height
, DXGI_FORMAT format
, UINT flags
)
534 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
535 struct wined3d_swapchain_desc wined3d_desc
;
536 struct wined3d_texture
*texture
;
541 TRACE("iface %p, buffer_count %u, width %u, height %u, format %s, flags %#x.\n",
542 iface
, buffer_count
, width
, height
, debug_dxgi_format(format
), flags
);
545 FIXME("Ignoring flags %#x.\n", flags
);
547 wined3d_mutex_lock();
548 wined3d_swapchain_get_desc(swapchain
->wined3d_swapchain
, &wined3d_desc
);
549 for (i
= 0; i
< wined3d_desc
.backbuffer_count
; ++i
)
551 texture
= wined3d_swapchain_get_back_buffer(swapchain
->wined3d_swapchain
, i
);
552 parent
= wined3d_texture_get_parent(texture
);
553 IUnknown_AddRef(parent
);
554 if (IUnknown_Release(parent
))
556 wined3d_mutex_unlock();
557 return DXGI_ERROR_INVALID_CALL
;
560 if (format
!= DXGI_FORMAT_UNKNOWN
)
561 wined3d_desc
.backbuffer_format
= wined3dformat_from_dxgi_format(format
);
562 hr
= wined3d_swapchain_resize_buffers(swapchain
->wined3d_swapchain
, buffer_count
, width
, height
,
563 wined3d_desc
.backbuffer_format
, wined3d_desc
.multisample_type
, wined3d_desc
.multisample_quality
);
564 wined3d_mutex_unlock();
569 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_ResizeTarget(IDXGISwapChain1
*iface
,
570 const DXGI_MODE_DESC
*target_mode_desc
)
572 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
573 struct wined3d_swapchain_state
*state
;
575 TRACE("iface %p, target_mode_desc %p.\n", iface
, target_mode_desc
);
577 state
= wined3d_swapchain_get_state(swapchain
->wined3d_swapchain
);
579 return dxgi_swapchain_resize_target(iface
, state
, target_mode_desc
);
582 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetContainingOutput(IDXGISwapChain1
*iface
, IDXGIOutput
**output
)
584 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
585 IDXGIAdapter
*adapter
;
589 TRACE("iface %p, output %p.\n", iface
, output
);
591 if (swapchain
->target
)
593 IDXGIOutput_AddRef(*output
= swapchain
->target
);
597 if (SUCCEEDED(hr
= d3d11_swapchain_GetDevice(iface
, &IID_IDXGIDevice
, (void **)&device
)))
599 hr
= IDXGIDevice_GetAdapter(device
, &adapter
);
600 IDXGIDevice_Release(device
);
605 HWND hwnd
= d3d11_swapchain_get_hwnd(swapchain
);
606 hr
= dxgi_get_output_from_window(adapter
, hwnd
, output
);
607 IDXGIAdapter_Release(adapter
);
611 WARN("Failed to get adapter, hr %#x.\n", hr
);
617 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetFrameStatistics(IDXGISwapChain1
*iface
,
618 DXGI_FRAME_STATISTICS
*stats
)
620 FIXME("iface %p, stats %p stub!\n", iface
, stats
);
625 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetLastPresentCount(IDXGISwapChain1
*iface
,
626 UINT
*last_present_count
)
628 FIXME("iface %p, last_present_count %p stub!\n", iface
, last_present_count
);
633 /* IDXGISwapChain1 methods */
635 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetDesc1(IDXGISwapChain1
*iface
, DXGI_SWAP_CHAIN_DESC1
*desc
)
637 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
638 struct wined3d_swapchain_desc wined3d_desc
;
640 TRACE("iface %p, desc %p.\n", iface
, desc
);
644 WARN("Invalid pointer.\n");
648 wined3d_mutex_lock();
649 wined3d_swapchain_get_desc(swapchain
->wined3d_swapchain
, &wined3d_desc
);
650 wined3d_mutex_unlock();
652 FIXME("Ignoring Stereo, Scaling and AlphaMode.\n");
654 desc
->Width
= wined3d_desc
.backbuffer_width
;
655 desc
->Height
= wined3d_desc
.backbuffer_height
;
656 desc
->Format
= dxgi_format_from_wined3dformat(wined3d_desc
.backbuffer_format
);
657 desc
->Stereo
= FALSE
;
658 dxgi_sample_desc_from_wined3d(&desc
->SampleDesc
,
659 wined3d_desc
.multisample_type
, wined3d_desc
.multisample_quality
);
660 desc
->BufferUsage
= dxgi_usage_from_wined3d_bind_flags(wined3d_desc
.backbuffer_bind_flags
);
661 desc
->BufferCount
= wined3d_desc
.backbuffer_count
;
662 desc
->Scaling
= DXGI_SCALING_STRETCH
;
663 desc
->SwapEffect
= dxgi_swap_effect_from_wined3d(wined3d_desc
.swap_effect
);
664 desc
->AlphaMode
= DXGI_ALPHA_MODE_IGNORE
;
665 desc
->Flags
= dxgi_swapchain_flags_from_wined3d(wined3d_desc
.flags
);
670 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetFullscreenDesc(IDXGISwapChain1
*iface
,
671 DXGI_SWAP_CHAIN_FULLSCREEN_DESC
*desc
)
673 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
674 struct wined3d_swapchain_desc wined3d_desc
;
676 TRACE("iface %p, desc %p.\n", iface
, desc
);
680 WARN("Invalid pointer.\n");
684 wined3d_mutex_lock();
685 wined3d_swapchain_get_desc(swapchain
->wined3d_swapchain
, &wined3d_desc
);
686 wined3d_mutex_unlock();
688 FIXME("Ignoring ScanlineOrdering and Scaling.\n");
690 desc
->RefreshRate
.Numerator
= wined3d_desc
.refresh_rate
;
691 desc
->RefreshRate
.Denominator
= 1;
692 desc
->ScanlineOrdering
= DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED
;
693 desc
->Scaling
= DXGI_MODE_SCALING_UNSPECIFIED
;
694 desc
->Windowed
= wined3d_desc
.windowed
;
699 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetHwnd(IDXGISwapChain1
*iface
, HWND
*hwnd
)
701 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
703 TRACE("iface %p, hwnd %p.\n", iface
, hwnd
);
707 WARN("Invalid pointer.\n");
708 return DXGI_ERROR_INVALID_CALL
;
711 *hwnd
= d3d11_swapchain_get_hwnd(swapchain
);
715 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetCoreWindow(IDXGISwapChain1
*iface
,
716 REFIID iid
, void **core_window
)
718 FIXME("iface %p, iid %s, core_window %p stub!\n", iface
, debugstr_guid(iid
), core_window
);
723 return DXGI_ERROR_INVALID_CALL
;
726 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_Present1(IDXGISwapChain1
*iface
,
727 UINT sync_interval
, UINT flags
, const DXGI_PRESENT_PARAMETERS
*present_parameters
)
729 struct d3d11_swapchain
*swapchain
= d3d11_swapchain_from_IDXGISwapChain1(iface
);
731 TRACE("iface %p, sync_interval %u, flags %#x, present_parameters %p.\n",
732 iface
, sync_interval
, flags
, present_parameters
);
734 if (present_parameters
)
735 FIXME("Ignored present parameters %p.\n", present_parameters
);
737 return d3d11_swapchain_present(swapchain
, sync_interval
, flags
);
740 static BOOL STDMETHODCALLTYPE
d3d11_swapchain_IsTemporaryMonoSupported(IDXGISwapChain1
*iface
)
742 FIXME("iface %p stub!\n", iface
);
747 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetRestrictToOutput(IDXGISwapChain1
*iface
, IDXGIOutput
**output
)
749 FIXME("iface %p, output %p stub!\n", iface
, output
);
753 WARN("Invalid pointer.\n");
761 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_SetBackgroundColor(IDXGISwapChain1
*iface
, const DXGI_RGBA
*color
)
763 FIXME("iface %p, color %p stub!\n", iface
, color
);
768 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetBackgroundColor(IDXGISwapChain1
*iface
, DXGI_RGBA
*color
)
770 FIXME("iface %p, color %p stub!\n", iface
, color
);
775 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_SetRotation(IDXGISwapChain1
*iface
, DXGI_MODE_ROTATION rotation
)
777 FIXME("iface %p, rotation %#x stub!\n", iface
, rotation
);
782 static HRESULT STDMETHODCALLTYPE
d3d11_swapchain_GetRotation(IDXGISwapChain1
*iface
, DXGI_MODE_ROTATION
*rotation
)
784 FIXME("iface %p, rotation %p stub!\n", iface
, rotation
);
789 static const struct IDXGISwapChain1Vtbl d3d11_swapchain_vtbl
=
791 /* IUnknown methods */
792 d3d11_swapchain_QueryInterface
,
793 d3d11_swapchain_AddRef
,
794 d3d11_swapchain_Release
,
795 /* IDXGIObject methods */
796 d3d11_swapchain_SetPrivateData
,
797 d3d11_swapchain_SetPrivateDataInterface
,
798 d3d11_swapchain_GetPrivateData
,
799 d3d11_swapchain_GetParent
,
800 /* IDXGIDeviceSubObject methods */
801 d3d11_swapchain_GetDevice
,
802 /* IDXGISwapChain methods */
803 d3d11_swapchain_Present
,
804 d3d11_swapchain_GetBuffer
,
805 d3d11_swapchain_SetFullscreenState
,
806 d3d11_swapchain_GetFullscreenState
,
807 d3d11_swapchain_GetDesc
,
808 d3d11_swapchain_ResizeBuffers
,
809 d3d11_swapchain_ResizeTarget
,
810 d3d11_swapchain_GetContainingOutput
,
811 d3d11_swapchain_GetFrameStatistics
,
812 d3d11_swapchain_GetLastPresentCount
,
813 /* IDXGISwapChain1 methods */
814 d3d11_swapchain_GetDesc1
,
815 d3d11_swapchain_GetFullscreenDesc
,
816 d3d11_swapchain_GetHwnd
,
817 d3d11_swapchain_GetCoreWindow
,
818 d3d11_swapchain_Present1
,
819 d3d11_swapchain_IsTemporaryMonoSupported
,
820 d3d11_swapchain_GetRestrictToOutput
,
821 d3d11_swapchain_SetBackgroundColor
,
822 d3d11_swapchain_GetBackgroundColor
,
823 d3d11_swapchain_SetRotation
,
824 d3d11_swapchain_GetRotation
,
827 static void STDMETHODCALLTYPE
d3d11_swapchain_wined3d_object_released(void *parent
)
829 struct d3d11_swapchain
*swapchain
= parent
;
831 wined3d_private_store_cleanup(&swapchain
->private_store
);
835 static const struct wined3d_parent_ops d3d11_swapchain_wined3d_parent_ops
=
837 d3d11_swapchain_wined3d_object_released
,
840 HRESULT
d3d11_swapchain_init(struct d3d11_swapchain
*swapchain
, struct dxgi_device
*device
,
841 struct wined3d_swapchain_desc
*desc
)
846 /* A reference to the implicit swapchain is held by the wined3d device. In
847 * order to avoid circular references we do not keep a reference to the
848 * device in the implicit swapchain. */
849 if (!(desc
->flags
& WINED3D_SWAPCHAIN_IMPLICIT
))
851 if (desc
->backbuffer_format
== WINED3DFMT_UNKNOWN
)
854 if (FAILED(hr
= IWineDXGIAdapter_GetParent(device
->adapter
, &IID_IDXGIFactory
,
855 (void **)&swapchain
->factory
)))
857 WARN("Failed to get adapter parent, hr %#x.\n", hr
);
860 IWineDXGIDevice_AddRef(swapchain
->device
= &device
->IWineDXGIDevice_iface
);
864 swapchain
->device
= NULL
;
865 swapchain
->factory
= NULL
;
868 swapchain
->IDXGISwapChain1_iface
.lpVtbl
= &d3d11_swapchain_vtbl
;
869 swapchain
->refcount
= 1;
870 wined3d_mutex_lock();
871 wined3d_private_store_init(&swapchain
->private_store
);
873 if (!desc
->windowed
&& (!desc
->backbuffer_width
|| !desc
->backbuffer_height
))
874 FIXME("Fullscreen swapchain with back buffer width/height equal to 0 not supported properly.\n");
876 fullscreen
= !desc
->windowed
;
877 desc
->windowed
= TRUE
;
878 if (FAILED(hr
= wined3d_swapchain_create(device
->wined3d_device
, desc
, swapchain
,
879 &d3d11_swapchain_wined3d_parent_ops
, &swapchain
->wined3d_swapchain
)))
881 WARN("Failed to create wined3d swapchain, hr %#x.\n", hr
);
885 swapchain
->target
= NULL
;
888 struct wined3d_swapchain_state
*state
;
890 desc
->windowed
= FALSE
;
891 state
= wined3d_swapchain_get_state(swapchain
->wined3d_swapchain
);
893 if (FAILED(hr
= IDXGISwapChain1_GetContainingOutput(&swapchain
->IDXGISwapChain1_iface
,
894 &swapchain
->target
)))
896 WARN("Failed to get target output for fullscreen swapchain, hr %#x.\n", hr
);
897 wined3d_swapchain_decref(swapchain
->wined3d_swapchain
);
901 if (FAILED(hr
= dxgi_swapchain_set_fullscreen_state(state
, desc
, swapchain
->target
)))
903 WARN("Failed to set fullscreen state, hr %#x.\n", hr
);
904 IDXGIOutput_Release(swapchain
->target
);
905 wined3d_swapchain_decref(swapchain
->wined3d_swapchain
);
910 wined3d_mutex_unlock();
915 wined3d_private_store_cleanup(&swapchain
->private_store
);
916 wined3d_mutex_unlock();
917 if (swapchain
->factory
)
918 IDXGIFactory_Release(swapchain
->factory
);
919 if (swapchain
->device
)
920 IWineDXGIDevice_Release(swapchain
->device
);
924 #ifdef SONAME_LIBVKD3D
926 #ifdef USE_WIN32_VULKAN
928 static void *load_library(const char *name
)
930 return LoadLibraryA(name
);
933 static void *get_library_proc(void *handle
, const char *name
)
935 return (void *)GetProcAddress(handle
, name
);
938 static void close_library(void *handle
)
944 static PFN_vkGetInstanceProcAddr
load_vulkan(void **vulkan_handle
)
946 *vulkan_handle
= LoadLibraryA("vulkan-1.dll");
947 return (void *)GetProcAddress(*vulkan_handle
, "vkGetInstanceProcAddr");
952 static void *load_library(const char *name
)
954 return dlopen(name
, RTLD_NOW
);
957 static void *get_library_proc(void *handle
, const char *name
)
959 return dlsym(handle
, name
);
962 static void close_library(void *handle
)
968 static PFN_vkGetInstanceProcAddr
load_vulkan(void **vulkan_handle
)
970 const struct vulkan_funcs
*vk_funcs
;
973 *vulkan_handle
= NULL
;
976 vk_funcs
= __wine_get_vulkan_driver(hdc
, WINE_VULKAN_DRIVER_VERSION
);
980 return (PFN_vkGetInstanceProcAddr
)vk_funcs
->p_vkGetInstanceProcAddr
;
985 #endif /* USE_WIN32_VULKAN */
987 static PFN_vkd3d_acquire_vk_queue vkd3d_acquire_vk_queue
;
988 static PFN_vkd3d_create_image_resource vkd3d_create_image_resource
;
989 static PFN_vkd3d_get_device_parent vkd3d_get_device_parent
;
990 static PFN_vkd3d_get_vk_device vkd3d_get_vk_device
;
991 static PFN_vkd3d_get_vk_format vkd3d_get_vk_format
;
992 static PFN_vkd3d_get_vk_physical_device vkd3d_get_vk_physical_device
;
993 static PFN_vkd3d_get_vk_queue_family_index vkd3d_get_vk_queue_family_index
;
994 static PFN_vkd3d_instance_from_device vkd3d_instance_from_device
;
995 static PFN_vkd3d_instance_get_vk_instance vkd3d_instance_get_vk_instance
;
996 static PFN_vkd3d_release_vk_queue vkd3d_release_vk_queue
;
997 static PFN_vkd3d_resource_decref vkd3d_resource_decref
;
998 static PFN_vkd3d_resource_incref vkd3d_resource_incref
;
1000 struct dxgi_vk_funcs
1002 PFN_vkAcquireNextImageKHR p_vkAcquireNextImageKHR
;
1003 PFN_vkAllocateCommandBuffers p_vkAllocateCommandBuffers
;
1004 PFN_vkAllocateMemory p_vkAllocateMemory
;
1005 PFN_vkBeginCommandBuffer p_vkBeginCommandBuffer
;
1006 PFN_vkBindImageMemory p_vkBindImageMemory
;
1007 PFN_vkCmdBlitImage p_vkCmdBlitImage
;
1008 PFN_vkCmdPipelineBarrier p_vkCmdPipelineBarrier
;
1009 PFN_vkCreateCommandPool p_vkCreateCommandPool
;
1010 PFN_vkCreateFence p_vkCreateFence
;
1011 PFN_vkCreateImage p_vkCreateImage
;
1012 PFN_vkCreateSemaphore p_vkCreateSemaphore
;
1013 PFN_vkCreateSwapchainKHR p_vkCreateSwapchainKHR
;
1014 PFN_vkCreateWin32SurfaceKHR p_vkCreateWin32SurfaceKHR
;
1015 PFN_vkDestroyCommandPool p_vkDestroyCommandPool
;
1016 PFN_vkDestroyFence p_vkDestroyFence
;
1017 PFN_vkDestroyImage p_vkDestroyImage
;
1018 PFN_vkDestroySemaphore p_vkDestroySemaphore
;
1019 PFN_vkDestroySurfaceKHR p_vkDestroySurfaceKHR
;
1020 PFN_vkResetCommandBuffer p_vkResetCommandBuffer
;
1021 PFN_vkDestroySwapchainKHR p_vkDestroySwapchainKHR
;
1022 PFN_vkEndCommandBuffer p_vkEndCommandBuffer
;
1023 PFN_vkFreeMemory p_vkFreeMemory
;
1024 PFN_vkGetImageMemoryRequirements p_vkGetImageMemoryRequirements
;
1025 PFN_vkGetInstanceProcAddr p_vkGetInstanceProcAddr
;
1026 PFN_vkGetPhysicalDeviceMemoryProperties p_vkGetPhysicalDeviceMemoryProperties
;
1027 PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR p_vkGetPhysicalDeviceSurfaceCapabilitiesKHR
;
1028 PFN_vkGetPhysicalDeviceSurfaceFormatsKHR p_vkGetPhysicalDeviceSurfaceFormatsKHR
;
1029 PFN_vkGetPhysicalDeviceSurfacePresentModesKHR p_vkGetPhysicalDeviceSurfacePresentModesKHR
;
1030 PFN_vkGetPhysicalDeviceSurfaceSupportKHR p_vkGetPhysicalDeviceSurfaceSupportKHR
;
1031 PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR p_vkGetPhysicalDeviceWin32PresentationSupportKHR
;
1032 PFN_vkGetSwapchainImagesKHR p_vkGetSwapchainImagesKHR
;
1033 PFN_vkQueuePresentKHR p_vkQueuePresentKHR
;
1034 PFN_vkQueueSubmit p_vkQueueSubmit
;
1035 PFN_vkQueueWaitIdle p_vkQueueWaitIdle
;
1036 PFN_vkResetFences p_vkResetFences
;
1037 PFN_vkWaitForFences p_vkWaitForFences
;
1039 void *vulkan_module
;
1042 static HRESULT
hresult_from_vk_result(VkResult vr
)
1048 case VK_ERROR_OUT_OF_HOST_MEMORY
:
1049 case VK_ERROR_OUT_OF_DEVICE_MEMORY
:
1050 return E_OUTOFMEMORY
;
1052 FIXME("Unhandled VkResult %d.\n", vr
);
1057 #define INVALID_VK_IMAGE_INDEX (~(uint32_t)0)
1059 struct d3d12_swapchain
1061 IDXGISwapChain3 IDXGISwapChain3_iface
;
1063 struct wined3d_private_store private_store
;
1065 struct wined3d_swapchain_state
*state
;
1067 VkSwapchainKHR vk_swapchain
;
1068 VkSurfaceKHR vk_surface
;
1070 VkInstance vk_instance
;
1072 VkPhysicalDevice vk_physical_device
;
1073 VkDeviceMemory vk_memory
;
1074 VkCommandPool vk_cmd_pool
;
1075 VkImage vk_images
[DXGI_MAX_SWAP_CHAIN_BUFFERS
];
1076 VkImage vk_swapchain_images
[DXGI_MAX_SWAP_CHAIN_BUFFERS
];
1077 VkCommandBuffer vk_cmd_buffers
[DXGI_MAX_SWAP_CHAIN_BUFFERS
];
1078 VkSemaphore vk_semaphores
[DXGI_MAX_SWAP_CHAIN_BUFFERS
];
1079 ID3D12Resource
*buffers
[DXGI_MAX_SWAP_CHAIN_BUFFERS
];
1080 unsigned int buffer_count
;
1081 unsigned int vk_swapchain_width
;
1082 unsigned int vk_swapchain_height
;
1083 VkPresentModeKHR present_mode
;
1085 uint32_t vk_image_index
;
1086 unsigned int current_buffer_index
;
1087 struct dxgi_vk_funcs vk_funcs
;
1089 ID3D12CommandQueue
*command_queue
;
1090 ID3D12Device
*device
;
1091 IWineDXGIFactory
*factory
;
1094 IDXGIOutput
*target
;
1095 DXGI_SWAP_CHAIN_DESC1 desc
;
1096 DXGI_SWAP_CHAIN_FULLSCREEN_DESC fullscreen_desc
;
1098 ID3D12Fence
*frame_latency_fence
;
1099 HANDLE frame_latency_event
;
1101 uint64_t frame_number
;
1102 uint32_t frame_latency
;
1105 static DXGI_FORMAT
dxgi_format_from_vk_format(VkFormat vk_format
)
1109 case VK_FORMAT_B8G8R8A8_UNORM
: return DXGI_FORMAT_B8G8R8A8_UNORM
;
1110 case VK_FORMAT_R8G8B8A8_UNORM
: return DXGI_FORMAT_R8G8B8A8_UNORM
;
1111 case VK_FORMAT_A2B10G10R10_UNORM_PACK32
: return DXGI_FORMAT_R10G10B10A2_UNORM
;
1112 case VK_FORMAT_R16G16B16A16_SFLOAT
: return DXGI_FORMAT_R16G16B16A16_FLOAT
;
1114 WARN("Unhandled format %#x.\n", vk_format
);
1115 return DXGI_FORMAT_UNKNOWN
;
1119 static VkFormat
get_swapchain_fallback_format(VkFormat vk_format
)
1123 case VK_FORMAT_R8G8B8A8_UNORM
:
1124 case VK_FORMAT_A2B10G10R10_UNORM_PACK32
:
1125 case VK_FORMAT_R16G16B16A16_SFLOAT
:
1126 return VK_FORMAT_B8G8R8A8_UNORM
;
1128 WARN("Unhandled format %#x.\n", vk_format
);
1129 return VK_FORMAT_UNDEFINED
;
1133 static HRESULT
select_vk_format(const struct dxgi_vk_funcs
*vk_funcs
,
1134 VkPhysicalDevice vk_physical_device
, VkSurfaceKHR vk_surface
,
1135 const DXGI_SWAP_CHAIN_DESC1
*swapchain_desc
, VkFormat
*vk_format
)
1137 VkSurfaceFormatKHR
*formats
;
1138 uint32_t format_count
;
1143 *vk_format
= VK_FORMAT_UNDEFINED
;
1145 format
= vkd3d_get_vk_format(swapchain_desc
->Format
);
1147 vr
= vk_funcs
->p_vkGetPhysicalDeviceSurfaceFormatsKHR(vk_physical_device
, vk_surface
, &format_count
, NULL
);
1148 if (vr
< 0 || !format_count
)
1150 WARN("Failed to get supported surface formats, vr %d.\n", vr
);
1151 return DXGI_ERROR_INVALID_CALL
;
1154 if (!(formats
= heap_calloc(format_count
, sizeof(*formats
))))
1155 return E_OUTOFMEMORY
;
1157 if ((vr
= vk_funcs
->p_vkGetPhysicalDeviceSurfaceFormatsKHR(vk_physical_device
,
1158 vk_surface
, &format_count
, formats
)) < 0)
1160 WARN("Failed to enumerate supported surface formats, vr %d.\n", vr
);
1162 return hresult_from_vk_result(vr
);
1165 for (i
= 0; i
< format_count
; ++i
)
1167 if (formats
[i
].format
== format
&& formats
[i
].colorSpace
== VK_COLOR_SPACE_SRGB_NONLINEAR_KHR
)
1170 if (i
== format_count
)
1172 /* Try to create a swapchain with format conversion. */
1173 format
= get_swapchain_fallback_format(format
);
1174 WARN("Failed to find Vulkan swapchain format for %s.\n", debug_dxgi_format(swapchain_desc
->Format
));
1175 for (i
= 0; i
< format_count
; ++i
)
1177 if (formats
[i
].format
== format
&& formats
[i
].colorSpace
== VK_COLOR_SPACE_SRGB_NONLINEAR_KHR
)
1179 format
= formats
[i
].format
;
1185 if (i
== format_count
)
1187 FIXME("Failed to find Vulkan swapchain format for %s.\n", debug_dxgi_format(swapchain_desc
->Format
));
1188 return DXGI_ERROR_UNSUPPORTED
;
1191 TRACE("Using Vulkan swapchain format %#x.\n", format
);
1193 *vk_format
= format
;
1197 static HRESULT
vk_select_memory_type(const struct dxgi_vk_funcs
*vk_funcs
,
1198 VkPhysicalDevice vk_physical_device
, uint32_t memory_type_mask
,
1199 VkMemoryPropertyFlags flags
, uint32_t *memory_type_index
)
1201 VkPhysicalDeviceMemoryProperties memory_properties
;
1204 vk_funcs
->p_vkGetPhysicalDeviceMemoryProperties(vk_physical_device
, &memory_properties
);
1205 for (i
= 0; i
< memory_properties
.memoryTypeCount
; ++i
)
1207 if (!(memory_type_mask
& (1u << i
)))
1210 if ((memory_properties
.memoryTypes
[i
].propertyFlags
& flags
) == flags
)
1212 *memory_type_index
= i
;
1217 FIXME("Failed to find memory type (allowed types %#x).\n", memory_type_mask
);
1221 static BOOL
d3d12_swapchain_is_present_mode_supported(struct d3d12_swapchain
*swapchain
,
1222 VkPresentModeKHR present_mode
)
1224 VkPhysicalDevice vk_physical_device
= swapchain
->vk_physical_device
;
1225 const struct dxgi_vk_funcs
*vk_funcs
= &swapchain
->vk_funcs
;
1226 VkPresentModeKHR
*modes
;
1231 if (present_mode
== VK_PRESENT_MODE_FIFO_KHR
)
1234 if ((vr
= vk_funcs
->p_vkGetPhysicalDeviceSurfacePresentModesKHR(vk_physical_device
,
1235 swapchain
->vk_surface
, &count
, NULL
)) < 0)
1237 WARN("Failed to get count of available present modes, vr %d.\n", vr
);
1243 if (!(modes
= heap_calloc(count
, sizeof(*modes
))))
1245 if ((vr
= vk_funcs
->p_vkGetPhysicalDeviceSurfacePresentModesKHR(vk_physical_device
,
1246 swapchain
->vk_surface
, &count
, modes
)) >= 0)
1248 for (i
= 0; i
< count
; ++i
)
1250 if (modes
[i
] == present_mode
)
1259 WARN("Failed to get available present modes, vr %d.\n", vr
);
1266 static BOOL
d3d12_swapchain_has_user_images(struct d3d12_swapchain
*swapchain
)
1268 return !!swapchain
->vk_images
[0];
1271 static HRESULT
d3d12_swapchain_create_user_buffers(struct d3d12_swapchain
*swapchain
, VkFormat vk_format
)
1273 const struct dxgi_vk_funcs
*vk_funcs
= &swapchain
->vk_funcs
;
1274 VkDeviceSize image_offset
[DXGI_MAX_SWAP_CHAIN_BUFFERS
];
1275 VkDevice vk_device
= swapchain
->vk_device
;
1276 VkMemoryAllocateInfo allocate_info
;
1277 VkMemoryRequirements requirements
;
1278 VkImageCreateInfo image_info
;
1279 uint32_t memory_type_mask
;
1280 VkDeviceSize memory_size
;
1285 if (d3d12_swapchain_has_user_images(swapchain
))
1288 memset(&image_info
, 0, sizeof(image_info
));
1289 image_info
.sType
= VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO
;
1290 image_info
.flags
= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT
;
1291 image_info
.imageType
= VK_IMAGE_TYPE_2D
;
1292 image_info
.format
= vk_format
;
1293 image_info
.extent
.width
= swapchain
->desc
.Width
;
1294 image_info
.extent
.height
= swapchain
->desc
.Height
;
1295 image_info
.extent
.depth
= 1;
1296 image_info
.mipLevels
= 1;
1297 image_info
.arrayLayers
= 1;
1298 image_info
.samples
= VK_SAMPLE_COUNT_1_BIT
;
1299 image_info
.tiling
= VK_IMAGE_TILING_OPTIMAL
;
1300 image_info
.usage
= VK_IMAGE_USAGE_TRANSFER_SRC_BIT
1301 | VK_IMAGE_USAGE_TRANSFER_DST_BIT
1302 | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT
;
1303 image_info
.sharingMode
= VK_SHARING_MODE_EXCLUSIVE
;
1304 image_info
.queueFamilyIndexCount
= 0;
1305 image_info
.pQueueFamilyIndices
= NULL
;
1306 image_info
.initialLayout
= VK_IMAGE_LAYOUT_UNDEFINED
;
1308 for (i
= 0; i
< swapchain
->desc
.BufferCount
; ++i
)
1310 assert(swapchain
->vk_images
[i
] == VK_NULL_HANDLE
);
1311 if ((vr
= vk_funcs
->p_vkCreateImage(vk_device
, &image_info
, NULL
, &swapchain
->vk_images
[i
])) < 0)
1313 WARN("Failed to create Vulkan image, vr %d.\n", vr
);
1314 swapchain
->vk_images
[i
] = VK_NULL_HANDLE
;
1315 return hresult_from_vk_result(vr
);
1320 memory_type_mask
= ~0u;
1321 for (i
= 0; i
< swapchain
->desc
.BufferCount
; ++i
)
1323 vk_funcs
->p_vkGetImageMemoryRequirements(vk_device
, swapchain
->vk_images
[i
], &requirements
);
1325 TRACE("Size %s, alignment %s, memory types %#x.\n",
1326 wine_dbgstr_longlong(requirements
.size
), wine_dbgstr_longlong(requirements
.alignment
),
1327 requirements
.memoryTypeBits
);
1329 image_offset
[i
] = (memory_size
+ (requirements
.alignment
- 1)) & ~(requirements
.alignment
- 1);
1330 memory_size
= image_offset
[i
] + requirements
.size
;
1332 memory_type_mask
&= requirements
.memoryTypeBits
;
1335 TRACE("Allocating %s bytes for user images.\n", wine_dbgstr_longlong(memory_size
));
1337 allocate_info
.sType
= VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO
;
1338 allocate_info
.pNext
= NULL
;
1339 allocate_info
.allocationSize
= memory_size
;
1341 if (FAILED(hr
= vk_select_memory_type(vk_funcs
, swapchain
->vk_physical_device
,
1342 memory_type_mask
, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT
, &allocate_info
.memoryTypeIndex
)))
1345 assert(swapchain
->vk_memory
== VK_NULL_HANDLE
);
1346 if ((vr
= vk_funcs
->p_vkAllocateMemory(vk_device
, &allocate_info
, NULL
, &swapchain
->vk_memory
)) < 0)
1348 WARN("Failed to allocate device memory, vr %d.\n", vr
);
1349 swapchain
->vk_memory
= VK_NULL_HANDLE
;
1350 return hresult_from_vk_result(vr
);
1353 for (i
= 0; i
< swapchain
->desc
.BufferCount
; ++i
)
1355 if ((vr
= vk_funcs
->p_vkBindImageMemory(vk_device
, swapchain
->vk_images
[i
],
1356 swapchain
->vk_memory
, image_offset
[i
])) < 0)
1358 WARN("Failed to bind image memory, vr %d.\n", vr
);
1359 return hresult_from_vk_result(vr
);
1366 static void vk_cmd_image_barrier(const struct dxgi_vk_funcs
*vk_funcs
, VkCommandBuffer cmd_buffer
,
1367 VkPipelineStageFlags src_stage_mask
, VkPipelineStageFlags dst_stage_mask
,
1368 VkAccessFlags src_access_mask
, VkAccessFlags dst_access_mask
,
1369 VkImageLayout old_layout
, VkImageLayout new_layout
, VkImage image
)
1371 VkImageMemoryBarrier barrier
;
1373 barrier
.sType
= VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER
;
1374 barrier
.pNext
= NULL
;
1375 barrier
.srcAccessMask
= src_access_mask
;
1376 barrier
.dstAccessMask
= dst_access_mask
;
1377 barrier
.oldLayout
= old_layout
;
1378 barrier
.newLayout
= new_layout
;
1379 barrier
.srcQueueFamilyIndex
= VK_QUEUE_FAMILY_IGNORED
;
1380 barrier
.dstQueueFamilyIndex
= VK_QUEUE_FAMILY_IGNORED
;
1381 barrier
.image
= image
;
1382 barrier
.subresourceRange
.aspectMask
= VK_IMAGE_ASPECT_COLOR_BIT
;
1383 barrier
.subresourceRange
.baseMipLevel
= 0;
1384 barrier
.subresourceRange
.levelCount
= VK_REMAINING_MIP_LEVELS
;
1385 barrier
.subresourceRange
.baseArrayLayer
= 0;
1386 barrier
.subresourceRange
.layerCount
= VK_REMAINING_ARRAY_LAYERS
;
1388 vk_funcs
->p_vkCmdPipelineBarrier(cmd_buffer
,
1389 src_stage_mask
, dst_stage_mask
, 0, 0, NULL
, 0, NULL
, 1, &barrier
);
1392 static VkResult
d3d12_swapchain_record_swapchain_blit(struct d3d12_swapchain
*swapchain
,
1393 VkCommandBuffer vk_cmd_buffer
, VkImage vk_dst_image
, VkImage vk_src_image
)
1395 const struct dxgi_vk_funcs
*vk_funcs
= &swapchain
->vk_funcs
;
1396 VkCommandBufferBeginInfo begin_info
;
1401 if (swapchain
->desc
.Width
!= swapchain
->vk_swapchain_width
1402 || swapchain
->desc
.Height
!= swapchain
->vk_swapchain_height
)
1403 filter
= VK_FILTER_LINEAR
;
1405 filter
= VK_FILTER_NEAREST
;
1407 begin_info
.sType
= VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO
;
1408 begin_info
.pNext
= NULL
;
1409 begin_info
.flags
= 0;
1410 begin_info
.pInheritanceInfo
= NULL
;
1412 if ((vr
= vk_funcs
->p_vkBeginCommandBuffer(vk_cmd_buffer
, &begin_info
)) < 0)
1414 WARN("Failed to begin command buffer, vr %d.\n", vr
);
1418 vk_cmd_image_barrier(vk_funcs
, vk_cmd_buffer
,
1419 VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT
, VK_PIPELINE_STAGE_TRANSFER_BIT
,
1420 0, VK_ACCESS_TRANSFER_WRITE_BIT
,
1421 VK_IMAGE_LAYOUT_UNDEFINED
, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
, vk_dst_image
);
1423 blit
.srcSubresource
.aspectMask
= VK_IMAGE_ASPECT_COLOR_BIT
;
1424 blit
.srcSubresource
.mipLevel
= 0;
1425 blit
.srcSubresource
.baseArrayLayer
= 0;
1426 blit
.srcSubresource
.layerCount
= 1;
1427 blit
.srcOffsets
[0].x
= 0;
1428 blit
.srcOffsets
[0].y
= 0;
1429 blit
.srcOffsets
[0].z
= 0;
1430 blit
.srcOffsets
[1].x
= swapchain
->desc
.Width
;
1431 blit
.srcOffsets
[1].y
= swapchain
->desc
.Height
;
1432 blit
.srcOffsets
[1].z
= 1;
1433 blit
.dstSubresource
= blit
.srcSubresource
;
1434 blit
.dstOffsets
[0].x
= 0;
1435 blit
.dstOffsets
[0].y
= 0;
1436 blit
.dstOffsets
[0].z
= 0;
1437 if (swapchain
->desc
.Scaling
== DXGI_SCALING_NONE
)
1439 blit
.srcOffsets
[1].x
= min(swapchain
->vk_swapchain_width
, blit
.srcOffsets
[1].x
);
1440 blit
.srcOffsets
[1].y
= min(swapchain
->vk_swapchain_height
, blit
.srcOffsets
[1].y
);
1441 blit
.dstOffsets
[1].x
= blit
.srcOffsets
[1].x
;
1442 blit
.dstOffsets
[1].y
= blit
.srcOffsets
[1].y
;
1446 /* FIXME: handle DXGI_SCALING_ASPECT_RATIO_STRETCH. */
1447 blit
.dstOffsets
[1].x
= swapchain
->vk_swapchain_width
;
1448 blit
.dstOffsets
[1].y
= swapchain
->vk_swapchain_height
;
1450 blit
.dstOffsets
[1].z
= 1;
1452 vk_funcs
->p_vkCmdBlitImage(vk_cmd_buffer
,
1453 vk_src_image
, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL
,
1454 vk_dst_image
, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
,
1457 vk_cmd_image_barrier(vk_funcs
, vk_cmd_buffer
,
1458 VK_PIPELINE_STAGE_TRANSFER_BIT
, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT
,
1459 VK_ACCESS_TRANSFER_WRITE_BIT
, 0,
1460 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR
, vk_dst_image
);
1462 if ((vr
= vk_funcs
->p_vkEndCommandBuffer(vk_cmd_buffer
)) < 0)
1463 WARN("Failed to end command buffer, vr %d.\n", vr
);
1468 static HRESULT
d3d12_swapchain_prepare_command_buffers(struct d3d12_swapchain
*swapchain
,
1469 uint32_t queue_family_index
)
1471 const struct dxgi_vk_funcs
*vk_funcs
= &swapchain
->vk_funcs
;
1472 VkDevice vk_device
= swapchain
->vk_device
;
1473 VkCommandBufferAllocateInfo allocate_info
;
1474 VkSemaphoreCreateInfo semaphore_info
;
1475 VkCommandPoolCreateInfo pool_info
;
1479 pool_info
.sType
= VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO
;
1480 pool_info
.pNext
= NULL
;
1481 pool_info
.flags
= VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT
;
1482 pool_info
.queueFamilyIndex
= queue_family_index
;
1484 assert(swapchain
->vk_cmd_pool
== VK_NULL_HANDLE
);
1485 if ((vr
= vk_funcs
->p_vkCreateCommandPool(vk_device
, &pool_info
,
1486 NULL
, &swapchain
->vk_cmd_pool
)) < 0)
1488 WARN("Failed to create command pool, vr %d.\n", vr
);
1489 swapchain
->vk_cmd_pool
= VK_NULL_HANDLE
;
1490 return hresult_from_vk_result(vr
);
1493 allocate_info
.sType
= VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO
;
1494 allocate_info
.pNext
= NULL
;
1495 allocate_info
.commandPool
= swapchain
->vk_cmd_pool
;
1496 allocate_info
.level
= VK_COMMAND_BUFFER_LEVEL_PRIMARY
;
1497 allocate_info
.commandBufferCount
= swapchain
->buffer_count
;
1499 if ((vr
= vk_funcs
->p_vkAllocateCommandBuffers(vk_device
, &allocate_info
,
1500 swapchain
->vk_cmd_buffers
)) < 0)
1502 WARN("Failed to allocate command buffers, vr %d.\n", vr
);
1503 return hresult_from_vk_result(vr
);
1506 for (i
= 0; i
< swapchain
->buffer_count
; ++i
)
1508 semaphore_info
.sType
= VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO
;
1509 semaphore_info
.pNext
= NULL
;
1510 semaphore_info
.flags
= 0;
1512 assert(swapchain
->vk_semaphores
[i
] == VK_NULL_HANDLE
);
1513 if ((vr
= vk_funcs
->p_vkCreateSemaphore(vk_device
, &semaphore_info
,
1514 NULL
, &swapchain
->vk_semaphores
[i
])) < 0)
1516 WARN("Failed to create semaphore, vr %d.\n", vr
);
1517 swapchain
->vk_semaphores
[i
] = VK_NULL_HANDLE
;
1518 return hresult_from_vk_result(vr
);
1525 static HRESULT
d3d12_swapchain_create_buffers(struct d3d12_swapchain
*swapchain
,
1526 VkFormat vk_swapchain_format
, VkFormat vk_format
)
1528 const struct dxgi_vk_funcs
*vk_funcs
= &swapchain
->vk_funcs
;
1529 struct vkd3d_image_resource_create_info resource_info
;
1530 VkSwapchainKHR vk_swapchain
= swapchain
->vk_swapchain
;
1531 ID3D12CommandQueue
*queue
= swapchain
->command_queue
;
1532 VkDevice vk_device
= swapchain
->vk_device
;
1533 ID3D12Device
*device
= swapchain
->device
;
1534 uint32_t image_count
, queue_family_index
;
1535 D3D12_COMMAND_QUEUE_DESC queue_desc
;
1540 if ((vr
= vk_funcs
->p_vkGetSwapchainImagesKHR(vk_device
, vk_swapchain
, &image_count
, NULL
)) < 0)
1542 WARN("Failed to get Vulkan swapchain images, vr %d.\n", vr
);
1543 return hresult_from_vk_result(vr
);
1545 if (image_count
> ARRAY_SIZE(swapchain
->vk_swapchain_images
))
1547 FIXME("Unsupported Vulkan swapchain image count %u.\n", image_count
);
1550 swapchain
->buffer_count
= image_count
;
1551 if ((vr
= vk_funcs
->p_vkGetSwapchainImagesKHR(vk_device
, vk_swapchain
,
1552 &image_count
, swapchain
->vk_swapchain_images
)) < 0)
1554 WARN("Failed to get Vulkan swapchain images, vr %d.\n", vr
);
1555 return hresult_from_vk_result(vr
);
1558 resource_info
.type
= VKD3D_STRUCTURE_TYPE_IMAGE_RESOURCE_CREATE_INFO
;
1559 resource_info
.next
= NULL
;
1560 resource_info
.desc
.Dimension
= D3D12_RESOURCE_DIMENSION_TEXTURE2D
;
1561 resource_info
.desc
.Alignment
= 0;
1562 resource_info
.desc
.Width
= swapchain
->desc
.Width
;
1563 resource_info
.desc
.Height
= swapchain
->desc
.Height
;
1564 resource_info
.desc
.DepthOrArraySize
= 1;
1565 resource_info
.desc
.MipLevels
= 1;
1566 resource_info
.desc
.Format
= dxgi_format_from_vk_format(vk_format
);
1567 resource_info
.desc
.SampleDesc
.Count
= 1;
1568 resource_info
.desc
.SampleDesc
.Quality
= 0;
1569 resource_info
.desc
.Layout
= D3D12_TEXTURE_LAYOUT_UNKNOWN
;
1570 resource_info
.desc
.Flags
= D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET
;
1571 resource_info
.flags
= VKD3D_RESOURCE_INITIAL_STATE_TRANSITION
| VKD3D_RESOURCE_PRESENT_STATE_TRANSITION
;
1573 queue_desc
= ID3D12CommandQueue_GetDesc(queue
);
1574 if (queue_desc
.Type
!= D3D12_COMMAND_LIST_TYPE_DIRECT
)
1576 /* vkCmdBlitImage() is only supported for graphics queues. */
1577 FIXME("Swapchain blit not implemented for command queue type %#x.\n", queue_desc
.Type
);
1578 if (vk_swapchain_format
!= vk_format
)
1580 if (image_count
!= swapchain
->desc
.BufferCount
)
1582 FIXME("Got %u swapchain images, expected %u.\n", image_count
, swapchain
->desc
.BufferCount
);
1586 queue_family_index
= vkd3d_get_vk_queue_family_index(queue
);
1588 if (queue_desc
.Type
== D3D12_COMMAND_LIST_TYPE_DIRECT
)
1590 TRACE("Creating user swapchain buffers.\n");
1592 if (FAILED(hr
= d3d12_swapchain_create_user_buffers(swapchain
, vk_format
)))
1595 if (FAILED(hr
= d3d12_swapchain_prepare_command_buffers(swapchain
, queue_family_index
)))
1599 if (swapchain
->buffers
[0])
1602 for (i
= 0; i
< swapchain
->desc
.BufferCount
; ++i
)
1604 if (swapchain
->vk_images
[i
])
1606 resource_info
.vk_image
= swapchain
->vk_images
[i
];
1607 resource_info
.present_state
= D3D12_RESOURCE_STATE_COPY_SOURCE
;
1611 resource_info
.vk_image
= swapchain
->vk_swapchain_images
[i
];
1612 resource_info
.present_state
= D3D12_RESOURCE_STATE_PRESENT
;
1615 if (FAILED(hr
= vkd3d_create_image_resource(device
, &resource_info
, &swapchain
->buffers
[i
])))
1617 WARN("Failed to create vkd3d resource for Vulkan image %u, hr %#x.\n", i
, hr
);
1621 vkd3d_resource_incref(swapchain
->buffers
[i
]);
1622 ID3D12Resource_Release(swapchain
->buffers
[i
]);
1628 static VkResult
d3d12_swapchain_acquire_next_vulkan_image(struct d3d12_swapchain
*swapchain
)
1630 const struct dxgi_vk_funcs
*vk_funcs
= &swapchain
->vk_funcs
;
1631 VkDevice vk_device
= swapchain
->vk_device
;
1632 VkFence vk_fence
= swapchain
->vk_fence
;
1635 swapchain
->vk_image_index
= INVALID_VK_IMAGE_INDEX
;
1637 if ((vr
= vk_funcs
->p_vkAcquireNextImageKHR(vk_device
, swapchain
->vk_swapchain
, UINT64_MAX
,
1638 VK_NULL_HANDLE
, vk_fence
, &swapchain
->vk_image_index
)) < 0)
1640 WARN("Failed to acquire next Vulkan image, vr %d.\n", vr
);
1644 if ((vr
= vk_funcs
->p_vkWaitForFences(vk_device
, 1, &vk_fence
, VK_TRUE
, UINT64_MAX
)) != VK_SUCCESS
)
1646 ERR("Failed to wait for fence, vr %d.\n", vr
);
1649 if ((vr
= vk_funcs
->p_vkResetFences(vk_device
, 1, &vk_fence
)) < 0)
1650 ERR("Failed to reset fence, vr %d.\n", vr
);
1655 static VkResult
d3d12_swapchain_acquire_next_back_buffer(struct d3d12_swapchain
*swapchain
)
1659 /* If we don't have user images, we need to acquire a Vulkan image in order
1660 * to get the correct value for the current back buffer index. */
1661 if (d3d12_swapchain_has_user_images(swapchain
))
1664 if ((vr
= d3d12_swapchain_acquire_next_vulkan_image(swapchain
)) >= 0)
1665 swapchain
->current_buffer_index
= swapchain
->vk_image_index
;
1667 ERR("Failed to acquire Vulkan image, vr %d.\n", vr
);
1672 static void d3d12_swapchain_destroy_buffers(struct d3d12_swapchain
*swapchain
, BOOL destroy_user_buffers
)
1674 const struct dxgi_vk_funcs
*vk_funcs
= &swapchain
->vk_funcs
;
1678 if (swapchain
->command_queue
)
1680 if ((vk_queue
= vkd3d_acquire_vk_queue(swapchain
->command_queue
)))
1682 vk_funcs
->p_vkQueueWaitIdle(vk_queue
);
1684 vkd3d_release_vk_queue(swapchain
->command_queue
);
1688 WARN("Failed to acquire Vulkan queue.\n");
1692 for (i
= 0; i
< swapchain
->desc
.BufferCount
; ++i
)
1694 if (swapchain
->buffers
[i
] && (destroy_user_buffers
|| !d3d12_swapchain_has_user_images(swapchain
)))
1696 vkd3d_resource_decref(swapchain
->buffers
[i
]);
1697 swapchain
->buffers
[i
] = NULL
;
1699 if (swapchain
->vk_device
&& destroy_user_buffers
)
1701 vk_funcs
->p_vkDestroyImage(swapchain
->vk_device
, swapchain
->vk_images
[i
], NULL
);
1702 swapchain
->vk_images
[i
] = VK_NULL_HANDLE
;
1706 if (swapchain
->vk_device
)
1708 for (i
= 0; i
< swapchain
->buffer_count
; ++i
)
1710 vk_funcs
->p_vkDestroySemaphore(swapchain
->vk_device
, swapchain
->vk_semaphores
[i
], NULL
);
1711 swapchain
->vk_semaphores
[i
] = VK_NULL_HANDLE
;
1713 if (destroy_user_buffers
)
1715 vk_funcs
->p_vkFreeMemory(swapchain
->vk_device
, swapchain
->vk_memory
, NULL
);
1716 swapchain
->vk_memory
= VK_NULL_HANDLE
;
1718 vk_funcs
->p_vkDestroyCommandPool(swapchain
->vk_device
, swapchain
->vk_cmd_pool
, NULL
);
1719 swapchain
->vk_cmd_pool
= VK_NULL_HANDLE
;
1723 static HRESULT
d3d12_swapchain_create_vulkan_swapchain(struct d3d12_swapchain
*swapchain
)
1725 VkPhysicalDevice vk_physical_device
= swapchain
->vk_physical_device
;
1726 const struct dxgi_vk_funcs
*vk_funcs
= &swapchain
->vk_funcs
;
1727 VkSwapchainCreateInfoKHR vk_swapchain_desc
;
1728 VkDevice vk_device
= swapchain
->vk_device
;
1729 VkFormat vk_format
, vk_swapchain_format
;
1730 unsigned int width
, height
, image_count
;
1731 VkSurfaceCapabilitiesKHR surface_caps
;
1732 VkSwapchainKHR vk_swapchain
;
1733 VkImageUsageFlags usage
;
1737 if (!(vk_format
= vkd3d_get_vk_format(swapchain
->desc
.Format
)))
1739 WARN("Invalid format %#x.\n", swapchain
->desc
.Format
);
1740 return DXGI_ERROR_INVALID_CALL
;
1743 if (FAILED(hr
= select_vk_format(vk_funcs
, vk_physical_device
,
1744 swapchain
->vk_surface
, &swapchain
->desc
, &vk_swapchain_format
)))
1747 if ((vr
= vk_funcs
->p_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(vk_physical_device
,
1748 swapchain
->vk_surface
, &surface_caps
)) < 0)
1750 WARN("Failed to get surface capabilities, vr %d.\n", vr
);
1751 return hresult_from_vk_result(vr
);
1754 image_count
= swapchain
->desc
.BufferCount
;
1755 image_count
= max(image_count
, surface_caps
.minImageCount
);
1756 if (surface_caps
.maxImageCount
)
1757 image_count
= min(image_count
, surface_caps
.maxImageCount
);
1759 if (image_count
!= swapchain
->desc
.BufferCount
)
1761 WARN("Buffer count %u is not supported (%u-%u).\n", swapchain
->desc
.BufferCount
,
1762 surface_caps
.minImageCount
, surface_caps
.maxImageCount
);
1765 width
= swapchain
->desc
.Width
;
1766 height
= swapchain
->desc
.Height
;
1767 width
= max(width
, surface_caps
.minImageExtent
.width
);
1768 width
= min(width
, surface_caps
.maxImageExtent
.width
);
1769 height
= max(height
, surface_caps
.minImageExtent
.height
);
1770 height
= min(height
, surface_caps
.maxImageExtent
.height
);
1772 if (width
!= swapchain
->desc
.Width
|| height
!= swapchain
->desc
.Height
)
1774 WARN("Swapchain dimensions %ux%u are not supported (%u-%u x %u-%u).\n",
1775 swapchain
->desc
.Width
, swapchain
->desc
.Height
,
1776 surface_caps
.minImageExtent
.width
, surface_caps
.maxImageExtent
.width
,
1777 surface_caps
.minImageExtent
.height
, surface_caps
.maxImageExtent
.height
);
1780 TRACE("Vulkan swapchain extent %ux%u.\n", width
, height
);
1782 if (!(surface_caps
.supportedCompositeAlpha
& VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR
))
1784 FIXME("Unsupported alpha mode.\n");
1785 return DXGI_ERROR_UNSUPPORTED
;
1788 usage
= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT
;
1789 usage
|= surface_caps
.supportedUsageFlags
& VK_IMAGE_USAGE_TRANSFER_SRC_BIT
;
1790 usage
|= surface_caps
.supportedUsageFlags
& VK_IMAGE_USAGE_TRANSFER_DST_BIT
;
1791 if (!(usage
& VK_IMAGE_USAGE_TRANSFER_SRC_BIT
) || !(usage
& VK_IMAGE_USAGE_TRANSFER_DST_BIT
))
1792 WARN("Transfer not supported for swapchain images.\n");
1794 vk_swapchain_desc
.sType
= VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR
;
1795 vk_swapchain_desc
.pNext
= NULL
;
1796 vk_swapchain_desc
.flags
= 0;
1797 vk_swapchain_desc
.surface
= swapchain
->vk_surface
;
1798 vk_swapchain_desc
.minImageCount
= image_count
;
1799 vk_swapchain_desc
.imageFormat
= vk_swapchain_format
;
1800 vk_swapchain_desc
.imageColorSpace
= VK_COLOR_SPACE_SRGB_NONLINEAR_KHR
;
1801 vk_swapchain_desc
.imageExtent
.width
= width
;
1802 vk_swapchain_desc
.imageExtent
.height
= height
;
1803 vk_swapchain_desc
.imageArrayLayers
= 1;
1804 vk_swapchain_desc
.imageUsage
= usage
;
1805 vk_swapchain_desc
.imageSharingMode
= VK_SHARING_MODE_EXCLUSIVE
;
1806 vk_swapchain_desc
.queueFamilyIndexCount
= 0;
1807 vk_swapchain_desc
.pQueueFamilyIndices
= NULL
;
1808 vk_swapchain_desc
.preTransform
= surface_caps
.currentTransform
;
1809 vk_swapchain_desc
.compositeAlpha
= VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR
;
1810 vk_swapchain_desc
.presentMode
= swapchain
->present_mode
;
1811 vk_swapchain_desc
.clipped
= VK_TRUE
;
1812 vk_swapchain_desc
.oldSwapchain
= swapchain
->vk_swapchain
;
1813 if ((vr
= vk_funcs
->p_vkCreateSwapchainKHR(vk_device
, &vk_swapchain_desc
, NULL
, &vk_swapchain
)) < 0)
1815 WARN("Failed to create Vulkan swapchain, vr %d.\n", vr
);
1816 return hresult_from_vk_result(vr
);
1819 if (swapchain
->vk_swapchain
)
1820 vk_funcs
->p_vkDestroySwapchainKHR(swapchain
->vk_device
, swapchain
->vk_swapchain
, NULL
);
1822 swapchain
->vk_swapchain
= vk_swapchain
;
1823 swapchain
->vk_swapchain_width
= width
;
1824 swapchain
->vk_swapchain_height
= height
;
1826 swapchain
->vk_image_index
= INVALID_VK_IMAGE_INDEX
;
1828 return d3d12_swapchain_create_buffers(swapchain
, vk_swapchain_format
, vk_format
);
1831 static HRESULT
d3d12_swapchain_recreate_vulkan_swapchain(struct d3d12_swapchain
*swapchain
)
1836 if (SUCCEEDED(hr
= d3d12_swapchain_create_vulkan_swapchain(swapchain
)))
1838 vr
= d3d12_swapchain_acquire_next_back_buffer(swapchain
);
1839 hr
= hresult_from_vk_result(vr
);
1843 ERR("Failed to recreate Vulkan swapchain, hr %#x.\n", hr
);
1849 static inline struct d3d12_swapchain
*d3d12_swapchain_from_IDXGISwapChain3(IDXGISwapChain3
*iface
)
1851 return CONTAINING_RECORD(iface
, struct d3d12_swapchain
, IDXGISwapChain3_iface
);
1854 /* IUnknown methods */
1856 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_QueryInterface(IDXGISwapChain3
*iface
, REFIID iid
, void **object
)
1858 TRACE("iface %p, iid %s, object %p.\n", iface
, debugstr_guid(iid
), object
);
1860 if (IsEqualGUID(iid
, &IID_IUnknown
)
1861 || IsEqualGUID(iid
, &IID_IDXGIObject
)
1862 || IsEqualGUID(iid
, &IID_IDXGIDeviceSubObject
)
1863 || IsEqualGUID(iid
, &IID_IDXGISwapChain
)
1864 || IsEqualGUID(iid
, &IID_IDXGISwapChain1
)
1865 || IsEqualGUID(iid
, &IID_IDXGISwapChain2
)
1866 || IsEqualGUID(iid
, &IID_IDXGISwapChain3
))
1868 IUnknown_AddRef(iface
);
1873 WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid
));
1876 return E_NOINTERFACE
;
1879 static ULONG STDMETHODCALLTYPE
d3d12_swapchain_AddRef(IDXGISwapChain3
*iface
)
1881 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain3(iface
);
1882 ULONG refcount
= InterlockedIncrement(&swapchain
->refcount
);
1884 TRACE("%p increasing refcount to %u.\n", swapchain
, refcount
);
1889 static void d3d12_swapchain_destroy(struct d3d12_swapchain
*swapchain
)
1891 const struct dxgi_vk_funcs
*vk_funcs
= &swapchain
->vk_funcs
;
1892 void *vulkan_module
= vk_funcs
->vulkan_module
;
1894 d3d12_swapchain_destroy_buffers(swapchain
, TRUE
);
1896 if (swapchain
->frame_latency_event
)
1897 CloseHandle(swapchain
->frame_latency_event
);
1899 if (swapchain
->frame_latency_fence
)
1900 ID3D12Fence_Release(swapchain
->frame_latency_fence
);
1902 if (swapchain
->command_queue
)
1903 ID3D12CommandQueue_Release(swapchain
->command_queue
);
1905 wined3d_private_store_cleanup(&swapchain
->private_store
);
1907 if (swapchain
->vk_device
)
1909 vk_funcs
->p_vkDestroyFence(swapchain
->vk_device
, swapchain
->vk_fence
, NULL
);
1910 vk_funcs
->p_vkDestroySwapchainKHR(swapchain
->vk_device
, swapchain
->vk_swapchain
, NULL
);
1913 if (swapchain
->vk_instance
)
1914 vk_funcs
->p_vkDestroySurfaceKHR(swapchain
->vk_instance
, swapchain
->vk_surface
, NULL
);
1916 if (swapchain
->target
)
1918 WARN("Destroying fullscreen swapchain.\n");
1919 IDXGIOutput_Release(swapchain
->target
);
1922 if (swapchain
->device
)
1923 ID3D12Device_Release(swapchain
->device
);
1925 if (swapchain
->factory
)
1926 IWineDXGIFactory_Release(swapchain
->factory
);
1928 close_library(vulkan_module
);
1930 wined3d_swapchain_state_destroy(swapchain
->state
);
1933 static ULONG STDMETHODCALLTYPE
d3d12_swapchain_Release(IDXGISwapChain3
*iface
)
1935 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain3(iface
);
1936 ULONG refcount
= InterlockedDecrement(&swapchain
->refcount
);
1938 TRACE("%p decreasing refcount to %u.\n", swapchain
, refcount
);
1942 d3d12_swapchain_destroy(swapchain
);
1943 heap_free(swapchain
);
1949 /* IDXGIObject methods */
1951 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_SetPrivateData(IDXGISwapChain3
*iface
,
1952 REFGUID guid
, UINT data_size
, const void *data
)
1954 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain3(iface
);
1956 TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface
, debugstr_guid(guid
), data_size
, data
);
1958 return dxgi_set_private_data(&swapchain
->private_store
, guid
, data_size
, data
);
1961 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_SetPrivateDataInterface(IDXGISwapChain3
*iface
,
1962 REFGUID guid
, const IUnknown
*object
)
1964 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain3(iface
);
1966 TRACE("iface %p, guid %s, object %p.\n", iface
, debugstr_guid(guid
), object
);
1968 return dxgi_set_private_data_interface(&swapchain
->private_store
, guid
, object
);
1971 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetPrivateData(IDXGISwapChain3
*iface
,
1972 REFGUID guid
, UINT
*data_size
, void *data
)
1974 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain3(iface
);
1976 TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface
, debugstr_guid(guid
), data_size
, data
);
1978 return dxgi_get_private_data(&swapchain
->private_store
, guid
, data_size
, data
);
1981 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetParent(IDXGISwapChain3
*iface
, REFIID iid
, void **parent
)
1983 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain3(iface
);
1985 TRACE("iface %p, iid %s, parent %p.\n", iface
, debugstr_guid(iid
), parent
);
1987 return IWineDXGIFactory_QueryInterface(swapchain
->factory
, iid
, parent
);
1990 /* IDXGIDeviceSubObject methods */
1992 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetDevice(IDXGISwapChain3
*iface
, REFIID iid
, void **device
)
1994 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain3(iface
);
1996 TRACE("iface %p, iid %s, device %p.\n", iface
, debugstr_guid(iid
), device
);
1998 return ID3D12Device_QueryInterface(swapchain
->device
, iid
, device
);
2001 /* IDXGISwapChain methods */
2003 static HRESULT
d3d12_swapchain_set_sync_interval(struct d3d12_swapchain
*swapchain
,
2004 unsigned int sync_interval
)
2006 VkPresentModeKHR present_mode
;
2008 switch (sync_interval
)
2011 present_mode
= VK_PRESENT_MODE_IMMEDIATE_KHR
;
2014 FIXME("Unsupported sync interval %u.\n", sync_interval
);
2016 present_mode
= VK_PRESENT_MODE_FIFO_KHR
;
2020 if (swapchain
->present_mode
== present_mode
)
2023 if (!d3d12_swapchain_has_user_images(swapchain
))
2025 FIXME("Cannot recreate swapchain without user images.\n");
2029 if (!d3d12_swapchain_is_present_mode_supported(swapchain
, present_mode
))
2031 FIXME("Vulkan present mode %#x is not supported.\n", present_mode
);
2035 d3d12_swapchain_destroy_buffers(swapchain
, FALSE
);
2036 swapchain
->present_mode
= present_mode
;
2037 return d3d12_swapchain_recreate_vulkan_swapchain(swapchain
);
2040 static VkResult
d3d12_swapchain_queue_present(struct d3d12_swapchain
*swapchain
, VkQueue vk_queue
)
2042 const struct dxgi_vk_funcs
*vk_funcs
= &swapchain
->vk_funcs
;
2043 VkPresentInfoKHR present_info
;
2044 VkSubmitInfo submit_info
;
2047 if (swapchain
->vk_image_index
== INVALID_VK_IMAGE_INDEX
)
2049 if ((vr
= d3d12_swapchain_acquire_next_vulkan_image(swapchain
)) < 0)
2053 assert(swapchain
->vk_image_index
< swapchain
->buffer_count
);
2055 present_info
.sType
= VK_STRUCTURE_TYPE_PRESENT_INFO_KHR
;
2056 present_info
.pNext
= NULL
;
2057 present_info
.waitSemaphoreCount
= 0;
2058 present_info
.pWaitSemaphores
= NULL
;
2059 present_info
.swapchainCount
= 1;
2060 present_info
.pSwapchains
= &swapchain
->vk_swapchain
;
2061 present_info
.pImageIndices
= &swapchain
->vk_image_index
;
2062 present_info
.pResults
= NULL
;
2064 if (d3d12_swapchain_has_user_images(swapchain
))
2067 VkCommandBuffer vk_cmd_buffer
= swapchain
->vk_cmd_buffers
[swapchain
->vk_image_index
];
2068 VkImage vk_dst_image
= swapchain
->vk_swapchain_images
[swapchain
->vk_image_index
];
2069 VkImage vk_src_image
= swapchain
->vk_images
[swapchain
->current_buffer_index
];
2071 if ((vr
= vk_funcs
->p_vkResetCommandBuffer(vk_cmd_buffer
, 0)) < 0)
2073 ERR("Failed to reset command buffer, vr %d.\n", vr
);
2077 if ((vr
= d3d12_swapchain_record_swapchain_blit(swapchain
,
2078 vk_cmd_buffer
, vk_dst_image
, vk_src_image
)) < 0 )
2081 submit_info
.sType
= VK_STRUCTURE_TYPE_SUBMIT_INFO
;
2082 submit_info
.pNext
= NULL
;
2083 submit_info
.waitSemaphoreCount
= 0;
2084 submit_info
.pWaitSemaphores
= NULL
;
2085 submit_info
.pWaitDstStageMask
= NULL
;
2086 submit_info
.commandBufferCount
= 1;
2087 submit_info
.pCommandBuffers
= &vk_cmd_buffer
;
2088 submit_info
.signalSemaphoreCount
= 1;
2089 submit_info
.pSignalSemaphores
= &swapchain
->vk_semaphores
[swapchain
->vk_image_index
];
2091 if ((vr
= vk_funcs
->p_vkQueueSubmit(vk_queue
, 1, &submit_info
, VK_NULL_HANDLE
)) < 0)
2093 ERR("Failed to blit swapchain buffer, vr %d.\n", vr
);
2097 present_info
.waitSemaphoreCount
= 1;
2098 present_info
.pWaitSemaphores
= &swapchain
->vk_semaphores
[swapchain
->vk_image_index
];
2101 if ((vr
= vk_funcs
->p_vkQueuePresentKHR(vk_queue
, &present_info
)) >= 0)
2102 swapchain
->vk_image_index
= INVALID_VK_IMAGE_INDEX
;
2107 static HRESULT
d3d12_swapchain_present(struct d3d12_swapchain
*swapchain
,
2108 unsigned int sync_interval
, unsigned int flags
)
2110 HANDLE frame_latency_event
;
2115 if (sync_interval
> 4)
2117 WARN("Invalid sync interval %u.\n", sync_interval
);
2118 return DXGI_ERROR_INVALID_CALL
;
2121 if (flags
& ~DXGI_PRESENT_TEST
)
2122 FIXME("Unimplemented flags %#x.\n", flags
);
2123 if (flags
& DXGI_PRESENT_TEST
)
2125 WARN("Returning S_OK for DXGI_PRESENT_TEST.\n");
2129 if (FAILED(hr
= d3d12_swapchain_set_sync_interval(swapchain
, sync_interval
)))
2132 if (!(vk_queue
= vkd3d_acquire_vk_queue(swapchain
->command_queue
)))
2134 ERR("Failed to acquire Vulkan queue.\n");
2138 vr
= d3d12_swapchain_queue_present(swapchain
, vk_queue
);
2139 if (vr
== VK_ERROR_OUT_OF_DATE_KHR
)
2141 vkd3d_release_vk_queue(swapchain
->command_queue
);
2143 if (!d3d12_swapchain_has_user_images(swapchain
))
2145 FIXME("Cannot recreate swapchain without user images.\n");
2146 return DXGI_STATUS_MODE_CHANGED
;
2149 TRACE("Recreating Vulkan swapchain.\n");
2151 d3d12_swapchain_destroy_buffers(swapchain
, FALSE
);
2152 if (FAILED(hr
= d3d12_swapchain_recreate_vulkan_swapchain(swapchain
)))
2155 if (!(vk_queue
= vkd3d_acquire_vk_queue(swapchain
->command_queue
)))
2157 ERR("Failed to acquire Vulkan queue.\n");
2161 if ((vr
= d3d12_swapchain_queue_present(swapchain
, vk_queue
)) < 0)
2162 ERR("Failed to present after recreating swapchain, vr %d.\n", vr
);
2165 vkd3d_release_vk_queue(swapchain
->command_queue
);
2169 ERR("Failed to queue present, vr %d.\n", vr
);
2170 return hresult_from_vk_result(vr
);
2173 if ((frame_latency_event
= swapchain
->frame_latency_event
))
2175 ++swapchain
->frame_number
;
2177 if (FAILED(hr
= ID3D12CommandQueue_Signal(swapchain
->command_queue
,
2178 swapchain
->frame_latency_fence
, swapchain
->frame_number
)))
2180 ERR("Failed to signal frame latency fence, hr %#x.\n", hr
);
2184 if (FAILED(hr
= ID3D12Fence_SetEventOnCompletion(swapchain
->frame_latency_fence
,
2185 swapchain
->frame_number
- swapchain
->frame_latency
, frame_latency_event
)))
2187 ERR("Failed to enqueue frame latency event, hr %#x.\n", hr
);
2192 swapchain
->current_buffer_index
= (swapchain
->current_buffer_index
+ 1) % swapchain
->desc
.BufferCount
;
2193 vr
= d3d12_swapchain_acquire_next_back_buffer(swapchain
);
2194 if (vr
== VK_ERROR_OUT_OF_DATE_KHR
)
2196 if (!d3d12_swapchain_has_user_images(swapchain
))
2198 FIXME("Cannot recreate swapchain without user images.\n");
2199 return DXGI_STATUS_MODE_CHANGED
;
2202 TRACE("Recreating Vulkan swapchain.\n");
2204 d3d12_swapchain_destroy_buffers(swapchain
, FALSE
);
2205 return d3d12_swapchain_recreate_vulkan_swapchain(swapchain
);
2208 ERR("Failed to acquire next Vulkan image, vr %d.\n", vr
);
2209 return hresult_from_vk_result(vr
);
2212 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_Present(IDXGISwapChain3
*iface
, UINT sync_interval
, UINT flags
)
2214 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain3(iface
);
2216 TRACE("iface %p, sync_interval %u, flags %#x.\n", iface
, sync_interval
, flags
);
2218 return d3d12_swapchain_present(swapchain
, sync_interval
, flags
);
2221 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetBuffer(IDXGISwapChain3
*iface
,
2222 UINT buffer_idx
, REFIID iid
, void **surface
)
2224 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain3(iface
);
2226 TRACE("iface %p, buffer_idx %u, iid %s, surface %p.\n",
2227 iface
, buffer_idx
, debugstr_guid(iid
), surface
);
2229 if (buffer_idx
>= swapchain
->desc
.BufferCount
)
2231 WARN("Invalid buffer index %u.\n", buffer_idx
);
2232 return DXGI_ERROR_INVALID_CALL
;
2235 assert(swapchain
->buffers
[buffer_idx
]);
2236 return ID3D12Resource_QueryInterface(swapchain
->buffers
[buffer_idx
], iid
, surface
);
2239 static HRESULT STDMETHODCALLTYPE DECLSPEC_HOTPATCH
d3d12_swapchain_SetFullscreenState(IDXGISwapChain3
*iface
,
2240 BOOL fullscreen
, IDXGIOutput
*target
)
2242 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain3(iface
);
2243 DXGI_SWAP_CHAIN_FULLSCREEN_DESC
*fullscreen_desc
= &swapchain
->fullscreen_desc
;
2244 const DXGI_SWAP_CHAIN_DESC1
*swapchain_desc
= &swapchain
->desc
;
2245 struct wined3d_swapchain_desc wined3d_desc
;
2246 HWND window
= swapchain
->window
;
2249 TRACE("iface %p, fullscreen %#x, target %p.\n", iface
, fullscreen
, target
);
2251 if (!fullscreen
&& target
)
2253 WARN("Invalid call.\n");
2254 return DXGI_ERROR_INVALID_CALL
;
2259 IDXGIOutput_AddRef(target
);
2261 else if (FAILED(hr
= IDXGISwapChain3_GetContainingOutput(iface
, &target
)))
2263 WARN("Failed to get target output for swapchain, hr %#x.\n", hr
);
2267 if (FAILED(hr
= wined3d_swapchain_desc_from_dxgi(&wined3d_desc
, window
, swapchain_desc
, fullscreen_desc
)))
2269 wined3d_mutex_lock();
2270 wined3d_desc
.windowed
= !fullscreen
;
2271 hr
= dxgi_swapchain_set_fullscreen_state(swapchain
->state
, &wined3d_desc
, target
);
2272 wined3d_mutex_unlock();
2276 fullscreen_desc
->Windowed
= wined3d_desc
.windowed
;
2279 IDXGIOutput_Release(target
);
2283 if (swapchain
->target
)
2284 IDXGIOutput_Release(swapchain
->target
);
2285 swapchain
->target
= target
;
2290 IDXGIOutput_Release(target
);
2292 return DXGI_ERROR_NOT_CURRENTLY_AVAILABLE
;
2295 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetFullscreenState(IDXGISwapChain3
*iface
,
2296 BOOL
*fullscreen
, IDXGIOutput
**target
)
2298 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain3(iface
);
2300 TRACE("iface %p, fullscreen %p, target %p.\n", iface
, fullscreen
, target
);
2303 *fullscreen
= !swapchain
->fullscreen_desc
.Windowed
;
2305 if (target
&& (*target
= swapchain
->target
))
2306 IDXGIOutput_AddRef(*target
);
2311 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetDesc(IDXGISwapChain3
*iface
, DXGI_SWAP_CHAIN_DESC
*desc
)
2313 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain3(iface
);
2314 const DXGI_SWAP_CHAIN_FULLSCREEN_DESC
*fullscreen_desc
= &swapchain
->fullscreen_desc
;
2315 const DXGI_SWAP_CHAIN_DESC1
*swapchain_desc
= &swapchain
->desc
;
2317 TRACE("iface %p, desc %p.\n", iface
, desc
);
2321 WARN("Invalid pointer.\n");
2322 return E_INVALIDARG
;
2325 desc
->BufferDesc
.Width
= swapchain_desc
->Width
;
2326 desc
->BufferDesc
.Height
= swapchain_desc
->Height
;
2327 desc
->BufferDesc
.RefreshRate
= fullscreen_desc
->RefreshRate
;
2328 desc
->BufferDesc
.Format
= swapchain_desc
->Format
;
2329 desc
->BufferDesc
.ScanlineOrdering
= fullscreen_desc
->ScanlineOrdering
;
2330 desc
->BufferDesc
.Scaling
= fullscreen_desc
->Scaling
;
2331 desc
->SampleDesc
= swapchain_desc
->SampleDesc
;
2332 desc
->BufferUsage
= swapchain_desc
->BufferUsage
;
2333 desc
->BufferCount
= swapchain_desc
->BufferCount
;
2334 desc
->OutputWindow
= swapchain
->window
;
2335 desc
->Windowed
= fullscreen_desc
->Windowed
;
2336 desc
->SwapEffect
= swapchain_desc
->SwapEffect
;
2337 desc
->Flags
= swapchain_desc
->Flags
;
2342 static HRESULT
d3d12_swapchain_resize_buffers(struct d3d12_swapchain
*swapchain
,
2343 UINT buffer_count
, UINT width
, UINT height
, DXGI_FORMAT format
, UINT flags
)
2345 DXGI_SWAP_CHAIN_DESC1
*desc
, new_desc
;
2350 FIXME("Ignoring flags %#x.\n", flags
);
2352 for (i
= 0; i
< swapchain
->desc
.BufferCount
; ++i
)
2354 ID3D12Resource_AddRef(swapchain
->buffers
[i
]);
2355 if ((refcount
= ID3D12Resource_Release(swapchain
->buffers
[i
])))
2357 WARN("Buffer %p has %u references left.\n", swapchain
->buffers
[i
], refcount
);
2358 return DXGI_ERROR_INVALID_CALL
;
2362 desc
= &swapchain
->desc
;
2363 new_desc
= swapchain
->desc
;
2366 new_desc
.BufferCount
= buffer_count
;
2367 if (!width
|| !height
)
2371 if (!GetClientRect(swapchain
->window
, &client_rect
))
2373 WARN("Failed to get client rect, last error %#x.\n", GetLastError());
2374 return DXGI_ERROR_INVALID_CALL
;
2378 width
= client_rect
.right
;
2380 height
= client_rect
.bottom
;
2382 new_desc
.Width
= width
;
2383 new_desc
.Height
= height
;
2386 new_desc
.Format
= format
;
2388 if (!dxgi_validate_swapchain_desc(&new_desc
))
2389 return DXGI_ERROR_INVALID_CALL
;
2391 if (desc
->Width
== new_desc
.Width
&& desc
->Height
== new_desc
.Height
2392 && desc
->Format
== new_desc
.Format
&& desc
->BufferCount
== new_desc
.BufferCount
)
2395 d3d12_swapchain_destroy_buffers(swapchain
, TRUE
);
2396 swapchain
->desc
= new_desc
;
2397 return d3d12_swapchain_recreate_vulkan_swapchain(swapchain
);
2400 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_ResizeBuffers(IDXGISwapChain3
*iface
,
2401 UINT buffer_count
, UINT width
, UINT height
, DXGI_FORMAT format
, UINT flags
)
2403 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain3(iface
);
2405 TRACE("iface %p, buffer_count %u, width %u, height %u, format %s, flags %#x.\n",
2406 iface
, buffer_count
, width
, height
, debug_dxgi_format(format
), flags
);
2408 return d3d12_swapchain_resize_buffers(swapchain
, buffer_count
, width
, height
, format
, flags
);
2411 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_ResizeTarget(IDXGISwapChain3
*iface
,
2412 const DXGI_MODE_DESC
*target_mode_desc
)
2414 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain3(iface
);
2416 TRACE("iface %p, target_mode_desc %p.\n", iface
, target_mode_desc
);
2418 return dxgi_swapchain_resize_target((IDXGISwapChain1
*)iface
, swapchain
->state
, target_mode_desc
);
2421 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetContainingOutput(IDXGISwapChain3
*iface
,
2422 IDXGIOutput
**output
)
2424 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain3(iface
);
2425 IUnknown
*device_parent
;
2426 IDXGIAdapter
*adapter
;
2429 TRACE("iface %p, output %p.\n", iface
, output
);
2431 if (swapchain
->target
)
2433 IDXGIOutput_AddRef(*output
= swapchain
->target
);
2437 device_parent
= vkd3d_get_device_parent(swapchain
->device
);
2439 if (SUCCEEDED(hr
= IUnknown_QueryInterface(device_parent
, &IID_IDXGIAdapter
, (void **)&adapter
)))
2441 hr
= dxgi_get_output_from_window(adapter
, swapchain
->window
, output
);
2442 IDXGIAdapter_Release(adapter
);
2446 WARN("Failed to get adapter, hr %#x.\n", hr
);
2452 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetFrameStatistics(IDXGISwapChain3
*iface
,
2453 DXGI_FRAME_STATISTICS
*stats
)
2455 FIXME("iface %p, stats %p stub!\n", iface
, stats
);
2460 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetLastPresentCount(IDXGISwapChain3
*iface
,
2461 UINT
*last_present_count
)
2463 FIXME("iface %p, last_present_count %p stub!\n", iface
, last_present_count
);
2468 /* IDXGISwapChain1 methods */
2470 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetDesc1(IDXGISwapChain3
*iface
, DXGI_SWAP_CHAIN_DESC1
*desc
)
2472 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain3(iface
);
2474 TRACE("iface %p, desc %p.\n", iface
, desc
);
2478 WARN("Invalid pointer.\n");
2479 return E_INVALIDARG
;
2482 *desc
= swapchain
->desc
;
2486 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetFullscreenDesc(IDXGISwapChain3
*iface
,
2487 DXGI_SWAP_CHAIN_FULLSCREEN_DESC
*desc
)
2489 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain3(iface
);
2491 TRACE("iface %p, desc %p.\n", iface
, desc
);
2495 WARN("Invalid pointer.\n");
2496 return E_INVALIDARG
;
2499 *desc
= swapchain
->fullscreen_desc
;
2503 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetHwnd(IDXGISwapChain3
*iface
, HWND
*hwnd
)
2505 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain3(iface
);
2507 TRACE("iface %p, hwnd %p.\n", iface
, hwnd
);
2511 WARN("Invalid pointer.\n");
2512 return DXGI_ERROR_INVALID_CALL
;
2515 *hwnd
= swapchain
->window
;
2519 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetCoreWindow(IDXGISwapChain3
*iface
,
2520 REFIID iid
, void **core_window
)
2522 FIXME("iface %p, iid %s, core_window %p stub!\n", iface
, debugstr_guid(iid
), core_window
);
2525 *core_window
= NULL
;
2527 return DXGI_ERROR_INVALID_CALL
;
2530 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_Present1(IDXGISwapChain3
*iface
,
2531 UINT sync_interval
, UINT flags
, const DXGI_PRESENT_PARAMETERS
*present_parameters
)
2533 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain3(iface
);
2535 TRACE("iface %p, sync_interval %u, flags %#x, present_parameters %p.\n",
2536 iface
, sync_interval
, flags
, present_parameters
);
2538 if (present_parameters
)
2539 FIXME("Ignored present parameters %p.\n", present_parameters
);
2541 return d3d12_swapchain_present(swapchain
, sync_interval
, flags
);
2544 static BOOL STDMETHODCALLTYPE
d3d12_swapchain_IsTemporaryMonoSupported(IDXGISwapChain3
*iface
)
2546 FIXME("iface %p stub!\n", iface
);
2551 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetRestrictToOutput(IDXGISwapChain3
*iface
, IDXGIOutput
**output
)
2553 FIXME("iface %p, output %p stub!\n", iface
, output
);
2557 WARN("Invalid pointer.\n");
2558 return E_INVALIDARG
;
2565 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_SetBackgroundColor(IDXGISwapChain3
*iface
, const DXGI_RGBA
*color
)
2567 FIXME("iface %p, color %p stub!\n", iface
, color
);
2572 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetBackgroundColor(IDXGISwapChain3
*iface
, DXGI_RGBA
*color
)
2574 FIXME("iface %p, color %p stub!\n", iface
, color
);
2579 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_SetRotation(IDXGISwapChain3
*iface
, DXGI_MODE_ROTATION rotation
)
2581 FIXME("iface %p, rotation %#x stub!\n", iface
, rotation
);
2586 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetRotation(IDXGISwapChain3
*iface
, DXGI_MODE_ROTATION
*rotation
)
2588 FIXME("iface %p, rotation %p stub!\n", iface
, rotation
);
2593 /* IDXGISwapChain2 methods */
2595 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_SetSourceSize(IDXGISwapChain3
*iface
, UINT width
, UINT height
)
2597 FIXME("iface %p, width %u, height %u stub!\n", iface
, width
, height
);
2602 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetSourceSize(IDXGISwapChain3
*iface
, UINT
*width
, UINT
*height
)
2604 FIXME("iface %p, width %p, height %p stub!\n", iface
, width
, height
);
2609 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_SetMaximumFrameLatency(IDXGISwapChain3
*iface
, UINT max_latency
)
2611 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain3(iface
);
2613 TRACE("iface %p, max_latency %u.\n", iface
, max_latency
);
2615 if (!(swapchain
->desc
.Flags
& DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT
))
2617 WARN("DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT not set for swap chain %p.\n", iface
);
2618 return DXGI_ERROR_INVALID_CALL
;
2623 WARN("Invalid maximum frame latency %u.\n", max_latency
);
2624 return DXGI_ERROR_INVALID_CALL
;
2627 swapchain
->frame_latency
= max_latency
;
2631 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetMaximumFrameLatency(IDXGISwapChain3
*iface
, UINT
*max_latency
)
2633 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain3(iface
);
2635 TRACE("iface %p, max_latency %p.\n", iface
, max_latency
);
2637 if (!(swapchain
->desc
.Flags
& DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT
))
2639 WARN("DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT not set for swap chain %p.\n", iface
);
2640 return DXGI_ERROR_INVALID_CALL
;
2643 *max_latency
= swapchain
->frame_latency
;
2647 static HANDLE STDMETHODCALLTYPE
d3d12_swapchain_GetFrameLatencyWaitableObject(IDXGISwapChain3
*iface
)
2649 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain3(iface
);
2651 TRACE("iface %p.\n", iface
);
2653 return swapchain
->frame_latency_event
;
2656 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_SetMatrixTransform(IDXGISwapChain3
*iface
,
2657 const DXGI_MATRIX_3X2_F
*matrix
)
2659 FIXME("iface %p, matrix %p stub!\n", iface
, matrix
);
2664 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_GetMatrixTransform(IDXGISwapChain3
*iface
,
2665 DXGI_MATRIX_3X2_F
*matrix
)
2667 FIXME("iface %p, matrix %p stub!\n", iface
, matrix
);
2672 /* IDXGISwapChain3 methods */
2674 static UINT STDMETHODCALLTYPE
d3d12_swapchain_GetCurrentBackBufferIndex(IDXGISwapChain3
*iface
)
2676 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain3(iface
);
2678 TRACE("iface %p.\n", iface
);
2680 TRACE("Current back buffer index %u.\n", swapchain
->current_buffer_index
);
2681 assert(swapchain
->current_buffer_index
< swapchain
->desc
.BufferCount
);
2682 return swapchain
->current_buffer_index
;
2685 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_CheckColorSpaceSupport(IDXGISwapChain3
*iface
,
2686 DXGI_COLOR_SPACE_TYPE colour_space
, UINT
*colour_space_support
)
2688 UINT support_flags
= 0;
2690 FIXME("iface %p, colour_space %#x, colour_space_support %p semi-stub!\n",
2691 iface
, colour_space
, colour_space_support
);
2693 if (!colour_space_support
)
2694 return E_INVALIDARG
;
2696 if (colour_space
== DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709
)
2697 support_flags
|= DXGI_SWAP_CHAIN_COLOR_SPACE_SUPPORT_FLAG_PRESENT
;
2699 *colour_space_support
= support_flags
;
2703 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_SetColorSpace1(IDXGISwapChain3
*iface
,
2704 DXGI_COLOR_SPACE_TYPE colour_space
)
2706 FIXME("iface %p, colour_space %#x semi-stub!\n", iface
, colour_space
);
2708 if (colour_space
!= DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709
)
2710 WARN("Colour space %u not supported.\n", colour_space
);
2711 return E_INVALIDARG
;
2717 static HRESULT STDMETHODCALLTYPE
d3d12_swapchain_ResizeBuffers1(IDXGISwapChain3
*iface
,
2718 UINT buffer_count
, UINT width
, UINT height
, DXGI_FORMAT format
, UINT flags
,
2719 const UINT
*node_mask
, IUnknown
* const *present_queue
)
2721 struct d3d12_swapchain
*swapchain
= d3d12_swapchain_from_IDXGISwapChain3(iface
);
2724 TRACE("iface %p, buffer_count %u, width %u, height %u, format %s, flags %#x, "
2725 "node_mask %p, present_queue %p.\n",
2726 iface
, buffer_count
, width
, height
, debug_dxgi_format(format
), flags
, node_mask
, present_queue
);
2728 if (!node_mask
|| !present_queue
)
2729 return DXGI_ERROR_INVALID_CALL
;
2731 count
= buffer_count
? buffer_count
: swapchain
->desc
.BufferCount
;
2732 for (i
= 0; i
< count
; ++i
)
2734 if (node_mask
[i
] > 1 || !present_queue
[i
])
2735 return DXGI_ERROR_INVALID_CALL
;
2736 if ((ID3D12CommandQueue
*)present_queue
[i
] != swapchain
->command_queue
)
2737 FIXME("Ignoring present queue %p.\n", present_queue
[i
]);
2740 return d3d12_swapchain_resize_buffers(swapchain
, buffer_count
, width
, height
, format
, flags
);
2743 static const struct IDXGISwapChain3Vtbl d3d12_swapchain_vtbl
=
2745 /* IUnknown methods */
2746 d3d12_swapchain_QueryInterface
,
2747 d3d12_swapchain_AddRef
,
2748 d3d12_swapchain_Release
,
2749 /* IDXGIObject methods */
2750 d3d12_swapchain_SetPrivateData
,
2751 d3d12_swapchain_SetPrivateDataInterface
,
2752 d3d12_swapchain_GetPrivateData
,
2753 d3d12_swapchain_GetParent
,
2754 /* IDXGIDeviceSubObject methods */
2755 d3d12_swapchain_GetDevice
,
2756 /* IDXGISwapChain methods */
2757 d3d12_swapchain_Present
,
2758 d3d12_swapchain_GetBuffer
,
2759 d3d12_swapchain_SetFullscreenState
,
2760 d3d12_swapchain_GetFullscreenState
,
2761 d3d12_swapchain_GetDesc
,
2762 d3d12_swapchain_ResizeBuffers
,
2763 d3d12_swapchain_ResizeTarget
,
2764 d3d12_swapchain_GetContainingOutput
,
2765 d3d12_swapchain_GetFrameStatistics
,
2766 d3d12_swapchain_GetLastPresentCount
,
2767 /* IDXGISwapChain1 methods */
2768 d3d12_swapchain_GetDesc1
,
2769 d3d12_swapchain_GetFullscreenDesc
,
2770 d3d12_swapchain_GetHwnd
,
2771 d3d12_swapchain_GetCoreWindow
,
2772 d3d12_swapchain_Present1
,
2773 d3d12_swapchain_IsTemporaryMonoSupported
,
2774 d3d12_swapchain_GetRestrictToOutput
,
2775 d3d12_swapchain_SetBackgroundColor
,
2776 d3d12_swapchain_GetBackgroundColor
,
2777 d3d12_swapchain_SetRotation
,
2778 d3d12_swapchain_GetRotation
,
2779 /* IDXGISwapChain2 methods */
2780 d3d12_swapchain_SetSourceSize
,
2781 d3d12_swapchain_GetSourceSize
,
2782 d3d12_swapchain_SetMaximumFrameLatency
,
2783 d3d12_swapchain_GetMaximumFrameLatency
,
2784 d3d12_swapchain_GetFrameLatencyWaitableObject
,
2785 d3d12_swapchain_SetMatrixTransform
,
2786 d3d12_swapchain_GetMatrixTransform
,
2787 /* IDXGISwapChain3 methods */
2788 d3d12_swapchain_GetCurrentBackBufferIndex
,
2789 d3d12_swapchain_CheckColorSpaceSupport
,
2790 d3d12_swapchain_SetColorSpace1
,
2791 d3d12_swapchain_ResizeBuffers1
,
2794 static BOOL
load_vkd3d_functions(void *vkd3d_handle
)
2796 #define LOAD_FUNCPTR(f) if (!(f = get_library_proc(vkd3d_handle, #f))) return FALSE;
2797 LOAD_FUNCPTR(vkd3d_acquire_vk_queue
)
2798 LOAD_FUNCPTR(vkd3d_create_image_resource
)
2799 LOAD_FUNCPTR(vkd3d_get_device_parent
)
2800 LOAD_FUNCPTR(vkd3d_get_vk_device
)
2801 LOAD_FUNCPTR(vkd3d_get_vk_format
)
2802 LOAD_FUNCPTR(vkd3d_get_vk_physical_device
)
2803 LOAD_FUNCPTR(vkd3d_get_vk_queue_family_index
)
2804 LOAD_FUNCPTR(vkd3d_instance_from_device
)
2805 LOAD_FUNCPTR(vkd3d_instance_get_vk_instance
)
2806 LOAD_FUNCPTR(vkd3d_release_vk_queue
)
2807 LOAD_FUNCPTR(vkd3d_resource_decref
)
2808 LOAD_FUNCPTR(vkd3d_resource_incref
)
2814 static void *vkd3d_handle
;
2816 static BOOL WINAPI
init_vkd3d_once(INIT_ONCE
*once
, void *param
, void **context
)
2818 TRACE("Loading vkd3d %s.\n", SONAME_LIBVKD3D
);
2820 if (!(vkd3d_handle
= load_library(SONAME_LIBVKD3D
)))
2823 if (!load_vkd3d_functions(vkd3d_handle
))
2825 ERR("Failed to load vkd3d functions.\n");
2826 close_library(vkd3d_handle
);
2827 vkd3d_handle
= NULL
;
2834 static BOOL
init_vkd3d(void)
2836 static INIT_ONCE init_once
= INIT_ONCE_STATIC_INIT
;
2837 InitOnceExecuteOnce(&init_once
, init_vkd3d_once
, NULL
, NULL
);
2838 return !!vkd3d_handle
;
2841 static BOOL
init_vk_funcs(struct dxgi_vk_funcs
*dxgi
, VkInstance vk_instance
, VkDevice vk_device
)
2843 PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr
;
2844 PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr
;
2846 dxgi
->vulkan_module
= NULL
;
2848 if (!(vkGetInstanceProcAddr
= load_vulkan(&dxgi
->vulkan_module
)))
2850 ERR_(winediag
)("Failed to load Vulkan.\n");
2854 vkGetDeviceProcAddr
= (void *)vkGetInstanceProcAddr(vk_instance
, "vkGetDeviceProcAddr");
2856 #define LOAD_INSTANCE_PFN(name) \
2857 if (!(dxgi->p_##name = (void *)vkGetInstanceProcAddr(vk_instance, #name))) \
2859 ERR("Failed to get instance proc "#name".\n"); \
2860 close_library(dxgi->vulkan_module); \
2863 LOAD_INSTANCE_PFN(vkCreateWin32SurfaceKHR
)
2864 LOAD_INSTANCE_PFN(vkDestroySurfaceKHR
)
2865 LOAD_INSTANCE_PFN(vkGetPhysicalDeviceMemoryProperties
)
2866 LOAD_INSTANCE_PFN(vkGetPhysicalDeviceSurfaceCapabilitiesKHR
)
2867 LOAD_INSTANCE_PFN(vkGetPhysicalDeviceSurfaceFormatsKHR
)
2868 LOAD_INSTANCE_PFN(vkGetPhysicalDeviceSurfacePresentModesKHR
)
2869 LOAD_INSTANCE_PFN(vkGetPhysicalDeviceSurfaceSupportKHR
)
2870 LOAD_INSTANCE_PFN(vkGetPhysicalDeviceWin32PresentationSupportKHR
)
2871 #undef LOAD_INSTANCE_PFN
2873 #define LOAD_DEVICE_PFN(name) \
2874 if (!(dxgi->p_##name = (void *)vkGetDeviceProcAddr(vk_device, #name))) \
2876 ERR("Failed to get device proc "#name".\n"); \
2877 close_library(dxgi->vulkan_module); \
2880 LOAD_DEVICE_PFN(vkAcquireNextImageKHR
)
2881 LOAD_DEVICE_PFN(vkAllocateCommandBuffers
)
2882 LOAD_DEVICE_PFN(vkAllocateMemory
)
2883 LOAD_DEVICE_PFN(vkBeginCommandBuffer
)
2884 LOAD_DEVICE_PFN(vkBindImageMemory
)
2885 LOAD_DEVICE_PFN(vkCmdBlitImage
)
2886 LOAD_DEVICE_PFN(vkCmdPipelineBarrier
)
2887 LOAD_DEVICE_PFN(vkCreateCommandPool
)
2888 LOAD_DEVICE_PFN(vkCreateFence
)
2889 LOAD_DEVICE_PFN(vkCreateImage
)
2890 LOAD_DEVICE_PFN(vkCreateSemaphore
)
2891 LOAD_DEVICE_PFN(vkCreateSwapchainKHR
)
2892 LOAD_DEVICE_PFN(vkDestroyCommandPool
)
2893 LOAD_DEVICE_PFN(vkDestroyFence
)
2894 LOAD_DEVICE_PFN(vkDestroyImage
)
2895 LOAD_DEVICE_PFN(vkDestroySemaphore
)
2896 LOAD_DEVICE_PFN(vkDestroySwapchainKHR
)
2897 LOAD_DEVICE_PFN(vkEndCommandBuffer
)
2898 LOAD_DEVICE_PFN(vkFreeMemory
)
2899 LOAD_DEVICE_PFN(vkResetCommandBuffer
)
2900 LOAD_DEVICE_PFN(vkGetImageMemoryRequirements
)
2901 LOAD_DEVICE_PFN(vkGetSwapchainImagesKHR
)
2902 LOAD_DEVICE_PFN(vkQueuePresentKHR
)
2903 LOAD_DEVICE_PFN(vkQueueSubmit
)
2904 LOAD_DEVICE_PFN(vkQueueWaitIdle
)
2905 LOAD_DEVICE_PFN(vkResetFences
)
2906 LOAD_DEVICE_PFN(vkWaitForFences
)
2907 #undef LOAD_DEVICE_PFN
2912 static HRESULT
d3d12_swapchain_init(struct d3d12_swapchain
*swapchain
, IWineDXGIFactory
*factory
,
2913 ID3D12Device
*device
, ID3D12CommandQueue
*queue
, HWND window
,
2914 const DXGI_SWAP_CHAIN_DESC1
*swapchain_desc
, const DXGI_SWAP_CHAIN_FULLSCREEN_DESC
*fullscreen_desc
)
2916 const struct dxgi_vk_funcs
*vk_funcs
= &swapchain
->vk_funcs
;
2917 struct wined3d_swapchain_desc wined3d_desc
;
2918 VkWin32SurfaceCreateInfoKHR surface_desc
;
2919 VkPhysicalDevice vk_physical_device
;
2920 struct dxgi_adapter
*dxgi_adapter
;
2921 VkFenceCreateInfo fence_desc
;
2922 uint32_t queue_family_index
;
2923 VkSurfaceKHR vk_surface
;
2924 IUnknown
*device_parent
;
2925 VkInstance vk_instance
;
2926 IDXGIAdapter
*adapter
;
2933 if (window
== GetDesktopWindow())
2935 WARN("D3D12 swapchain cannot be created on desktop window.\n");
2936 return E_ACCESSDENIED
;
2939 swapchain
->IDXGISwapChain3_iface
.lpVtbl
= &d3d12_swapchain_vtbl
;
2940 swapchain
->refcount
= 1;
2942 swapchain
->window
= window
;
2943 swapchain
->desc
= *swapchain_desc
;
2944 swapchain
->fullscreen_desc
= *fullscreen_desc
;
2946 swapchain
->present_mode
= VK_PRESENT_MODE_FIFO_KHR
;
2948 switch (swapchain_desc
->SwapEffect
)
2950 case DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL
:
2951 case DXGI_SWAP_EFFECT_FLIP_DISCARD
:
2952 FIXME("Ignoring swap effect %#x.\n", swapchain_desc
->SwapEffect
);
2955 WARN("Invalid swap effect %#x.\n", swapchain_desc
->SwapEffect
);
2956 return DXGI_ERROR_INVALID_CALL
;
2961 ERR_(winediag
)("libvkd3d could not be loaded.\n");
2962 return DXGI_ERROR_UNSUPPORTED
;
2965 device_parent
= vkd3d_get_device_parent(device
);
2966 if (FAILED(hr
= IUnknown_QueryInterface(device_parent
, &IID_IDXGIAdapter
, (void **)&adapter
)))
2968 dxgi_adapter
= unsafe_impl_from_IDXGIAdapter(adapter
);
2969 IDXGIAdapter_Release(adapter
);
2970 if (FAILED(hr
= wined3d_swapchain_desc_from_dxgi(&wined3d_desc
, window
, swapchain_desc
, fullscreen_desc
)))
2972 if (FAILED(hr
= wined3d_swapchain_state_create(&wined3d_desc
, window
,
2973 dxgi_adapter
->factory
->wined3d
, &swapchain
->state
)))
2976 if (swapchain_desc
->BufferUsage
&& swapchain_desc
->BufferUsage
!= DXGI_USAGE_RENDER_TARGET_OUTPUT
)
2977 FIXME("Ignoring buffer usage %#x.\n", swapchain_desc
->BufferUsage
);
2978 if (swapchain_desc
->Scaling
!= DXGI_SCALING_STRETCH
&& swapchain_desc
->Scaling
!= DXGI_SCALING_NONE
)
2979 FIXME("Ignoring scaling %#x.\n", swapchain_desc
->Scaling
);
2980 if (swapchain_desc
->AlphaMode
&& swapchain_desc
->AlphaMode
!= DXGI_ALPHA_MODE_IGNORE
)
2981 FIXME("Ignoring alpha mode %#x.\n", swapchain_desc
->AlphaMode
);
2982 if (swapchain_desc
->Flags
& ~(DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT
))
2983 FIXME("Ignoring swapchain flags %#x.\n", swapchain_desc
->Flags
);
2985 if (fullscreen_desc
->RefreshRate
.Numerator
|| fullscreen_desc
->RefreshRate
.Denominator
)
2986 FIXME("Ignoring refresh rate.\n");
2987 if (fullscreen_desc
->ScanlineOrdering
)
2988 FIXME("Unhandled scanline ordering %#x.\n", fullscreen_desc
->ScanlineOrdering
);
2989 if (fullscreen_desc
->Scaling
)
2990 FIXME("Unhandled mode scaling %#x.\n", fullscreen_desc
->Scaling
);
2991 if (!fullscreen_desc
->Windowed
)
2992 FIXME("Fullscreen not supported yet.\n");
2994 vk_instance
= vkd3d_instance_get_vk_instance(vkd3d_instance_from_device(device
));
2995 vk_physical_device
= vkd3d_get_vk_physical_device(device
);
2996 vk_device
= vkd3d_get_vk_device(device
);
2998 swapchain
->vk_instance
= vk_instance
;
2999 swapchain
->vk_device
= vk_device
;
3000 swapchain
->vk_physical_device
= vk_physical_device
;
3002 if (!init_vk_funcs(&swapchain
->vk_funcs
, vk_instance
, vk_device
))
3004 wined3d_swapchain_state_destroy(swapchain
->state
);
3008 wined3d_private_store_init(&swapchain
->private_store
);
3010 surface_desc
.sType
= VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR
;
3011 surface_desc
.pNext
= NULL
;
3012 surface_desc
.flags
= 0;
3013 surface_desc
.hinstance
= GetModuleHandleA("dxgi.dll");
3014 surface_desc
.hwnd
= window
;
3015 if ((vr
= vk_funcs
->p_vkCreateWin32SurfaceKHR(vk_instance
, &surface_desc
, NULL
, &vk_surface
)) < 0)
3017 WARN("Failed to create Vulkan surface, vr %d.\n", vr
);
3018 d3d12_swapchain_destroy(swapchain
);
3019 return hresult_from_vk_result(vr
);
3021 swapchain
->vk_surface
= vk_surface
;
3023 queue_family_index
= vkd3d_get_vk_queue_family_index(queue
);
3024 if ((vr
= vk_funcs
->p_vkGetPhysicalDeviceSurfaceSupportKHR(vk_physical_device
,
3025 queue_family_index
, vk_surface
, &supported
)) < 0 || !supported
)
3027 FIXME("Queue family does not support presentation, vr %d.\n", vr
);
3028 d3d12_swapchain_destroy(swapchain
);
3029 return DXGI_ERROR_UNSUPPORTED
;
3032 ID3D12CommandQueue_AddRef(swapchain
->command_queue
= queue
);
3033 ID3D12Device_AddRef(swapchain
->device
= device
);
3035 if (FAILED(hr
= d3d12_swapchain_create_vulkan_swapchain(swapchain
)))
3037 d3d12_swapchain_destroy(swapchain
);
3041 fence_desc
.sType
= VK_STRUCTURE_TYPE_FENCE_CREATE_INFO
;
3042 fence_desc
.pNext
= NULL
;
3043 fence_desc
.flags
= 0;
3044 if ((vr
= vk_funcs
->p_vkCreateFence(vk_device
, &fence_desc
, NULL
, &vk_fence
)) < 0)
3046 WARN("Failed to create Vulkan fence, vr %d.\n", vr
);
3047 d3d12_swapchain_destroy(swapchain
);
3048 return hresult_from_vk_result(vr
);
3050 swapchain
->vk_fence
= vk_fence
;
3052 swapchain
->current_buffer_index
= 0;
3053 if ((vr
= d3d12_swapchain_acquire_next_back_buffer(swapchain
)) < 0)
3055 d3d12_swapchain_destroy(swapchain
);
3056 return hresult_from_vk_result(vr
);
3059 if (swapchain_desc
->Flags
& DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT
)
3061 swapchain
->frame_number
= DXGI_MAX_SWAP_CHAIN_BUFFERS
;
3062 swapchain
->frame_latency
= 1;
3064 if (FAILED(hr
= ID3D12Device_CreateFence(device
, DXGI_MAX_SWAP_CHAIN_BUFFERS
,
3065 0, &IID_ID3D12Fence
, (void **)&swapchain
->frame_latency_fence
)))
3067 WARN("Failed to create frame latency fence, hr %#x.\n", hr
);
3068 d3d12_swapchain_destroy(swapchain
);
3072 if (!(swapchain
->frame_latency_event
= CreateEventW(NULL
, FALSE
, TRUE
, NULL
)))
3074 hr
= HRESULT_FROM_WIN32(GetLastError());
3075 WARN("Failed to create frame latency event, hr %#x.\n", hr
);
3076 d3d12_swapchain_destroy(swapchain
);
3081 IWineDXGIFactory_AddRef(swapchain
->factory
= factory
);
3086 HRESULT
d3d12_swapchain_create(IWineDXGIFactory
*factory
, ID3D12CommandQueue
*queue
, HWND window
,
3087 const DXGI_SWAP_CHAIN_DESC1
*swapchain_desc
, const DXGI_SWAP_CHAIN_FULLSCREEN_DESC
*fullscreen_desc
,
3088 IDXGISwapChain1
**swapchain
)
3090 DXGI_SWAP_CHAIN_FULLSCREEN_DESC default_fullscreen_desc
;
3091 struct d3d12_swapchain
*object
;
3092 ID3D12Device
*device
;
3095 if (swapchain_desc
->Format
== DXGI_FORMAT_UNKNOWN
)
3096 return DXGI_ERROR_INVALID_CALL
;
3098 if (!fullscreen_desc
)
3100 memset(&default_fullscreen_desc
, 0, sizeof(default_fullscreen_desc
));
3101 default_fullscreen_desc
.Windowed
= TRUE
;
3102 fullscreen_desc
= &default_fullscreen_desc
;
3105 if (!(object
= heap_alloc_zero(sizeof(*object
))))
3106 return E_OUTOFMEMORY
;
3108 if (FAILED(hr
= ID3D12CommandQueue_GetDevice(queue
, &IID_ID3D12Device
, (void **)&device
)))
3110 ERR("Failed to get D3D12 device, hr %#x.\n", hr
);
3115 hr
= d3d12_swapchain_init(object
, factory
, device
, queue
, window
, swapchain_desc
, fullscreen_desc
);
3116 ID3D12Device_Release(device
);
3123 TRACE("Created swapchain %p.\n", object
);
3125 *swapchain
= (IDXGISwapChain1
*)&object
->IDXGISwapChain3_iface
;
3132 HRESULT
d3d12_swapchain_create(IWineDXGIFactory
*factory
, ID3D12CommandQueue
*queue
, HWND window
,
3133 const DXGI_SWAP_CHAIN_DESC1
*swapchain_desc
, const DXGI_SWAP_CHAIN_FULLSCREEN_DESC
*fullscreen_desc
,
3134 IDXGISwapChain1
**swapchain
)
3136 ERR_(winediag
)("Wine was built without Direct3D 12 support.\n");
3137 return DXGI_ERROR_UNSUPPORTED
;
3140 #endif /* SONAME_LIBVKD3D */