From: Stian Low <wineryyyyy@gmail.com> --- dlls/d3d10core/tests/d3d10core.c | 8 +- dlls/d3d11/device.c | 3 +- dlls/d3d11/tests/d3d11.c | 6 +- dlls/d3d11/view.c | 36 +++++++- dlls/wined3d/adapter_gl.c | 53 ++++++++--- dlls/wined3d/adapter_vk.c | 38 +++++++- dlls/wined3d/directx.c | 10 ++ dlls/wined3d/swapchain.c | 85 ++++++++++++++++- dlls/wined3d/texture_gl.c | 6 ++ dlls/wined3d/utils.c | 35 ++++++- dlls/wined3d/view.c | 153 +++++++++++++++++++++++++------ dlls/wined3d/wined3d.spec | 1 + dlls/wined3d/wined3d_gl.h | 7 ++ dlls/wined3d/wined3d_private.h | 19 +++- dlls/wined3d/wined3d_vk.h | 7 ++ include/wine/wined3d.h | 4 +- 16 files changed, 410 insertions(+), 61 deletions(-) diff --git a/dlls/d3d10core/tests/d3d10core.c b/dlls/d3d10core/tests/d3d10core.c index fb5482c484c..ff78ac23b9e 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); ID3D10RenderTargetView_Release(backbuffer_0_rtv_srgb); } diff --git a/dlls/d3d11/device.c b/dlls/d3d11/device.c index e1a846698e6..ceeeee40cc5 100644 --- a/dlls/d3d11/device.c +++ b/dlls/d3d11/device.c @@ -4631,10 +4631,11 @@ 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, WINED3D_BIND_RENDER_TARGET, WINED3DUSAGE_QUERY_BACKBUFFER_CAST, D3D11_FORMAT_SUPPORT_BACK_BUFFER_CAST}, }; HRESULT hr; - FIXME("iface %p, format %u, format_support %p partial-stub!\n", iface, format, format_support); + TRACE("iface %p, format %u, format_support %p partial-stub!\n", iface, format, format_support); wined3d_format = wined3dformat_from_dxgi_format(format); if (format && !wined3d_format) diff --git a/dlls/d3d11/tests/d3d11.c b/dlls/d3d11/tests/d3d11.c index 7b45dafbdb3..5adbf2c977c 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); diff --git a/dlls/d3d11/view.c b/dlls/d3d11/view.c index ec55dba5cf3..5acd410e2bb 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; @@ -1732,10 +1733,43 @@ static HRESULT d3d_rendertarget_view_init(struct d3d_rendertarget_view *view, st { wined3d_mutex_unlock(); ERR("Failed to get wined3d resource for d3d11 resource %p.\n", resource); - return E_FAIL; + return E_INVALIDARG; } 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; + } + + if (desc) + { + UINT flags; + + if (FAILED(hr = ID3D11Device_CheckFormatSupport((ID3D11Device*)&device->ID3D11Device5_iface, desc->Format, &flags))) + { + wined3d_mutex_unlock(); + ERR("Failed to get format support\n"); + return hr; + } + + flags &= D3D11_FORMAT_SUPPORT_BACK_BUFFER_CAST; + if (!flags) + { + wined3d_mutex_unlock(); + ERR("Casting format for swapchain backbuffer not supported\n"); + return E_INVALIDARG; + } + } + + } + + if (FAILED(hr = wined3d_rendertarget_view_create(&wined3d_desc, wined3d_resource, view, &d3d_render_target_view_wined3d_parent_ops, &view->wined3d_view))) { diff --git a/dlls/wined3d/adapter_gl.c b/dlls/wined3d/adapter_gl.c index 35f73b64497..94de4329577 100644 --- a/dlls/wined3d/adapter_gl.c +++ b/dlls/wined3d/adapter_gl.c @@ -4561,7 +4561,7 @@ static HRESULT adapter_gl_create_rendertarget_view(const struct wined3d_view_des struct wined3d_resource *resource, void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_rendertarget_view **view) { - struct wined3d_rendertarget_view_gl *view_gl; + struct wined3d_rendertarget_view_gl *view_gl = NULL; HRESULT hr; TRACE("desc %s, resource %p, parent %p, parent_ops %p, view %p.\n", @@ -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,36 @@ 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_swapchain_rendertarget_view *swap_view, *swap_view_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; + } + + LIST_FOR_EACH_ENTRY_SAFE(swap_view, swap_view_next, &swapchain->back_buffer_rendertarget_views, struct wined3d_swapchain_rendertarget_view, entry) + { + if (swap_view->view != &view_gl->v) + continue; + + list_remove(&swap_view->entry); + free(swap_view); + swap_view = swap_view_next; + break; + } +} + 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 +4683,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 +4722,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 +4759,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/adapter_vk.c b/dlls/wined3d/adapter_vk.c index 79014b4c331..a4499960cc0 100644 --- a/dlls/wined3d/adapter_vk.c +++ b/dlls/wined3d/adapter_vk.c @@ -1393,7 +1393,8 @@ static HRESULT adapter_vk_create_rendertarget_view(const struct wined3d_view_des struct wined3d_resource *resource, void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_rendertarget_view **view) { - struct wined3d_rendertarget_view_vk *view_vk; + struct wined3d_rendertarget_view_vk *view_vk = NULL; + HRESULT hr; TRACE("desc %s, resource %p, parent %p, parent_ops %p, view %p.\n", @@ -1515,6 +1516,37 @@ 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_swapchain_rendertarget_view *swap_view, *swap_view_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; + } + + LIST_FOR_EACH_ENTRY_SAFE(swap_view, swap_view_next, &swapchain->back_buffer_rendertarget_views, struct wined3d_swapchain_rendertarget_view, entry) + { + if (swap_view->view != &view_vk->v) + continue; + + list_remove(&swap_view->entry); + free(swap_view); + swap_view = swap_view_next; + break; + } +} + 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,9 +1554,9 @@ 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); + wined3d_view_vk_destroy(resource->device, NULL, &view_vk->vk_image_view, NULL, NULL, NULL, &view_vk->command_buffer_id, view_vk); } static HRESULT adapter_vk_create_shader_resource_view(const struct wined3d_view_desc *desc, diff --git a/dlls/wined3d/directx.c b/dlls/wined3d/directx.c index 19ec8070dd9..889b4cc3f0c 100644 --- a/dlls/wined3d/directx.c +++ b/dlls/wined3d/directx.c @@ -2025,10 +2025,15 @@ HRESULT CDECL wined3d_check_device_format(const struct wined3d *wined3d, allowed_usage = WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING; if (bind_flags & WINED3D_BIND_RENDER_TARGET) allowed_usage |= WINED3DUSAGE_QUERY_SRGBWRITE; + allowed_bind_flags = WINED3D_BIND_RENDER_TARGET | WINED3D_BIND_DEPTH_STENCIL | WINED3D_BIND_UNORDERED_ACCESS; gl_type = gl_type_end = WINED3D_GL_RES_TYPE_TEX_2D; + + if ((usage & WINED3DUSAGE_QUERY_BACKBUFFER_CAST)) + allowed_usage |= WINED3DUSAGE_QUERY_BACKBUFFER_CAST; + if (!(bind_flags & WINED3D_BIND_SHADER_RESOURCE)) { if (!wined3d_check_surface_format(format)) @@ -2119,6 +2124,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_BACKBUFFER_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 +2138,9 @@ 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/swapchain.c b/dlls/wined3d/swapchain.c index c26df770cdb..2b1f08810e0 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); @@ -533,16 +538,49 @@ static void swapchain_gl_set_swap_interval(struct wined3d_swapchain *swapchain, } } +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; + } +} + /* Context activation is done by the caller. */ static void wined3d_swapchain_gl_rotate(struct wined3d_swapchain *swapchain, struct wined3d_context *context) { + static const DWORD supported_locations = WINED3D_LOCATION_TEXTURE_RGB | WINED3D_LOCATION_RB_MULTISAMPLE; struct wined3d_texture_sub_resource *sub_resource; struct wined3d_texture_gl *texture, *texture_prev; struct gl_texture tex0; - GLuint rb0; DWORD locations0; unsigned int i; - static const DWORD supported_locations = WINED3D_LOCATION_TEXTURE_RGB | WINED3D_LOCATION_RB_MULTISAMPLE; + GLuint rb0; if (swapchain->state.desc.backbuffer_count < 2) return; @@ -554,6 +592,7 @@ static void wined3d_swapchain_gl_rotate(struct wined3d_swapchain *swapchain, str rb0 = texture_prev->rb_multisample; locations0 = texture_prev->t.sub_resources[0].locations; + for (i = 1; i < swapchain->state.desc.backbuffer_count; ++i) { texture = wined3d_texture_gl(swapchain->back_buffers[i]); @@ -574,6 +613,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)); @@ -1195,6 +1236,42 @@ static VkResult wined3d_swapchain_vk_blit(struct wined3d_swapchain_vk *swapchain return vr; } +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; + } +} + static void wined3d_swapchain_vk_rotate(struct wined3d_swapchain *swapchain, struct wined3d_context_vk *context_vk) { struct wined3d_texture_sub_resource *sub_resource; @@ -1244,6 +1321,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)); @@ -1746,6 +1825,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); } @@ -1759,6 +1839,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/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()"); diff --git a/dlls/wined3d/utils.c b/dlls/wined3d/utils.c index 0fb90ba3f18..3ae8c520802 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,35 @@ 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/view.c b/dlls/wined3d/view.c index a506b0c6f18..97bc2916f1a 100644 --- a/dlls/wined3d/view.c +++ b/dlls/wined3d/view.c @@ -587,48 +587,99 @@ 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_swapchain_rendertarget_view *lview = NULL; struct wined3d_resource *resource = view_gl->v.resource; const struct wined3d_view_desc *desc = &view_gl->v.desc; + 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); - 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 (!view_gl->gl_view.name) + { + ERR("Failed to create render target view for resource %p\n", resource); + /* TODO: cleanup gl, mem? */ + 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"); + 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: cleanup gl, mem? */ + break; + } + view_gl->gl_view.name = name; + context_release(context); + + if (!(lview = calloc(1, sizeof(*lview)))) + { + ERR("Out of memory.\n"); + /* TODO: cleanup gl, mem? */ + 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, @@ -697,6 +748,7 @@ HRESULT wined3d_rendertarget_view_gl_init(struct wined3d_rendertarget_view_gl *v TRACE("view_gl %p, desc %s, resource %p, parent %p, parent_ops %p.\n", view_gl, wined3d_debug_view_desc(desc, resource), resource, parent, parent_ops); + list_init(&view_gl->swapchain_views); if (FAILED(hr = wined3d_rendertarget_view_init(&view_gl->v, desc, resource, parent, parent_ops))) return hr; @@ -896,14 +948,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_swapchain_rendertarget_view *lview = NULL; struct wined3d_rendertarget_view_vk *view_vk = object; struct wined3d_view_desc *desc = &view_vk->v.desc; 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); @@ -930,12 +986,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) @@ -947,8 +997,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: cleanup gl, mem? */ + 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"); + return; + } + + list_add_head(&view_vk->swapchain_views, &swap_view_vk->entry); + texture_vk = wined3d_texture_vk(swapchain->back_buffers[i + 1]); + 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); + + if (view_vk->vk_image_view) + continue; + + ERR("Failed to create render target view for swapchain %p backbuffer[%u]\n", swapchain, i); + /* TODO: cleanup gl, mem? */ + break; + } + context_release(context); + + if (!(lview = calloc(1, sizeof(*lview)))) + { + ERR("Out of memory.\n"); + /* TODO: cleanup gl, mem? */ + 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)); } @@ -961,6 +1052,7 @@ HRESULT wined3d_rendertarget_view_vk_init(struct wined3d_rendertarget_view_vk *v TRACE("view_vk %p, desc %s, resource %p, parent %p, parent_ops %p.\n", view_vk, wined3d_debug_view_desc(desc, resource), resource, parent, parent_ops); + list_init(&view_vk->swapchain_views); if (FAILED(hr = wined3d_rendertarget_view_init(&view_vk->v, desc, resource, parent, parent_ops))) return hr; @@ -979,6 +1071,7 @@ HRESULT CDECL wined3d_rendertarget_view_create(const struct wined3d_view_desc *d wined3d_debug_view_desc(desc, resource), resource, parent, parent_ops, view); adapter_ops = resource->device->adapter->adapter_ops; + return adapter_ops->adapter_create_rendertarget_view(desc, resource, parent, parent_ops, view); } diff --git a/dlls/wined3d/wined3d.spec b/dlls/wined3d/wined3d.spec index e08dd089521..00438617093 100644 --- a/dlls/wined3d/wined3d.spec +++ b/dlls/wined3d/wined3d.spec @@ -306,6 +306,7 @@ @ cdecl wined3d_swapchain_get_parent(ptr) @ cdecl wined3d_swapchain_get_raster_status(ptr ptr) @ cdecl wined3d_swapchain_get_state(ptr) +@ cdecl wined3d_swapchain_from_resource(ptr) @ cdecl wined3d_swapchain_incref(ptr) @ cdecl wined3d_swapchain_present(ptr ptr ptr ptr long long) @ cdecl wined3d_swapchain_resize_buffers(ptr long long long long long long) 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( diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index e4e0cf24dc7..390cba42713 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -3563,8 +3563,7 @@ BOOL wined3d_texture_prepare_location(struct wined3d_texture *texture, unsigned struct wined3d_context *context, uint32_t location); void wined3d_texture_set_swapchain(struct wined3d_texture *texture, struct wined3d_swapchain *swapchain); -BOOL wined3d_texture_can_use_pbo(const struct wined3d_texture *texture, const struct wined3d_d3d_info *d3d_info) - ; +BOOL wined3d_texture_can_use_pbo(const struct wined3d_texture *texture, const struct wined3d_d3d_info *d3d_info); void wined3d_texture_sub_resources_destroyed(struct wined3d_texture *texture); void wined3d_texture_translate_drawable_coords(const struct wined3d_texture *texture, HWND window, RECT *rect); @@ -4094,6 +4093,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 +4109,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; @@ -4121,6 +4127,14 @@ struct wined3d_swapchain HDC dc; }; +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; +} + void wined3d_swapchain_activate(struct wined3d_swapchain *swapchain, BOOL activate); void wined3d_swapchain_cleanup(struct wined3d_swapchain *swapchain); struct wined3d_output * wined3d_swapchain_get_output(const struct wined3d_swapchain *swapchain); @@ -4563,6 +4577,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/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( diff --git a/include/wine/wined3d.h b/include/wine/wined3d.h index 355140043db..9425e07d1dd 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_BACKBUFFER_CAST 0x00400000 +#define WINED3DUSAGE_QUERY_MASK 0x007f8400 #define WINED3D_MAP_NOSYSLOCK 0x00000800 #define WINED3D_MAP_NOOVERWRITE 0x00001000 @@ -2914,6 +2915,7 @@ void __cdecl wined3d_swapchain_get_desc(const struct wined3d_swapchain *swapchai HRESULT __cdecl wined3d_swapchain_get_raster_status(const struct wined3d_swapchain *swapchain, struct wined3d_raster_status *raster_status); struct wined3d_swapchain_state * __cdecl wined3d_swapchain_get_state(struct wined3d_swapchain *swapchain); +struct wined3d_swapchain * __cdecl wined3d_swapchain_from_resource(struct wined3d_resource *resource); ULONG __cdecl wined3d_swapchain_incref(struct wined3d_swapchain *swapchain); HRESULT __cdecl wined3d_swapchain_present(struct wined3d_swapchain *swapchain, const RECT *src_rect, const RECT *dst_rect, HWND dst_window_override, unsigned int swap_interval, uint32_t flags); -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/10567