[PATCH v52 0/11] MR10567: wined3d: fix SRGB RTV fail for UNORM swapchain backbuffers > 1 for d3d10/11
wined3d: fix vk swapchain rendering too dark by supporting UNORM to SRGB conversion for brightness similar to gl This merge request addresses: https://bugs.winehq.org/show_bug.cgi?id=45364 Frostpunk is very dark Very dark rendering issues for Frostpunk seem to match the same problem for Vulkan renderer for "Against the Storm": - https://bugs.winehq.org/show_bug.cgi?id=58632 - https://bugs.winehq.org/attachment.cgi?id=80656 Running both games with gl renderer seems to fix excessive darkness: - https://bugs.winehq.org/attachment.cgi?id=80654 - https://bugs.winehq.org/attachment.cgi?id=80690 Vulkan renderer seems to be missing SRGB conversion handling availiable for GL renderer. GL renderer can be forced to render darker the same as Vulkan by bypassing EXT_TEXTURE_SRGB support for ./dlls/wined3d/utils.c: ``` @@ -3133,7 +3146,7 @@ static BOOL init_format_texture_info(struct wined3d_adapter *adapter, struct win continue; copy_format(adapter, &srgb_format->f, &format->f); +#if 000 if (gl_info->supported[EXT_TEXTURE_SRGB] && !(adapter->d3d_info.wined3d_creation_flags & WINED3D_SRGB_READ_WRITE_CONTROL)) { @@ -3142,6 +3155,7 @@ static BOOL init_format_texture_info(struct wined3d_adapter *adapter, struct win format_set_caps(&srgb_format->f, WINED3D_FORMAT_CAP_SRGB_READ | WINED3D_FORMAT_CAP_SRGB_WRITE); query_internal_format(adapter, srgb_format, &format_texture_info[i], gl_info, TRUE); } +#endif } ``` This merge request patch allows Vulkan renderer to perform SRGB conversion for wined3d_swapchain_vk_select_vk_format() to mimic the GL capability. Changing VkSwapchainCreateInfoKHR imageColorSpace from VK_COLOR_SPACE_SRGB_NONLINEAR_KHR for `wined3d_swapchain_vk_create_vulkan_swapchain()` had no effect despite enabling VK_EXT_swapchain_colorspace for dlls/win32u/vulkan.c `convert_instance_create_info():` https://docs.vulkan.org/refpages/latest/refpages/source/VkColorSpaceKHR.html Therefore converting UNORM to SRGB was chosen similar to how the GL renderer seems to handle it: ``` static const struct wined3d_format_srgb_info format_srgb_info[] = { {WINED3DFMT_R8G8B8A8_UNORM_SRGB, WINED3DFMT_R8G8B8A8_UNORM}, {WINED3DFMT_BC1_UNORM_SRGB, WINED3DFMT_BC1_UNORM}, {WINED3DFMT_BC2_UNORM_SRGB, WINED3DFMT_BC2_UNORM}, {WINED3DFMT_BC3_UNORM_SRGB, WINED3DFMT_BC3_UNORM}, {WINED3DFMT_B8G8R8A8_UNORM_SRGB, WINED3DFMT_B8G8R8A8_UNORM}, {WINED3DFMT_B8G8R8X8_UNORM_SRGB, WINED3DFMT_B8G8R8X8_UNORM}, {WINED3DFMT_BC7_UNORM_SRGB, WINED3DFMT_BC7_UNORM}, }; ``` Its unclear whether SRGB conversion should always happen or only for particular games so the patch leaves the Vulkan renderer without SRGB conversion by default. Therefore the patch adds a new WINE_D3D_CONFIG flag named "vk_swap_srgb" to force the Vulkan renderer to perform SRGB conversion for the swapchain. By default vk_swap_srgb is set to FALSE or 0: `WINE_D3D_CONFIG=vk_swap_srgb=0,renderer=vulkan` To force vk_swap_srgb to TRUE or 1: `WINE_D3D_CONFIG=vk_swap_srgb=1,renderer=vulkan` For example, launching Frostpunk via the following after the patch fixes the dark rendering for Vulkan and appears brighter similar to the GL renderer: `WINEDEBUG=-all mangohud --dlsym WINE_D3D_CONFIG=csmt=0x1,renderer=vulkan,vk_swap_srgb=1 WINEPREFIX=/home/any/wine_stianlow_wow64_new_pfx ~/tmp/wine_stianlow_wow64_new_install/bin/wine /home/any/wine_stianlow_wow64_new_pfx/drive_c/GOG\ Games/Frostpunk/Frostpunk.exe` Some SRGB handling was added several years ago but not for mapping UNORM to SRGB that this patch adds: ``` 6f55c8d1c56 * wined3d: Use an sRGB fallback format for sRGB formats in wined3d_swapchain_vk_select_vk_format(). Author: Henri Verbeet <hverbeet@codeweavers.com> CommitDate: Wed Dec 9 16:29:28 2020 +0100 ``` If UNORM to SRGB should be enabled by default then this patch may be changed so that vk_swap_srgb defaults to TRUE. -- v52: wined3d/tests: fix SRGB RTV UNORM swapchain backbuffers > 1 for d3d10/11 MR-10567 wined3d: gl fix texture2d_blt_fbo SRGB handling for MR-10567 wined3d: use wined3d_swapchain_rendertarget_view_gl_rotate for MR-10567 wined3d: impl wined3d_swapchain_rendertarget_view_gl for MR-10567 wined3d: use wined3d_swapchain_rendertarget_view_vk_rotate for MR-10567 wined3d: impl wined3d_swapchain_rendertarget_view_vk for MR-10567 wined3d: add wined3d_swapchain_rendertarget_view for MR-10567 wined3d: use impl D3D BACK_BUFFER_CAST for MR-10567 wined3d: impl D3D BACK_BUFFER_CAST for MR-10567 wined3d: add swapchain_from_resource for MR-10567 https://gitlab.winehq.org/wine/wine/-/merge_requests/10567
From: Stian Low <wineryyyyy@gmail.com> --- dlls/d3d10core/tests/d3d10core.c | 49 +++++++++++++++++++++++++++----- dlls/d3d11/tests/d3d11.c | 30 ++++++++++++++++--- 2 files changed, 68 insertions(+), 11 deletions(-) diff --git a/dlls/d3d10core/tests/d3d10core.c b/dlls/d3d10core/tests/d3d10core.c index a949b14837e..4735d271d74 100644 --- a/dlls/d3d10core/tests/d3d10core.c +++ b/dlls/d3d10core/tests/d3d10core.c @@ -11028,6 +11028,7 @@ static void test_swapchain_views(void) ID3D10RenderTargetView *rtv; ID3D10Device *device; ULONG refcount; + UINT flags; HRESULT hr; if (!init_test_context(&test_context)) @@ -11041,9 +11042,13 @@ static void test_swapchain_views(void) rtv_desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM_SRGB; rtv_desc.ViewDimension = D3D10_RTV_DIMENSION_TEXTURE2D; rtv_desc.Texture2D.MipSlice = 0; + + hr = ID3D10Device_CheckFormatSupport(device, rtv_desc.Format, &flags); + ok(SUCCEEDED(hr), "Got unexpected hr %#lx.\n", hr); hr = ID3D10Device_CreateRenderTargetView(device, (ID3D10Resource *)test_context.backbuffer, &rtv_desc, &rtv); - /* This seems to work only on Windows 7. */ - ok(hr == S_OK || broken(hr == E_INVALIDARG), "Failed to create render target view, hr %#lx.\n", hr); + flags &= D3D10_FORMAT_SUPPORT_BACK_BUFFER_CAST; + flags = (FAILED(hr) && !flags) || (SUCCEEDED(hr) && flags); + todo_wine ok(flags, "Got unexpected for SRGB rtv for UNORM swapchain, hr %#lx.\n", hr); if (SUCCEEDED(hr)) ID3D10RenderTargetView_Release(rtv); @@ -11061,12 +11066,14 @@ static void test_swapchain_views(void) static void test_swapchain_flip(void) { + ID3D10RenderTargetView *backbuffer_0_rtv, *backbuffer_0_rtv_srgb, *offscreen_rtv; ID3D10Texture2D *backbuffer_0, *backbuffer_1, *backbuffer_2, *offscreen; ID3D10ShaderResourceView *backbuffer_0_srv, *backbuffer_1_srv; - ID3D10RenderTargetView *backbuffer_0_rtv, *offscreen_rtv; + D3D10_RENDER_TARGET_VIEW_DESC rtv_desc; unsigned int color, stride, offset; D3D10_TEXTURE2D_DESC texture_desc; ID3D10InputLayout *input_layout; + struct swapchain_desc desc; IDXGISwapChain *swapchain; ID3D10VertexShader *vs; ID3D10PixelShader *ps; @@ -11074,6 +11081,7 @@ static void test_swapchain_flip(void) ID3D10Buffer *vb; ULONG refcount; HWND window; + UINT flags; HRESULT hr; RECT rect; @@ -11139,7 +11147,8 @@ static void test_swapchain_flip(void) static const float red[] = {1.0f, 0.0f, 0.0f, 0.5f}; static const float green[] = {0.0f, 1.0f, 0.0f, 0.5f}; static const float blue[] = {0.0f, 0.0f, 1.0f, 0.5f}; - struct swapchain_desc desc; + static const float grey[] = {0.5, 0.5f, 0.5f, 0.5f}; + if (!(device = create_device())) { @@ -11184,7 +11193,7 @@ static void test_swapchain_flip(void) ok(texture_desc.Usage == D3D10_USAGE_DEFAULT, "Got unexpected usage %u.\n", texture_desc.Usage); hr = ID3D10Device_CreateRenderTargetView(device, (ID3D10Resource *)backbuffer_1, NULL, &offscreen_rtv); - todo_wine ok(hr == E_INVALIDARG, "Got unexpected hr %#lx.\n", hr); + todo_wine ok(hr == E_INVALIDARG, "Got unexpected for rtv for swapchain backbuffer_1, hr %#lx.\n", hr); if (SUCCEEDED(hr)) ID3D10RenderTargetView_Release(offscreen_rtv); @@ -11227,11 +11236,30 @@ static void test_swapchain_flip(void) ok(SUCCEEDED(hr), "Failed to create pixel shader, hr %#lx.\n", hr); ID3D10Device_PSSetShader(device, ps); + /* Test SRGB rtv for UNORM swapchain common for Unity games for Win10 (bug #45364, MR #10567) */ + rtv_desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM_SRGB; + rtv_desc.ViewDimension = D3D10_RTV_DIMENSION_TEXTURE2D; + rtv_desc.Texture2D.MipSlice = 0; + hr = ID3D10Device_CheckFormatSupport(device, rtv_desc.Format, &flags); + ok(SUCCEEDED(hr), "Got unexpected hr %#lx.\n", hr); + hr = ID3D10Device_CreateRenderTargetView(device, (ID3D10Resource *)backbuffer_0, &rtv_desc, &backbuffer_0_rtv_srgb); + flags &= D3D10_FORMAT_SUPPORT_BACK_BUFFER_CAST; + flags = (FAILED(hr) && !flags) || (SUCCEEDED(hr) && flags); + todo_wine ok(flags, "Got unexpected for SRGB rtv for UNORM swapchain, hr %#lx.\n", hr); + if (SUCCEEDED(hr)) + { + ID3D10Device_ClearRenderTargetView(device, backbuffer_0_rtv_srgb, grey); + color = get_texture_color(backbuffer_0, 320, 240); /* red */ + todo_wine ok(compare_color(color, 0x80bcbcbc, 1), "Got unexpected srgb color 0x%08x.\n", color); + } + ID3D10Device_ClearRenderTargetView(device, backbuffer_0_rtv, red); ID3D10Device_Draw(device, 4, 0); - color = get_texture_color(offscreen, 120, 240); + color = get_texture_color(offscreen, 120, 240); /* red, buf 0 */ ok(compare_color(color, 0x7f0000ff, 1), "Got unexpected color 0x%08x.\n", color); + color = get_texture_color(offscreen, 320, 240); /* black (untouched default), buf 1 */ + ok(compare_color(color, 0x00000000, 1), "Got unexpected color 0x%08x.\n", color); /* DXGI moves buffers in the same direction as earlier versions. Buffer 2 becomes buffer 1, * buffer 1 becomes the new buffer 0, and buffer 0 becomes buffer n - 1. However, only buffer @@ -11247,12 +11275,17 @@ static void test_swapchain_flip(void) ID3D10Device_ClearRenderTargetView(device, backbuffer_0_rtv, green); ID3D10Device_Draw(device, 4, 0); + color = get_texture_color(offscreen, 120, 240); /* green, buf 0 */ ok(compare_color(color, 0x7f00ff00, 1), "Got unexpected color 0x%08x.\n", color); - /* Buffer 1 is still untouched. */ + color = get_texture_color(offscreen, 320, 240); /* black (untouched default), buf 1 */ + ok(compare_color(color, 0x00000000, 1), "Got unexpected color 0x%08x.\n", color); + /* Buffer 1 is still untouched. */ color = get_texture_color(backbuffer_0, 320, 240); /* green */ ok(compare_color(color, 0x7f00ff00, 1), "Got unexpected color 0x%08x.\n", color); + color = get_texture_color(backbuffer_1, 320, 240); /* black (untouched default) */ + ok(compare_color(color, 0x00000000, 1), "Got unexpected color 0x%08x.\n", color); color = get_texture_color(backbuffer_2, 320, 240); /* red */ ok(compare_color(color, 0x7f0000ff, 1), "Got unexpected color 0x%08x.\n", color); @@ -11280,6 +11313,8 @@ static void test_swapchain_flip(void) ID3D10ShaderResourceView_Release(backbuffer_0_srv); ID3D10ShaderResourceView_Release(backbuffer_1_srv); ID3D10RenderTargetView_Release(backbuffer_0_rtv); + if (backbuffer_0_rtv_srgb) + ID3D10RenderTargetView_Release(backbuffer_0_rtv_srgb); ID3D10RenderTargetView_Release(offscreen_rtv); ID3D10Texture2D_Release(offscreen); ID3D10Texture2D_Release(backbuffer_0); diff --git a/dlls/d3d11/tests/d3d11.c b/dlls/d3d11/tests/d3d11.c index 00ec3b0d2b9..76ef5f6bb98 100644 --- a/dlls/d3d11/tests/d3d11.c +++ b/dlls/d3d11/tests/d3d11.c @@ -16013,9 +16013,10 @@ static void test_swapchain_views(void) static void test_swapchain_flip(void) { + ID3D11RenderTargetView *backbuffer_0_rtv, *offscreen_rtv, *backbuffer_0_rtv_srgb; ID3D11Texture2D *backbuffer_0, *backbuffer_1, *backbuffer_2, *offscreen; ID3D11ShaderResourceView *backbuffer_0_srv, *backbuffer_1_srv; - ID3D11RenderTargetView *backbuffer_0_rtv, *offscreen_rtv; + D3D11_RENDER_TARGET_VIEW_DESC rtv_desc; D3D11_TEXTURE2D_DESC texture_desc; ID3D11InputLayout *input_layout; ID3D11DeviceContext *context; @@ -16029,6 +16030,7 @@ static void test_swapchain_flip(void) ULONG refcount; DWORD color; HWND window; + UINT flags; HRESULT hr; RECT rect; @@ -16094,6 +16096,7 @@ static void test_swapchain_flip(void) static const float red[] = {1.0f, 0.0f, 0.0f, 0.5f}; static const float green[] = {0.0f, 1.0f, 0.0f, 0.5f}; static const float blue[] = {0.0f, 0.0f, 1.0f, 0.5f}; + static const float grey[] = {0.5, 0.5f, 0.5f, 0.5f}; if (!(device = create_device(NULL))) { @@ -16118,6 +16121,8 @@ static void test_swapchain_flip(void) hr = IDXGISwapChain_GetBuffer(swapchain, 2, &IID_ID3D11Texture2D, (void **)&backbuffer_2); ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr); + ID3D11Device_GetImmediateContext(device, &context); + hr = ID3D11Device_CreateRenderTargetView(device, (ID3D11Resource *)backbuffer_0, NULL, &backbuffer_0_rtv); ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr); hr = ID3D11Device_CreateShaderResourceView(device, (ID3D11Resource *)backbuffer_0, NULL, &backbuffer_0_srv); @@ -16138,12 +16143,10 @@ static void test_swapchain_flip(void) ok(texture_desc.Usage == D3D11_USAGE_DEFAULT, "Got unexpected usage %u.\n", texture_desc.Usage); hr = ID3D11Device_CreateRenderTargetView(device, (ID3D11Resource *)backbuffer_1, NULL, &offscreen_rtv); - todo_wine ok(hr == E_INVALIDARG, "Got unexpected hr %#lx.\n", hr); + todo_wine ok(hr == E_INVALIDARG, "Got unexpected for rtv for swapchain backbuffer_1, hr %#lx.\n", hr); if (SUCCEEDED(hr)) ID3D11RenderTargetView_Release(offscreen_rtv); - ID3D11Device_GetImmediateContext(device, &context); - ID3D11DeviceContext_PSSetShaderResources(context, 0, 1, &backbuffer_0_srv); ID3D11DeviceContext_PSSetShaderResources(context, 1, 1, &backbuffer_1_srv); @@ -16183,6 +16186,23 @@ static void test_swapchain_flip(void) ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr); ID3D11DeviceContext_PSSetShader(context, ps, NULL, 0); + /* Test SRGB rtv for UNORM swapchain common for Unity games for Win10 (bug #45364, MR #10567) */ + rtv_desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM_SRGB; + hr = ID3D11Device_CheckFormatSupport(device, rtv_desc.Format, &flags); + ok(SUCCEEDED(hr), "Got unexpected hr %#lx.\n", hr); + rtv_desc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D; + rtv_desc.Texture2D.MipSlice = 0; + hr = ID3D11Device_CreateRenderTargetView(device, (ID3D11Resource *)backbuffer_0, &rtv_desc, &backbuffer_0_rtv_srgb); + flags &= D3D11_FORMAT_SUPPORT_BACK_BUFFER_CAST; + flags = (FAILED(hr) && !flags) || (SUCCEEDED(hr) && flags); + todo_wine ok(flags, "Got unexpected for SRGB rtv vs swapchain UNORM, hr %#lx.\n", hr); + if (SUCCEEDED(hr)) + { + ID3D11DeviceContext_ClearRenderTargetView(context, backbuffer_0_rtv_srgb, grey); + color = get_texture_color(backbuffer_0, 320, 240); /* grey */ + todo_wine ok(compare_color(color, 0x80bcbcbc, 1), "Got unexpected srgb color 0x%08lx.\n", color); + } + ID3D11DeviceContext_ClearRenderTargetView(context, backbuffer_0_rtv, red); ID3D11DeviceContext_Draw(context, 4, 0); @@ -16237,6 +16257,8 @@ static void test_swapchain_flip(void) ID3D11ShaderResourceView_Release(backbuffer_0_srv); ID3D11ShaderResourceView_Release(backbuffer_1_srv); ID3D11RenderTargetView_Release(backbuffer_0_rtv); + if (backbuffer_0_rtv_srgb) + ID3D11RenderTargetView_Release(backbuffer_0_rtv_srgb); ID3D11RenderTargetView_Release(offscreen_rtv); ID3D11Texture2D_Release(offscreen); ID3D11Texture2D_Release(backbuffer_0); -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/10567
From: Stian Low <wineryyyyy@gmail.com> --- dlls/wined3d/swapchain.c | 5 +++++ dlls/wined3d/wined3d.spec | 1 + dlls/wined3d/wined3d_private.h | 7 +++++++ include/wine/wined3d.h | 1 + 4 files changed, 14 insertions(+) diff --git a/dlls/wined3d/swapchain.c b/dlls/wined3d/swapchain.c index c26df770cdb..487b4c1d1ad 100644 --- a/dlls/wined3d/swapchain.c +++ b/dlls/wined3d/swapchain.c @@ -145,6 +145,11 @@ void wined3d_swapchain_vk_cleanup(struct wined3d_swapchain_vk *swapchain_vk) wined3d_swapchain_cleanup(&swapchain_vk->s); } +struct wined3d_swapchain * __cdecl wined3d_swapchain_from_resource(struct wined3d_resource *resource) +{ + return swapchain_from_resource(resource); +} + ULONG CDECL wined3d_swapchain_incref(struct wined3d_swapchain *swapchain) { unsigned int refcount = InterlockedIncrement(&swapchain->ref); diff --git a/dlls/wined3d/wined3d.spec b/dlls/wined3d/wined3d.spec index 735957c8777..98ff7fa4b38 100644 --- a/dlls/wined3d/wined3d.spec +++ b/dlls/wined3d/wined3d.spec @@ -296,6 +296,7 @@ @ cdecl wined3d_swapchain_create(ptr ptr ptr ptr ptr ptr) @ cdecl wined3d_swapchain_decref(ptr) +@ cdecl wined3d_swapchain_from_resource(ptr) @ cdecl wined3d_swapchain_get_back_buffer(ptr long) @ cdecl wined3d_swapchain_get_desc(ptr ptr) @ cdecl wined3d_swapchain_get_device(ptr) diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index e4e0cf24dc7..dfd353de84f 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -4123,6 +4123,13 @@ struct wined3d_swapchain void wined3d_swapchain_activate(struct wined3d_swapchain *swapchain, BOOL activate); void wined3d_swapchain_cleanup(struct wined3d_swapchain *swapchain); +static inline struct wined3d_swapchain *swapchain_from_resource(struct wined3d_resource *resource) +{ + if (!resource || resource->type != WINED3D_RTYPE_TEXTURE_2D) + return NULL; + + return texture_from_resource(resource)->swapchain; +} struct wined3d_output * wined3d_swapchain_get_output(const struct wined3d_swapchain *swapchain); void swapchain_update_draw_bindings(struct wined3d_swapchain *swapchain); void swapchain_set_max_frame_latency(struct wined3d_swapchain *swapchain, diff --git a/include/wine/wined3d.h b/include/wine/wined3d.h index 355140043db..a49b6885ad3 100644 --- a/include/wine/wined3d.h +++ b/include/wine/wined3d.h @@ -2898,6 +2898,7 @@ HRESULT __cdecl wined3d_swapchain_create(struct wined3d_device *device, void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_swapchain **swapchain); ULONG __cdecl wined3d_swapchain_decref(struct wined3d_swapchain *swapchain); +struct wined3d_swapchain * __cdecl wined3d_swapchain_from_resource(struct wined3d_resource *resource); struct wined3d_texture * __cdecl wined3d_swapchain_get_back_buffer(const struct wined3d_swapchain *swapchain, UINT backbuffer_idx); struct wined3d_device * __cdecl wined3d_swapchain_get_device(const struct wined3d_swapchain *swapchain); -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/10567
From: Stian Low <wineryyyyy@gmail.com> --- dlls/d3d11/device.c | 1 + dlls/wined3d/directx.c | 8 ++++++++ dlls/wined3d/utils.c | 34 +++++++++++++++++++++++++++++++--- dlls/wined3d/wined3d_private.h | 1 + include/wine/wined3d.h | 3 ++- 5 files changed, 43 insertions(+), 4 deletions(-) diff --git a/dlls/d3d11/device.c b/dlls/d3d11/device.c index e1a846698e6..b83ff03ce8d 100644 --- a/dlls/d3d11/device.c +++ b/dlls/d3d11/device.c @@ -4631,6 +4631,7 @@ static HRESULT STDMETHODCALLTYPE d3d11_device_CheckFormatSupport(ID3D11Device5 * {WINED3D_RTYPE_TEXTURE_2D, WINED3D_BIND_SHADER_RESOURCE, WINED3DUSAGE_QUERY_WRAPANDMIP, D3D11_FORMAT_SUPPORT_MIP}, {WINED3D_RTYPE_TEXTURE_2D, WINED3D_BIND_SHADER_RESOURCE, WINED3DUSAGE_QUERY_GENMIPMAP, D3D11_FORMAT_SUPPORT_MIP_AUTOGEN}, {WINED3D_RTYPE_TEXTURE_2D, WINED3D_BIND_RENDER_TARGET, WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING, D3D11_FORMAT_SUPPORT_BLENDABLE}, + {WINED3D_RTYPE_TEXTURE_2D, 0, WINED3DUSAGE_QUERY_BACK_BUFFER_CAST, D3D11_FORMAT_SUPPORT_BACK_BUFFER_CAST}, }; HRESULT hr; diff --git a/dlls/wined3d/directx.c b/dlls/wined3d/directx.c index 19ec8070dd9..7dfb6833105 100644 --- a/dlls/wined3d/directx.c +++ b/dlls/wined3d/directx.c @@ -2029,6 +2029,10 @@ HRESULT CDECL wined3d_check_device_format(const struct wined3d *wined3d, | WINED3D_BIND_DEPTH_STENCIL | WINED3D_BIND_UNORDERED_ACCESS; gl_type = gl_type_end = WINED3D_GL_RES_TYPE_TEX_2D; + + if ((usage & WINED3DUSAGE_QUERY_BACK_BUFFER_CAST)) + allowed_usage |= WINED3DUSAGE_QUERY_BACK_BUFFER_CAST; + if (!(bind_flags & WINED3D_BIND_SHADER_RESOURCE)) { if (!wined3d_check_surface_format(format)) @@ -2119,6 +2123,8 @@ HRESULT CDECL wined3d_check_device_format(const struct wined3d *wined3d, if (bind_flags & WINED3D_BIND_INDEX_BUFFER) format_caps |= WINED3D_FORMAT_CAP_INDEX_BUFFER; + if (usage & WINED3DUSAGE_QUERY_BACK_BUFFER_CAST) + format_caps |= WINED3D_FORMAT_CAP_BACK_BUFFER_CAST; if (usage & WINED3DUSAGE_QUERY_FILTER) format_caps |= WINED3D_FORMAT_CAP_FILTERING; if (usage & WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING) @@ -2131,6 +2137,8 @@ HRESULT CDECL wined3d_check_device_format(const struct wined3d *wined3d, format_caps |= WINED3D_FORMAT_CAP_VTF; if (usage & WINED3DUSAGE_QUERY_LEGACYBUMPMAP) format_attrs |= WINED3D_FORMAT_ATTR_BUMPMAP; + if (usage & WINED3DUSAGE_QUERY_LEGACYBUMPMAP) + format_attrs |= WINED3D_FORMAT_ATTR_BUMPMAP; if ((format_caps & WINED3D_FORMAT_CAP_TEXTURE) && (wined3d->flags & WINED3D_NO3D)) { diff --git a/dlls/wined3d/utils.c b/dlls/wined3d/utils.c index 0fb90ba3f18..c1d97835ce7 100644 --- a/dlls/wined3d/utils.c +++ b/dlls/wined3d/utils.c @@ -1419,7 +1419,7 @@ static const struct wined3d_format_texture_info format_texture_info[] = GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, 0, WINED3D_FORMAT_CAP_TEXTURE | WINED3D_FORMAT_CAP_POSTPIXELSHADER_BLENDING | WINED3D_FORMAT_CAP_FILTERING | WINED3D_FORMAT_CAP_RENDERTARGET | WINED3D_FORMAT_CAP_SRGB_READ | WINED3D_FORMAT_CAP_SRGB_WRITE - | WINED3D_FORMAT_CAP_VTF, + | WINED3D_FORMAT_CAP_VTF | WINED3D_FORMAT_CAP_BACK_BUFFER_CAST, WINED3D_GL_EXT_NONE, NULL}, {WINED3DFMT_B8G8R8X8_UNORM, GL_RGB8, GL_SRGB8_EXT, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, 0, @@ -1480,13 +1480,13 @@ static const struct wined3d_format_texture_info format_texture_info[] = {WINED3DFMT_R10G10B10A2_UNORM, GL_RGB10_A2, GL_RGB10_A2, 0, GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV, 0, WINED3D_FORMAT_CAP_TEXTURE | WINED3D_FORMAT_CAP_POSTPIXELSHADER_BLENDING | WINED3D_FORMAT_CAP_FILTERING - | WINED3D_FORMAT_CAP_RENDERTARGET, + | WINED3D_FORMAT_CAP_RENDERTARGET | WINED3D_FORMAT_CAP_BACK_BUFFER_CAST, WINED3D_GL_EXT_NONE, NULL}, {WINED3DFMT_R8G8B8A8_UNORM, GL_RGBA8, GL_SRGB8_ALPHA8_EXT, 0, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, 0, WINED3D_FORMAT_CAP_TEXTURE | WINED3D_FORMAT_CAP_POSTPIXELSHADER_BLENDING | WINED3D_FORMAT_CAP_FILTERING | WINED3D_FORMAT_CAP_RENDERTARGET | WINED3D_FORMAT_CAP_SRGB_READ | WINED3D_FORMAT_CAP_SRGB_WRITE - | WINED3D_FORMAT_CAP_VTF, + | WINED3D_FORMAT_CAP_VTF | WINED3D_FORMAT_CAP_BACK_BUFFER_CAST, WINED3D_GL_EXT_NONE, NULL}, {WINED3DFMT_R8G8B8A8_UINT, GL_RGBA8UI, GL_RGBA8UI, 0, GL_RGBA_INTEGER, GL_UNSIGNED_INT_8_8_8_8_REV, 0, @@ -4212,6 +4212,34 @@ static void init_vulkan_format_info(struct wined3d_adapter *adapter, struct wine return; } + for (i = 0; i < ARRAY_SIZE(format_texture_info); ++i) + { + if (format->f.id != format_texture_info[i].id) + continue; + + format->f.caps[WINED3D_GL_RES_TYPE_TEX_2D] |= format_texture_info[i].caps & WINED3D_FORMAT_CAP_BACK_BUFFER_CAST; + break; + } + + for (i = 0; i < ARRAY_SIZE(format_srgb_info); ++i) + { + if (format_srgb_info[i].base_format_id == format->f.id) + { + enum wined3d_format_id srgb_format_id = format_srgb_info[i].srgb_format_id; + struct wined3d_format_vk *srgb_format; + for (i = 0; i < WINED3D_FORMAT_COUNT; ++i) + { + srgb_format = wined3d_format_vk_mutable(get_format_by_idx(adapter, i)); + if (srgb_format_id != srgb_format->f.id) + continue; + + srgb_format->f.caps[WINED3D_GL_RES_TYPE_TEX_2D] |= format->f.caps[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3D_FORMAT_CAP_BACK_BUFFER_CAST; + break; + } + break; + } + } + if ((format->f.attrs & WINED3D_FORMAT_ATTR_PLANAR) && !vk_info->supported[WINED3D_VK_KHR_SAMPLER_YCBCR_CONVERSION] && vk_info->api_version < VK_API_VERSION_1_1) return; diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index dfd353de84f..1519ac906e0 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -4570,6 +4570,7 @@ extern enum wined3d_format_id pixelformat_for_depth(DWORD depth); #define WINED3D_FORMAT_CAP_VERTEX_ATTRIBUTE 0x00004000 #define WINED3D_FORMAT_CAP_BLIT 0x00008000 #define WINED3D_FORMAT_CAP_INDEX_BUFFER 0x00010000 +#define WINED3D_FORMAT_CAP_BACK_BUFFER_CAST 0x00020000 struct wined3d_rational { diff --git a/include/wine/wined3d.h b/include/wine/wined3d.h index a49b6885ad3..1500fd4b1da 100644 --- a/include/wine/wined3d.h +++ b/include/wine/wined3d.h @@ -968,7 +968,8 @@ enum wined3d_memory_segment_group #define WINED3DUSAGE_QUERY_SRGBWRITE 0x00040000 #define WINED3DUSAGE_QUERY_VERTEXTEXTURE 0x00100000 #define WINED3DUSAGE_QUERY_WRAPANDMIP 0x00200000 -#define WINED3DUSAGE_QUERY_MASK 0x003f8400 +#define WINED3DUSAGE_QUERY_BACK_BUFFER_CAST 0x00400000 +#define WINED3DUSAGE_QUERY_MASK 0x007f8400 #define WINED3D_MAP_NOSYSLOCK 0x00000800 #define WINED3D_MAP_NOOVERWRITE 0x00001000 -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/10567
From: Stian Low <wineryyyyy@gmail.com> --- dlls/d3d11/view.c | 38 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 38 insertions(+) diff --git a/dlls/d3d11/view.c b/dlls/d3d11/view.c index ec55dba5cf3..fd2ff9da206 100644 --- a/dlls/d3d11/view.c +++ b/dlls/d3d11/view.c @@ -1709,6 +1709,7 @@ static HRESULT d3d_rendertarget_view_init(struct d3d_rendertarget_view *view, st { struct wined3d_resource *wined3d_resource; struct wined3d_view_desc wined3d_desc; + struct wined3d_swapchain *swapchain; HRESULT hr; view->ID3D11RenderTargetView_iface.lpVtbl = &d3d11_rendertarget_view_vtbl; @@ -1736,6 +1737,43 @@ static HRESULT d3d_rendertarget_view_init(struct d3d_rendertarget_view *view, st } wined3d_rendertarget_view_desc_from_d3d11(&wined3d_desc, &view->desc); + + if ((swapchain = wined3d_swapchain_from_resource(wined3d_resource))) + { + if (wined3d_swapchain_get_back_buffer(swapchain, 0) != wined3d_texture_from_resource(wined3d_resource)) + { + wined3d_mutex_unlock(); + ERR("RTVs texture does not match swapchain back_buffers[0]\n"); + return E_INVALIDARG; + } + else + { + struct wined3d_device_creation_parameters params; + struct wined3d_adapter *wined3d_adapter; + enum wined3d_format_id wined3d_format; + struct wined3d *wined3d; + + wined3d_format = wined3dformat_from_dxgi_format(view->desc.Format); + if (view->desc.Format && !wined3d_format) + { + WARN("Invalid format %#x.\n", view->desc.Format); + return E_FAIL; + } + wined3d_device_get_creation_parameters(device->wined3d_device, ¶ms); + wined3d = wined3d_device_get_wined3d(device->wined3d_device); + wined3d_adapter = wined3d_get_adapter(wined3d, params.adapter_idx); + hr = wined3d_check_device_format(wined3d, wined3d_adapter, params.device_type, WINED3DFMT_UNKNOWN, + WINED3DUSAGE_QUERY_BACK_BUFFER_CAST, 0, WINED3D_RTYPE_TEXTURE_2D, wined3d_format); + if (hr == WINED3DERR_NOTAVAILABLE || hr == WINED3DOK_NOMIPGEN) + { + wined3d_mutex_unlock(); + ERR("Failed to get format support\n"); + return hr; + } + } + } + + if (FAILED(hr = wined3d_rendertarget_view_create(&wined3d_desc, wined3d_resource, view, &d3d_render_target_view_wined3d_parent_ops, &view->wined3d_view))) { -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/10567
From: Stian Low <wineryyyyy@gmail.com> --- dlls/wined3d/swapchain.c | 2 ++ dlls/wined3d/view.c | 16 ++++++++++++++++ dlls/wined3d/wined3d_private.h | 7 +++++++ 3 files changed, 25 insertions(+) diff --git a/dlls/wined3d/swapchain.c b/dlls/wined3d/swapchain.c index 487b4c1d1ad..05a4d225d91 100644 --- a/dlls/wined3d/swapchain.c +++ b/dlls/wined3d/swapchain.c @@ -1751,6 +1751,7 @@ HRESULT wined3d_swapchain_gl_init(struct wined3d_swapchain_gl *swapchain_gl, str TRACE("swapchain_gl %p, device %p, desc %p, state_parent %p, parent %p, parent_ops %p.\n", swapchain_gl, device, desc, state_parent, parent, parent_ops); + list_init(&swapchain_gl->s.back_buffer_rendertarget_views); return wined3d_swapchain_init(&swapchain_gl->s, device, desc, state_parent, parent, parent_ops, &swapchain_gl_ops); } @@ -1764,6 +1765,7 @@ HRESULT wined3d_swapchain_vk_init(struct wined3d_swapchain_vk *swapchain_vk, str TRACE("swapchain_vk %p, device %p, desc %p, parent %p, parent_ops %p.\n", swapchain_vk, device, desc, parent, parent_ops); + list_init(&swapchain_vk->s.back_buffer_rendertarget_views); if (FAILED(hr = wined3d_swapchain_init(&swapchain_vk->s, device, desc, state_parent, parent, parent_ops, &swapchain_vk_ops))) return hr; diff --git a/dlls/wined3d/view.c b/dlls/wined3d/view.c index a506b0c6f18..004f9fca655 100644 --- a/dlls/wined3d/view.c +++ b/dlls/wined3d/view.c @@ -417,10 +417,26 @@ ULONG CDECL wined3d_rendertarget_view_decref(struct wined3d_rendertarget_view *v if (!refcount) { struct wined3d_resource *resource = view->resource; + struct wined3d_swapchain *swapchain; /* Release the resource after destroying the view. * See wined3d_shader_resource_view_decref(). */ wined3d_mutex_lock(); + + if ((swapchain = wined3d_swapchain_from_resource(resource))) + { + struct wined3d_swapchain_rendertarget_view *swap_view; + LIST_FOR_EACH_ENTRY(swap_view, &swapchain->back_buffer_rendertarget_views, struct wined3d_swapchain_rendertarget_view, entry) + { + if (swap_view->view != view) + continue; + + list_remove(&swap_view->entry); + free(swap_view); + break; + } + } + resource->device->adapter->adapter_ops->adapter_destroy_rendertarget_view(view); wined3d_mutex_unlock(); wined3d_resource_decref(resource); diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index 1519ac906e0..f36e3889bcf 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -4094,6 +4094,12 @@ struct wined3d_swapchain_ops void (*swapchain_frontbuffer_updated)(struct wined3d_swapchain *swapchain); }; +struct wined3d_swapchain_rendertarget_view +{ + struct list entry; + struct wined3d_rendertarget_view *view; +}; + struct wined3d_swapchain { LONG ref; @@ -4104,6 +4110,7 @@ struct wined3d_swapchain struct wined3d_texture **back_buffers; struct wined3d_texture *front_buffer; + struct list back_buffer_rendertarget_views; struct wined3d_gamma_ramp orig_gamma; bool reapply_mode; const struct wined3d_format *ds_format; -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/10567
From: Stian Low <wineryyyyy@gmail.com> --- dlls/wined3d/adapter_vk.c | 19 ++++++++++++++ dlls/wined3d/swapchain.c | 36 +++++++++++++++++++++++++++ dlls/wined3d/view.c | 52 ++++++++++++++++++++++++++++++++++----- dlls/wined3d/wined3d_vk.h | 7 ++++++ 4 files changed, 108 insertions(+), 6 deletions(-) diff --git a/dlls/wined3d/adapter_vk.c b/dlls/wined3d/adapter_vk.c index 79014b4c331..bdb4b480d29 100644 --- a/dlls/wined3d/adapter_vk.c +++ b/dlls/wined3d/adapter_vk.c @@ -1515,6 +1515,24 @@ static void wined3d_view_vk_destroy(struct wined3d_device *device, VkBufferView wined3d_cs_finish(device->cs, WINED3D_CS_QUEUE_DEFAULT); } +static void adapter_vk_destroy_swapchain_rendertarget_views(struct wined3d_rendertarget_view_vk *view_vk) +{ + struct wined3d_swapchain_rendertarget_view_vk *swap_view_vk, *swap_view_vk_next; + struct wined3d_resource *resource = view_vk->v.resource; + struct wined3d_swapchain *swapchain; + + if (!(swapchain = wined3d_swapchain_from_resource(resource))) + return; + + LIST_FOR_EACH_ENTRY_SAFE(swap_view_vk, swap_view_vk_next, &view_vk->swapchain_views, struct wined3d_swapchain_rendertarget_view_vk, entry) + { + wined3d_view_vk_destroy(resource->device, NULL, &swap_view_vk->vk_image_view, NULL, NULL, NULL, &view_vk->command_buffer_id, NULL); + list_remove(&swap_view_vk->entry); + free(swap_view_vk); + swap_view_vk = swap_view_vk_next; + } +} + static void adapter_vk_destroy_rendertarget_view(struct wined3d_rendertarget_view *view) { struct wined3d_rendertarget_view_vk *view_vk = wined3d_rendertarget_view_vk(view); @@ -1522,6 +1540,7 @@ static void adapter_vk_destroy_rendertarget_view(struct wined3d_rendertarget_vie TRACE("view_vk %p.\n", view_vk); + adapter_vk_destroy_swapchain_rendertarget_views(view_vk); wined3d_rendertarget_view_cleanup(&view_vk->v); wined3d_view_vk_destroy(resource->device, NULL, &view_vk->vk_image_view, NULL, NULL, NULL, &view_vk->command_buffer_id, view_vk); diff --git a/dlls/wined3d/swapchain.c b/dlls/wined3d/swapchain.c index 05a4d225d91..d8733dd3bf1 100644 --- a/dlls/wined3d/swapchain.c +++ b/dlls/wined3d/swapchain.c @@ -1199,7 +1199,43 @@ static VkResult wined3d_swapchain_vk_blit(struct wined3d_swapchain_vk *swapchain WARN("Present returned vr %s.\n", wined3d_debug_vkresult(vr)); return vr; } +#if 0 +static void wined3d_swapchain_rendertarget_view_vk_rotate(struct wined3d_swapchain *swapchain) +{ + struct wined3d_swapchain_rendertarget_view_vk *swap_view_vk; + struct wined3d_swapchain_rendertarget_view *swap_view; + struct wined3d_rendertarget_view_vk *view_vk; + VkImageView vk_image_view, vk_image_view_prev; + + if (!swapchain || swapchain->state.desc.backbuffer_count < 2) + return; + + LIST_FOR_EACH_ENTRY(swap_view, &swapchain->back_buffer_rendertarget_views, struct wined3d_swapchain_rendertarget_view, entry) + { + if (!swap_view->view) + { + FIXME("Skipping rotate for swap_view %p which should not occur.\n", swap_view); + continue; + } + view_vk = wined3d_rendertarget_view_vk(swap_view->view); + if (!view_vk->vk_image_view) + { + FIXME("Skipping rotate for view_vk %p with vk_image_view 0 which should not occur.\n", view_vk); + continue; + } + + vk_image_view_prev = view_vk->vk_image_view; + LIST_FOR_EACH_ENTRY(swap_view_vk, &view_vk->swapchain_views, struct wined3d_swapchain_rendertarget_view_vk, entry) + { + vk_image_view = swap_view_vk->vk_image_view; + swap_view_vk->vk_image_view = vk_image_view_prev; + vk_image_view_prev = vk_image_view; + } + view_vk->vk_image_view = vk_image_view_prev; + } +} +#endif static void wined3d_swapchain_vk_rotate(struct wined3d_swapchain *swapchain, struct wined3d_context_vk *context_vk) { struct wined3d_texture_sub_resource *sub_resource; diff --git a/dlls/wined3d/view.c b/dlls/wined3d/view.c index 004f9fca655..a8892a88b92 100644 --- a/dlls/wined3d/view.c +++ b/dlls/wined3d/view.c @@ -912,14 +912,18 @@ static VkImageView wined3d_view_vk_create_vk_image_view(struct wined3d_context_v static void wined3d_render_target_view_vk_cs_init(void *object) { + struct wined3d_swapchain_rendertarget_view_vk *swap_view_vk; struct wined3d_rendertarget_view_vk *view_vk = object; struct wined3d_view_desc *desc = &view_vk->v.desc; + struct wined3d_swapchain_rendertarget_view *lview; const struct wined3d_format_vk *format_vk; struct wined3d_texture_vk *texture_vk; + struct wined3d_swapchain *swapchain; struct wined3d_resource *resource; struct wined3d_context *context; VkImageUsageFlags vk_usage = 0; uint32_t default_flags = 0; + unsigned int i, count; TRACE("view_vk %p.\n", view_vk); @@ -946,12 +950,6 @@ static void wined3d_render_target_view_vk_cs_init(void *object) return; } - if (texture_vk->t.swapchain && texture_vk->t.swapchain->state.desc.backbuffer_count > 1) - { - FIXME("Swapchain views not supported.\n"); - return; - } - if (resource->bind_flags & WINED3D_BIND_RENDER_TARGET) vk_usage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; if (resource->bind_flags & WINED3D_BIND_DEPTH_STENCIL) @@ -963,8 +961,49 @@ static void wined3d_render_target_view_vk_cs_init(void *object) context_release(context); if (!view_vk->vk_image_view) + { + ERR("Failed to create render target view for resource %p\n", resource); + /* TODO: flag for cleanup? */ + return; + } + + if (!(swapchain = swapchain_from_resource(resource))) return; + context = context_acquire(resource->device, NULL, 0); + count = swapchain->state.desc.backbuffer_count - 1; + for (i = 0; i < count; i++) + { + if (!(swap_view_vk = calloc(1, sizeof(*swap_view_vk)))) + { + ERR("Out of memory.\n"); + context_release(context); + return; + } + + list_add_head(&view_vk->swapchain_views, &swap_view_vk->entry); + texture_vk = wined3d_texture_vk(swapchain->back_buffers[i + 1]); + if ((swap_view_vk->vk_image_view = wined3d_view_vk_create_vk_image_view(wined3d_context_vk(context), + desc, texture_vk, format_vk, COLOR_FIXUP_IDENTITY, true, vk_usage))) + continue; + + ERR("Failed to create render target view for swapchain %p backbuffer[%u]\n", swapchain, i); + /* TODO: flag for cleanup? */ + break; + } + + context_release(context); + + if (!(lview = calloc(1, sizeof(*lview)))) + { + ERR("Out of memory.\n"); + /* TODO: flag for cleanup? */ + return; + } + + list_add_head(&swapchain->back_buffer_rendertarget_views, &lview->entry); + lview->view = &view_vk->v; + TRACE("Created image view 0x%s.\n", wine_dbgstr_longlong(view_vk->vk_image_view)); } @@ -980,6 +1019,7 @@ HRESULT wined3d_rendertarget_view_vk_init(struct wined3d_rendertarget_view_vk *v if (FAILED(hr = wined3d_rendertarget_view_init(&view_vk->v, desc, resource, parent, parent_ops))) return hr; + list_init(&view_vk->swapchain_views); wined3d_cs_init_object(resource->device->cs, wined3d_render_target_view_vk_cs_init, view_vk); return hr; diff --git a/dlls/wined3d/wined3d_vk.h b/dlls/wined3d/wined3d_vk.h index 937a958760c..05ce14f153b 100644 --- a/dlls/wined3d/wined3d_vk.h +++ b/dlls/wined3d/wined3d_vk.h @@ -1031,12 +1031,19 @@ static inline void wined3d_resource_vk_barrier(struct wined3d_resource *resource wined3d_texture_vk_barrier(wined3d_texture_vk(texture_from_resource(resource)), context_vk, bind_mask); } +struct wined3d_swapchain_rendertarget_view_vk +{ + struct list entry; + VkImageView vk_image_view; +}; + struct wined3d_rendertarget_view_vk { struct wined3d_rendertarget_view v; VkImageView vk_image_view; uint64_t command_buffer_id; + struct list swapchain_views; }; static inline struct wined3d_rendertarget_view_vk *wined3d_rendertarget_view_vk( -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/10567
From: Stian Low <wineryyyyy@gmail.com> --- dlls/wined3d/swapchain.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/dlls/wined3d/swapchain.c b/dlls/wined3d/swapchain.c index d8733dd3bf1..59fa4e9146e 100644 --- a/dlls/wined3d/swapchain.c +++ b/dlls/wined3d/swapchain.c @@ -1199,7 +1199,7 @@ static VkResult wined3d_swapchain_vk_blit(struct wined3d_swapchain_vk *swapchain WARN("Present returned vr %s.\n", wined3d_debug_vkresult(vr)); return vr; } -#if 0 + static void wined3d_swapchain_rendertarget_view_vk_rotate(struct wined3d_swapchain *swapchain) { struct wined3d_swapchain_rendertarget_view_vk *swap_view_vk; @@ -1235,7 +1235,7 @@ static void wined3d_swapchain_rendertarget_view_vk_rotate(struct wined3d_swapcha view_vk->vk_image_view = vk_image_view_prev; } } -#endif + static void wined3d_swapchain_vk_rotate(struct wined3d_swapchain *swapchain, struct wined3d_context_vk *context_vk) { struct wined3d_texture_sub_resource *sub_resource; @@ -1285,6 +1285,8 @@ static void wined3d_swapchain_vk_rotate(struct wined3d_swapchain *swapchain, str texture_prev->bind_mask = bind_mask0; texture_prev->default_image_info = vk_info0; + wined3d_swapchain_rendertarget_view_vk_rotate(swapchain); + wined3d_texture_validate_location(&texture_prev->t, 0, locations0 & supported_locations); wined3d_texture_invalidate_location(&texture_prev->t, 0, ~(locations0 & supported_locations)); -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/10567
From: Stian Low <wineryyyyy@gmail.com> --- dlls/wined3d/adapter_gl.c | 39 +++++++++++---- dlls/wined3d/swapchain.c | 33 +++++++++++++ dlls/wined3d/view.c | 101 +++++++++++++++++++++++++++++--------- dlls/wined3d/wined3d_gl.h | 7 +++ 4 files changed, 146 insertions(+), 34 deletions(-) diff --git a/dlls/wined3d/adapter_gl.c b/dlls/wined3d/adapter_gl.c index 35f73b64497..dd1b1a65deb 100644 --- a/dlls/wined3d/adapter_gl.c +++ b/dlls/wined3d/adapter_gl.c @@ -4586,7 +4586,7 @@ static HRESULT adapter_gl_create_rendertarget_view(const struct wined3d_view_des struct wined3d_view_gl_destroy_ctx { struct wined3d_device *device; - const struct wined3d_gl_view *gl_view; + GLuint name; struct wined3d_bo_user *bo_user; struct wined3d_bo_gl *counter_bo; void *object; @@ -4606,14 +4606,14 @@ static void wined3d_view_gl_destroy_object(void *object) device = ctx->device; counter_id = ctx->counter_bo ? ctx->counter_bo->id : 0; - if (ctx->gl_view->name || counter_id) + if (ctx->name || counter_id) { context = context_acquire(device, NULL, 0); gl_info = wined3d_context_gl(context)->gl_info; - if (ctx->gl_view->name) + if (ctx->name) { - context_gl_resource_released(device, ctx->gl_view->name, FALSE); - gl_info->gl_ops.gl.p_glDeleteTextures(1, &ctx->gl_view->name); + context_gl_resource_released(device, ctx->name, FALSE); + gl_info->gl_ops.gl.p_glDeleteTextures(1, &ctx->name); } if (counter_id) wined3d_context_gl_destroy_bo(wined3d_context_gl(context), ctx->counter_bo); @@ -4627,7 +4627,7 @@ static void wined3d_view_gl_destroy_object(void *object) free(ctx->free); } -static void wined3d_view_gl_destroy(struct wined3d_device *device, const struct wined3d_gl_view *gl_view, +static void wined3d_view_gl_destroy(struct wined3d_device *device, GLuint name, struct wined3d_bo_user *bo_user, struct wined3d_bo_gl *counter_bo, void *object) { struct wined3d_view_gl_destroy_ctx *ctx, c; @@ -4635,7 +4635,7 @@ static void wined3d_view_gl_destroy(struct wined3d_device *device, const struct if (!(ctx = malloc(sizeof(*ctx)))) ctx = &c; ctx->device = device; - ctx->gl_view = gl_view; + ctx->name = name; ctx->bo_user = bo_user; ctx->counter_bo = counter_bo; ctx->object = object; @@ -4646,6 +4646,24 @@ static void wined3d_view_gl_destroy(struct wined3d_device *device, const struct wined3d_cs_finish(device->cs, WINED3D_CS_QUEUE_DEFAULT); } +static void adapter_gl_destroy_swapchain_rendertarget_views(struct wined3d_rendertarget_view_gl *view_gl) +{ + struct wined3d_swapchain_rendertarget_view_gl *swap_view_gl, *swap_view_gl_next; + struct wined3d_resource *resource = view_gl->v.resource; + struct wined3d_swapchain *swapchain; + + if (!(swapchain = wined3d_swapchain_from_resource(resource))) + return; + + LIST_FOR_EACH_ENTRY_SAFE(swap_view_gl, swap_view_gl_next, &view_gl->swapchain_views, struct wined3d_swapchain_rendertarget_view_gl, entry) + { + wined3d_view_gl_destroy(resource->device, swap_view_gl->name, NULL, NULL, NULL); + list_remove(&swap_view_gl->entry); + free(swap_view_gl); + swap_view_gl = swap_view_gl_next; + } +} + static void adapter_gl_destroy_rendertarget_view(struct wined3d_rendertarget_view *view) { struct wined3d_rendertarget_view_gl *view_gl = wined3d_rendertarget_view_gl(view); @@ -4653,8 +4671,9 @@ static void adapter_gl_destroy_rendertarget_view(struct wined3d_rendertarget_vie TRACE("view_gl %p.\n", view_gl); + adapter_gl_destroy_swapchain_rendertarget_views(view_gl); wined3d_rendertarget_view_cleanup(&view_gl->v); - wined3d_view_gl_destroy(resource->device, &view_gl->gl_view, NULL, NULL, view_gl); + wined3d_view_gl_destroy(resource->device, view_gl->gl_view.name, NULL, NULL, view_gl); } static HRESULT adapter_gl_create_shader_resource_view(const struct wined3d_view_desc *desc, @@ -4691,7 +4710,7 @@ static void adapter_gl_destroy_shader_resource_view(struct wined3d_shader_resour TRACE("view_gl %p.\n", view_gl); wined3d_shader_resource_view_cleanup(&view_gl->v); - wined3d_view_gl_destroy(resource->device, &view_gl->gl_view, &view_gl->bo_user, NULL, view_gl); + wined3d_view_gl_destroy(resource->device, view_gl->gl_view.name, &view_gl->bo_user, NULL, view_gl); } static HRESULT adapter_gl_create_unordered_access_view(const struct wined3d_view_desc *desc, @@ -4728,7 +4747,7 @@ static void adapter_gl_destroy_unordered_access_view(struct wined3d_unordered_ac TRACE("view_gl %p.\n", view_gl); wined3d_unordered_access_view_cleanup(&view_gl->v); - wined3d_view_gl_destroy(resource->device, &view_gl->gl_view, &view_gl->bo_user, &view_gl->counter_bo, view_gl); + wined3d_view_gl_destroy(resource->device, view_gl->gl_view.name, &view_gl->bo_user, &view_gl->counter_bo, view_gl); } static HRESULT adapter_gl_create_video_decoder_output_view(const struct wined3d_view_desc *desc, diff --git a/dlls/wined3d/swapchain.c b/dlls/wined3d/swapchain.c index 59fa4e9146e..e2d13723d6e 100644 --- a/dlls/wined3d/swapchain.c +++ b/dlls/wined3d/swapchain.c @@ -537,7 +537,40 @@ static void swapchain_gl_set_swap_interval(struct wined3d_swapchain *swapchain, swap_interval, context_gl, GetLastError()); } } +#if 0 +static void wined3d_swapchain_rendertarget_view_gl_rotate(struct wined3d_swapchain *swapchain) +{ + struct wined3d_swapchain_rendertarget_view_gl *swap_view_gl; + struct wined3d_swapchain_rendertarget_view *swap_view; + struct wined3d_rendertarget_view_gl *view_gl; + GLuint name, name_prev; + + if (!swapchain || swapchain->state.desc.backbuffer_count < 2) + return; + + LIST_FOR_EACH_ENTRY(swap_view, &swapchain->back_buffer_rendertarget_views, struct wined3d_swapchain_rendertarget_view, entry) + { + if (!swap_view->view) + continue; + + view_gl = wined3d_rendertarget_view_gl(swap_view->view); + if (!view_gl->gl_view.name) + { + FIXME("Skipping rotate for view_gl %p with name 0 which should not occur.\n", view_gl); + continue; + } + name_prev = view_gl->gl_view.name; + LIST_FOR_EACH_ENTRY(swap_view_gl, &view_gl->swapchain_views, struct wined3d_swapchain_rendertarget_view_gl, entry) + { + name = swap_view_gl->name; + swap_view_gl->name = name_prev; + name_prev = name; + } + view_gl->gl_view.name = name_prev; + } +} +#endif /* Context activation is done by the caller. */ static void wined3d_swapchain_gl_rotate(struct wined3d_swapchain *swapchain, struct wined3d_context *context) { diff --git a/dlls/wined3d/view.c b/dlls/wined3d/view.c index a8892a88b92..e65453bc15a 100644 --- a/dlls/wined3d/view.c +++ b/dlls/wined3d/view.c @@ -603,48 +603,100 @@ void wined3d_rendertarget_view_get_box(struct wined3d_rendertarget_view *view, static void wined3d_render_target_view_gl_cs_init(void *object) { + struct wined3d_swapchain_rendertarget_view_gl *swap_view_gl; struct wined3d_rendertarget_view_gl *view_gl = object; struct wined3d_resource *resource = view_gl->v.resource; const struct wined3d_view_desc *desc = &view_gl->v.desc; + struct wined3d_swapchain_rendertarget_view *lview; + struct wined3d_texture_gl *texture_gl; + struct wined3d_swapchain *swapchain; + unsigned int depth_or_layer_count; + GLenum resource_class, view_class; + struct wined3d_context *context; + unsigned int i, count; + GLuint name; TRACE("view_gl %p.\n", view_gl); if (resource->type == WINED3D_RTYPE_BUFFER) { FIXME("Not implemented for resources %s.\n", debug_d3dresourcetype(resource->type)); + return; } + + texture_gl = wined3d_texture_gl(texture_from_resource(resource)); + if (resource->type == WINED3D_RTYPE_TEXTURE_3D) + depth_or_layer_count = wined3d_texture_get_level_depth(&texture_gl->t, desc->u.texture.level_idx); else + depth_or_layer_count = texture_gl->t.layer_count; + + if (resource->format->id == view_gl->v.format->id + && (view_gl->v.layer_count == 1 && view_gl->v.layer_count == depth_or_layer_count)) { - struct wined3d_texture_gl *texture_gl = wined3d_texture_gl(texture_from_resource(resource)); - unsigned int depth_or_layer_count; + TRACE("Skipping view init because format and layer_count matches underlying texture\n"); + return; + } - if (resource->type == WINED3D_RTYPE_TEXTURE_3D) - depth_or_layer_count = wined3d_texture_get_level_depth(&texture_gl->t, desc->u.texture.level_idx); - else - depth_or_layer_count = texture_gl->t.layer_count; + resource_class = wined3d_format_gl(resource->format)->view_class; + view_class = wined3d_format_gl(view_gl->v.format)->view_class; + if (resource_class != view_class) + { + FIXME("Render target view not supported, resource format %s, view format %s.\n", + debug_d3dformat(resource->format->id), debug_d3dformat(view_gl->v.format->id)); + return; + } - if (resource->format->id != view_gl->v.format->id - || (view_gl->v.layer_count != 1 && view_gl->v.layer_count != depth_or_layer_count)) - { - GLenum resource_class, view_class; + context = context_acquire(resource->device, NULL, 0); + create_texture_view(&view_gl->gl_view, texture_gl->target, desc, texture_gl, view_gl->v.format); + context_release(context); + if (!view_gl->gl_view.name) + { + ERR("Failed to create render target view for resource %p\n", resource); + /* TODO: flag for cleanup? */ + return; + } - resource_class = wined3d_format_gl(resource->format)->view_class; - view_class = wined3d_format_gl(view_gl->v.format)->view_class; - if (resource_class != view_class) - { - FIXME("Render target view not supported, resource format %s, view format %s.\n", - debug_d3dformat(resource->format->id), debug_d3dformat(view_gl->v.format->id)); - return; - } - if (texture_gl->t.swapchain && texture_gl->t.swapchain->state.desc.backbuffer_count > 1) - { - FIXME("Swapchain views not supported.\n"); - return; - } + if (!(swapchain = swapchain_from_resource(resource))) + return; + + context = context_acquire(resource->device, NULL, 0); + count = swapchain->state.desc.backbuffer_count - 1; + name = view_gl->gl_view.name; + for (i = 0; i < count; i++) + { + if (!(swap_view_gl = calloc(1, sizeof(*swap_view_gl)))) + { + ERR("Out of memory.\n"); + context_release(context); + return; + } - create_texture_view(&view_gl->gl_view, texture_gl->target, desc, texture_gl, view_gl->v.format); + list_add_head(&view_gl->swapchain_views, &swap_view_gl->entry); + texture_gl = wined3d_texture_gl(swapchain->back_buffers[i + 1]); + create_texture_view(&view_gl->gl_view, texture_gl->target, desc, texture_gl, view_gl->v.format); + if (view_gl->gl_view.name) + { + swap_view_gl->name = view_gl->gl_view.name; + continue; } + + ERR("Failed to create render target view for swapchain %p backbuffer[%u]\n", swapchain, i); + /* TODO: flag for cleanup? */ + break; + } + + view_gl->gl_view.name = name; + context_release(context); + + if (!(lview = calloc(1, sizeof(*lview)))) + { + ERR("Out of memory.\n"); + /* TODO: flag for cleanup? */ + return; } + + list_add_head(&swapchain->back_buffer_rendertarget_views, &lview->entry); + lview->view = &view_gl->v; } static HRESULT wined3d_rendertarget_view_init(struct wined3d_rendertarget_view *view, @@ -716,6 +768,7 @@ HRESULT wined3d_rendertarget_view_gl_init(struct wined3d_rendertarget_view_gl *v if (FAILED(hr = wined3d_rendertarget_view_init(&view_gl->v, desc, resource, parent, parent_ops))) return hr; + list_init(&view_gl->swapchain_views); wined3d_cs_init_object(resource->device->cs, wined3d_render_target_view_gl_cs_init, view_gl); return hr; diff --git a/dlls/wined3d/wined3d_gl.h b/dlls/wined3d/wined3d_gl.h index c9c7118c59e..fdd3e4a0e9b 100644 --- a/dlls/wined3d/wined3d_gl.h +++ b/dlls/wined3d/wined3d_gl.h @@ -1078,10 +1078,17 @@ HRESULT wined3d_buffer_gl_init(struct wined3d_buffer_gl *buffer_gl, struct wined const struct wined3d_buffer_desc *desc, const struct wined3d_sub_resource_data *data, void *parent, const struct wined3d_parent_ops *parent_ops); +struct wined3d_swapchain_rendertarget_view_gl +{ + struct list entry; + GLuint name; +}; + struct wined3d_rendertarget_view_gl { struct wined3d_rendertarget_view v; struct wined3d_gl_view gl_view; + struct list swapchain_views; }; static inline struct wined3d_rendertarget_view_gl *wined3d_rendertarget_view_gl( -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/10567
From: Stian Low <wineryyyyy@gmail.com> --- dlls/wined3d/swapchain.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/dlls/wined3d/swapchain.c b/dlls/wined3d/swapchain.c index e2d13723d6e..14dcecfac25 100644 --- a/dlls/wined3d/swapchain.c +++ b/dlls/wined3d/swapchain.c @@ -537,7 +537,7 @@ static void swapchain_gl_set_swap_interval(struct wined3d_swapchain *swapchain, swap_interval, context_gl, GetLastError()); } } -#if 0 + static void wined3d_swapchain_rendertarget_view_gl_rotate(struct wined3d_swapchain *swapchain) { struct wined3d_swapchain_rendertarget_view_gl *swap_view_gl; @@ -570,7 +570,7 @@ static void wined3d_swapchain_rendertarget_view_gl_rotate(struct wined3d_swapcha view_gl->gl_view.name = name_prev; } } -#endif + /* Context activation is done by the caller. */ static void wined3d_swapchain_gl_rotate(struct wined3d_swapchain *swapchain, struct wined3d_context *context) { @@ -612,6 +612,8 @@ static void wined3d_swapchain_gl_rotate(struct wined3d_swapchain *swapchain, str texture_prev->texture_rgb = tex0; texture_prev->rb_multisample = rb0; + wined3d_swapchain_rendertarget_view_gl_rotate(swapchain); + wined3d_texture_validate_location(&texture_prev->t, 0, locations0 & supported_locations); wined3d_texture_invalidate_location(&texture_prev->t, 0, ~(locations0 & supported_locations)); -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/10567
From: Stian Low <wineryyyyy@gmail.com> --- dlls/wined3d/texture_gl.c | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/dlls/wined3d/texture_gl.c b/dlls/wined3d/texture_gl.c index 311ee954c23..a08c2662867 100644 --- a/dlls/wined3d/texture_gl.c +++ b/dlls/wined3d/texture_gl.c @@ -913,6 +913,12 @@ static void texture2d_blt_fbo(struct wined3d_device *device, struct wined3d_cont gl_info->gl_ops.gl.p_glDisable(GL_SCISSOR_TEST); context_invalidate_state(context, STATE_RASTERIZER); + if (gl_info->supported[ARB_FRAMEBUFFER_SRGB] && (!resolve_format || !(resolve_format->caps[WINED3D_RTYPE_TEXTURE_2D] & WINED3D_FORMAT_CAP_SRGB_WRITE))) + { + gl_info->gl_ops.gl.p_glDisable(GL_FRAMEBUFFER_SRGB); + context_invalidate_state(context, STATE_SHADER(WINED3D_SHADER_TYPE_PIXEL)); + } + gl_info->fbo_ops.glBlitFramebuffer(src_rect->left, src_rect->top, src_rect->right, src_rect->bottom, dst_rect->left, dst_rect->top, dst_rect->right, dst_rect->bottom, GL_COLOR_BUFFER_BIT, gl_filter); checkGLcall("glBlitFramebuffer()"); -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/10567
From: Stian Low <wineryyyyy@gmail.com> --- dlls/d3d10core/tests/d3d10core.c | 8 ++++---- dlls/d3d11/tests/d3d11.c | 6 +++--- 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/dlls/d3d10core/tests/d3d10core.c b/dlls/d3d10core/tests/d3d10core.c index 4735d271d74..53518ed7755 100644 --- a/dlls/d3d10core/tests/d3d10core.c +++ b/dlls/d3d10core/tests/d3d10core.c @@ -11048,7 +11048,7 @@ static void test_swapchain_views(void) hr = ID3D10Device_CreateRenderTargetView(device, (ID3D10Resource *)test_context.backbuffer, &rtv_desc, &rtv); flags &= D3D10_FORMAT_SUPPORT_BACK_BUFFER_CAST; flags = (FAILED(hr) && !flags) || (SUCCEEDED(hr) && flags); - todo_wine ok(flags, "Got unexpected for SRGB rtv for UNORM swapchain, hr %#lx.\n", hr); + ok(flags, "Got unexpected for SRGB rtv for UNORM swapchain, hr %#lx.\n", hr); if (SUCCEEDED(hr)) ID3D10RenderTargetView_Release(rtv); @@ -11193,7 +11193,7 @@ static void test_swapchain_flip(void) ok(texture_desc.Usage == D3D10_USAGE_DEFAULT, "Got unexpected usage %u.\n", texture_desc.Usage); hr = ID3D10Device_CreateRenderTargetView(device, (ID3D10Resource *)backbuffer_1, NULL, &offscreen_rtv); - todo_wine ok(hr == E_INVALIDARG, "Got unexpected for rtv for swapchain backbuffer_1, hr %#lx.\n", hr); + ok(hr == E_INVALIDARG, "Got unexpected for rtv for swapchain backbuffer_1, hr %#lx.\n", hr); if (SUCCEEDED(hr)) ID3D10RenderTargetView_Release(offscreen_rtv); @@ -11245,12 +11245,12 @@ static void test_swapchain_flip(void) hr = ID3D10Device_CreateRenderTargetView(device, (ID3D10Resource *)backbuffer_0, &rtv_desc, &backbuffer_0_rtv_srgb); flags &= D3D10_FORMAT_SUPPORT_BACK_BUFFER_CAST; flags = (FAILED(hr) && !flags) || (SUCCEEDED(hr) && flags); - todo_wine ok(flags, "Got unexpected for SRGB rtv for UNORM swapchain, hr %#lx.\n", hr); + ok(flags, "Got unexpected for SRGB rtv for UNORM swapchain, hr %#lx.\n", hr); if (SUCCEEDED(hr)) { ID3D10Device_ClearRenderTargetView(device, backbuffer_0_rtv_srgb, grey); color = get_texture_color(backbuffer_0, 320, 240); /* red */ - todo_wine ok(compare_color(color, 0x80bcbcbc, 1), "Got unexpected srgb color 0x%08x.\n", color); + ok(compare_color(color, 0x80bcbcbc, 1), "Got unexpected srgb color 0x%08x.\n", color); } ID3D10Device_ClearRenderTargetView(device, backbuffer_0_rtv, red); diff --git a/dlls/d3d11/tests/d3d11.c b/dlls/d3d11/tests/d3d11.c index 76ef5f6bb98..01b5a3fc909 100644 --- a/dlls/d3d11/tests/d3d11.c +++ b/dlls/d3d11/tests/d3d11.c @@ -16143,7 +16143,7 @@ static void test_swapchain_flip(void) ok(texture_desc.Usage == D3D11_USAGE_DEFAULT, "Got unexpected usage %u.\n", texture_desc.Usage); hr = ID3D11Device_CreateRenderTargetView(device, (ID3D11Resource *)backbuffer_1, NULL, &offscreen_rtv); - todo_wine ok(hr == E_INVALIDARG, "Got unexpected for rtv for swapchain backbuffer_1, hr %#lx.\n", hr); + ok(hr == E_INVALIDARG, "Got unexpected for rtv for swapchain backbuffer_1, hr %#lx.\n", hr); if (SUCCEEDED(hr)) ID3D11RenderTargetView_Release(offscreen_rtv); @@ -16195,12 +16195,12 @@ static void test_swapchain_flip(void) hr = ID3D11Device_CreateRenderTargetView(device, (ID3D11Resource *)backbuffer_0, &rtv_desc, &backbuffer_0_rtv_srgb); flags &= D3D11_FORMAT_SUPPORT_BACK_BUFFER_CAST; flags = (FAILED(hr) && !flags) || (SUCCEEDED(hr) && flags); - todo_wine ok(flags, "Got unexpected for SRGB rtv vs swapchain UNORM, hr %#lx.\n", hr); + ok(flags, "Got unexpected for SRGB rtv vs swapchain UNORM, hr %#lx.\n", hr); if (SUCCEEDED(hr)) { ID3D11DeviceContext_ClearRenderTargetView(context, backbuffer_0_rtv_srgb, grey); color = get_texture_color(backbuffer_0, 320, 240); /* grey */ - todo_wine ok(compare_color(color, 0x80bcbcbc, 1), "Got unexpected srgb color 0x%08lx.\n", color); + ok(compare_color(color, 0x80bcbcbc, 1), "Got unexpected srgb color 0x%08lx.\n", color); } ID3D11DeviceContext_ClearRenderTargetView(context, backbuffer_0_rtv, red); -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/10567
Perhaps not unexpectedly, this MR is getting pretty large, as these things tend to. I recommend splitting the test and format support changes into a separate MR.
```diff + hr = ID3D10Device_CheckFormatSupport(device, rtv_desc.Format, &flags); + ok(SUCCEEDED(hr), "Got unexpected hr %#lx.\n", hr); + hr = ID3D10Device_CreateRenderTargetView(device, (ID3D10Resource *)backbuffer_0, &rtv_desc, &backbuffer_0_rtv_srgb); + flags &= D3D10_FORMAT_SUPPORT_BACK_BUFFER_CAST; + flags = (FAILED(hr) && !flags) || (SUCCEEDED(hr) && flags); + todo_wine ok(flags, "Got unexpected for SRGB rtv for UNORM swapchain, hr %#lx.\n", hr); ```
That's a little awkward. I'd suggest something like this: ```c ... expect_hr = flags & D3D10_FORMAT_SUPPORT_BACK_BUFFER_CAST ? S_OK : E_INVALIDARG; hr = ID3D10Device_CreateRenderTargetView(...); ok(hr == expect_hr, "Got hr %#lx, expected %#lx\n", hr, expect_hr); ```
```diff +struct wined3d_swapchain * __cdecl wined3d_swapchain_from_resource(struct wined3d_resource *resource) +{ + return swapchain_from_resource(resource); +} ```
I don't think we need/want wined3d_swapchain_from_resource(). It seems you're using this mainly in d3d11's d3d_rendertarget_view_init() to validate WINED3D_FORMAT_CAP_BACK_BUFFER_CAST support, but if we're going to call into wined3d anyway, we may as well just do that validation inside wined3d. The most convenient place for that is probably validate_resource_view(). There may be a case for swapchain_from_resource() in principle, but in the places where you're using it, it's just a replacement for "texture_vk->t.swapchain" and "texture_gl->t.swapchain".
```diff {WINED3DFMT_R8G8B8A8_UNORM, GL_RGBA8, GL_SRGB8_ALPHA8_EXT, 0, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, 0, WINED3D_FORMAT_CAP_TEXTURE | WINED3D_FORMAT_CAP_POSTPIXELSHADER_BLENDING | WINED3D_FORMAT_CAP_FILTERING | WINED3D_FORMAT_CAP_RENDERTARGET | WINED3D_FORMAT_CAP_SRGB_READ | WINED3D_FORMAT_CAP_SRGB_WRITE - | WINED3D_FORMAT_CAP_VTF, + | WINED3D_FORMAT_CAP_VTF | WINED3D_FORMAT_CAP_BACK_BUFFER_CAST, WINED3D_GL_EXT_NONE, NULL}, ```
I'd add this to format_base_flags[], that would also avoid accessing format_texture_info[] from Vulkan code.
```diff +static void wined3d_swapchain_rendertarget_view_gl_rotate(struct wined3d_swapchain *swapchain) +{ + struct wined3d_swapchain_rendertarget_view_gl *swap_view_gl; + struct wined3d_swapchain_rendertarget_view *swap_view; + struct wined3d_rendertarget_view_gl *view_gl; + GLuint name, name_prev; + + if (!swapchain || swapchain->state.desc.backbuffer_count < 2) + return; ```
I don't think wined3d_swapchain_rendertarget_view_gl_rotate() should ever get called in that case.
```diff +struct wined3d_swapchain_rendertarget_view_gl +{ + struct list entry; + GLuint name; +}; + struct wined3d_rendertarget_view_gl { struct wined3d_rendertarget_view v; struct wined3d_gl_view gl_view; + struct list swapchain_views; }; ```
I think Elizabeth was getting at this, but if we have a struct wined3d_rendertarget_view_gl like this: ```c struct wined3d_rendertarget_view_gl { struct wined3d_rendertarget_view v; struct wined3d_swapchain_view swapchain_view; struct wined3d_gl_view gl_view[1]; }; ``` we can then allocate it like this: ```c count = ...; ... view_gl = calloc(1, offsetof(struct wined3d_rendertarget_view_gl, gl_view[count])); ``` in adapter_gl_create_rendertarget_view(), and get a gl_view[] of the appropriate length.
GL_FRAMEBUFFER_SRGB has been moved back to texture2d_blt_fbo with a condition for resolve_format WINED3D_FORMAT_CAP_SRGB_WRITE. Unclear if this is actually correct but it fixes tests and Frostpunk.
It seems suspicious to me. The way I understand the issue, we should be disabling GL_FRAMEBUFFER_SRGB when copying to/from WINED3D_LOCATION_DRAWABLE, or alternatively simply always when the source and destination formats are the same. -- https://gitlab.winehq.org/wine/wine/-/merge_requests/10567#note_144547
On Tue Jun 30 17:51:15 2026 +0000, Henri Verbeet wrote:
Perhaps not unexpectedly, this MR is getting pretty large, as these things tend to. I recommend splitting the test and format support changes into a separate MR.
```diff + hr = ID3D10Device_CheckFormatSupport(device, rtv_desc.Format, &flags); + ok(SUCCEEDED(hr), "Got unexpected hr %#lx.\n", hr); + hr = ID3D10Device_CreateRenderTargetView(device, (ID3D10Resource
*)backbuffer_0, &rtv_desc, &backbuffer_0_rtv_srgb);
+ flags &= D3D10_FORMAT_SUPPORT_BACK_BUFFER_CAST; + flags = (FAILED(hr) && !flags) || (SUCCEEDED(hr) && flags); + todo_wine ok(flags, "Got unexpected for SRGB rtv for UNORM swapchain, hr %#lx.\n", hr); ``` That's a little awkward. I'd suggest something like this:
... expect_hr = flags & D3D10_FORMAT_SUPPORT_BACK_BUFFER_CAST ? S_OK : E_INVALIDARG; hr = ID3D10Device_CreateRenderTargetView(...); ok(hr == expect_hr, "Got hr %#lx, expected %#lx\n", hr, expect_hr);```diff +struct wined3d_swapchain * __cdecl
wined3d_swapchain_from_resource(struct wined3d_resource *resource)
+{ + return swapchain_from_resource(resource); +} ``` I don't think we need/want wined3d_swapchain_from_resource(). It seems you're using this mainly in d3d11's d3d_rendertarget_view_init() to validate WINED3D_FORMAT_CAP_BACK_BUFFER_CAST support, but if we're going to call into wined3d anyway, we may as well just do that validation inside wined3d. The most convenient place for that is probably validate_resource_view(). There may be a case for swapchain_from_resource() in principle, but in the places where you're using it, it's just a replacement for "texture_vk->t.swapchain" and "texture_gl->t.swapchain". ```diff {WINED3DFMT_R8G8B8A8_UNORM, GL_RGBA8, GL_SRGB8_ALPHA8_EXT, 0, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, 0, WINED3D_FORMAT_CAP_TEXTURE | WINED3D_FORMAT_CAP_POSTPIXELSHADER_BLENDING | WINED3D_FORMAT_CAP_FILTERING | WINED3D_FORMAT_CAP_RENDERTARGET | WINED3D_FORMAT_CAP_SRGB_READ | WINED3D_FORMAT_CAP_SRGB_WRITE - | WINED3D_FORMAT_CAP_VTF, + | WINED3D_FORMAT_CAP_VTF | WINED3D_FORMAT_CAP_BACK_BUFFER_CAST, WINED3D_GL_EXT_NONE, NULL}, ``` I'd add this to format_base_flags[], that would also avoid accessing format_texture_info[] from Vulkan code. ```diff +static void wined3d_swapchain_rendertarget_view_gl_rotate(struct wined3d_swapchain *swapchain) +{ + struct wined3d_swapchain_rendertarget_view_gl *swap_view_gl; + struct wined3d_swapchain_rendertarget_view *swap_view; + struct wined3d_rendertarget_view_gl *view_gl; + GLuint name, name_prev; + + if (!swapchain || swapchain->state.desc.backbuffer_count < 2) + return; ``` I don't think wined3d_swapchain_rendertarget_view_gl_rotate() should ever get called in that case. ```diff +struct wined3d_swapchain_rendertarget_view_gl +{ + struct list entry; + GLuint name; +}; + struct wined3d_rendertarget_view_gl { struct wined3d_rendertarget_view v; struct wined3d_gl_view gl_view; + struct list swapchain_views; }; ``` I think Elizabeth was getting at this, but if we have a struct wined3d_rendertarget_view_gl like this:
struct wined3d_rendertarget_view_gl { struct wined3d_rendertarget_view v; struct wined3d_swapchain_view swapchain_view; struct wined3d_gl_view gl_view[1]; };we can then allocate it like this: ```c count = ...; ... view_gl = calloc(1, offsetof(struct wined3d_rendertarget_view_gl, gl_view[count])); ``` in adapter_gl_create_rendertarget_view(), and get a gl_view[] of the appropriate length.
GL_FRAMEBUFFER_SRGB has been moved back to texture2d_blt_fbo with a condition for resolve_format WINED3D_FORMAT_CAP_SRGB_WRITE. Unclear if this is actually correct but it fixes tests and Frostpunk. It seems suspicious to me. The way I understand the issue, we should be disabling GL_FRAMEBUFFER_SRGB when copying to/from WINED3D_LOCATION_DRAWABLE, or alternatively simply always when the source and destination formats are the same. Thanks for review @hverbeet
I'll split `ID3D11Device_CheckFormatSupport` as a separate MR which was the only real use case for `swapchain_from_resource` so I'll also remove it from this MR. I indeed seem to have gotten confused about `wined3d_rendertarget_view_gl` which seems clear now so I'll switch it back but with correct impl this time. I'll adjust `texture2d_blt_fbo` based on your suggestions to determine if it works. -- https://gitlab.winehq.org/wine/wine/-/merge_requests/10567#note_144549
participants (3)
-
Henri Verbeet (＠hverbeet) -
Stian Low
-
Stian Low (＠stianlow)