December 2019 - Wine-Devel - list.winehq.org

[PATCH 02/10] d3d10: Implement scalar effect variable set methods.

by Connor McAdams

Implement SetFloat/SetFloatArray, SetInt/SetIntArray, and SetBool/SetBoolArray methods for the scalar effect variable interface. Signed-off-by: Connor McAdams <conmanx360(a)gmail.com> --- dlls/d3d10/effect.c | 83 ++++++++++++++++++++++++++++++++++++++------- 1 file changed, 71 insertions(+), 12 deletions(-) diff --git a/dlls/d3d10/effect.c b/dlls/d3d10/effect.c index f0932409b1..4ecc0753de 100644 --- a/dlls/d3d10/effect.c +++ b/dlls/d3d10/effect.c @@ -4212,6 +4212,43 @@ static const struct ID3D10EffectConstantBufferVtbl d3d10_effect_constant_buffer_ d3d10_effect_constant_buffer_GetTextureBuffer, }; +static inline void write_variable_to_cbuffer(struct d3d10_effect_variable *variable, void *data) +{ + memcpy(variable->buffer->u.buffer.local_buffer + variable->buffer_offset, data, variable->type->size_packed); + + variable->buffer->u.buffer.changed = 1; +} + +static void write_variable_array_to_cbuffer(struct d3d10_effect_variable *variable, void *data, UINT count) +{ + char *cbuf = variable->buffer->u.buffer.local_buffer + variable->buffer_offset; + char *cur_element = data; + DWORD element_size; + UINT i; + + /* + * If for some reason we try to use an array write on a variable that + * isn't an array, just default back to the normal variable write. + */ + if (!variable->type->element_count) + { + write_variable_to_cbuffer(variable, data); + return; + } + + element_size = variable->type->elementtype->size_packed; + + for (i = 0; i < count; i++) + { + memcpy(cbuf, cur_element, element_size); + + cur_element += element_size; + cbuf += variable->type->stride; + } + + variable->buffer->u.buffer.changed = 1; +} + /* ID3D10EffectVariable methods */ static BOOL STDMETHODCALLTYPE d3d10_effect_scalar_variable_IsValid(ID3D10EffectScalarVariable *iface) @@ -4370,9 +4407,12 @@ static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetRawValue(ID3D10 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetFloat(ID3D10EffectScalarVariable *iface, float value) { - FIXME("iface %p, value %.8e stub!\n", iface, value); + struct d3d10_effect_variable *effect_var = impl_from_ID3D10EffectVariable((ID3D10EffectVariable *)iface); - return E_NOTIMPL; + TRACE("iface %p, value %.8e.\n", iface, value); + write_variable_to_cbuffer(effect_var, &value); + + return S_OK; } static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetFloat(ID3D10EffectScalarVariable *iface, @@ -4383,12 +4423,19 @@ static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetFloat(ID3D10Eff return E_NOTIMPL; } +/* + * According to MSDN, array writing functions for Scalar/Vector effect + * variables have offset go unused. + */ static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetFloatArray(ID3D10EffectScalarVariable *iface, float *values, UINT offset, UINT count) { - FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count); + struct d3d10_effect_variable *effect_var = impl_from_ID3D10EffectVariable((ID3D10EffectVariable *)iface); - return E_NOTIMPL; + TRACE("iface %p, values %p, offset %u, count %u.\n", iface, values, offset, count); + write_variable_array_to_cbuffer(effect_var, values, count); + + return S_OK; } static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetFloatArray(ID3D10EffectScalarVariable *iface, @@ -4402,9 +4449,12 @@ static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetFloatArray(ID3D static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetInt(ID3D10EffectScalarVariable *iface, int value) { - FIXME("iface %p, value %d stub!\n", iface, value); + struct d3d10_effect_variable *effect_var = impl_from_ID3D10EffectVariable((ID3D10EffectVariable *)iface); - return E_NOTIMPL; + TRACE("iface %p, value %d.\n", iface, value); + write_variable_to_cbuffer(effect_var, &value); + + return S_OK; } static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetInt(ID3D10EffectScalarVariable *iface, @@ -4418,9 +4468,12 @@ static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetInt(ID3D10Effec static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetIntArray(ID3D10EffectScalarVariable *iface, int *values, UINT offset, UINT count) { - FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count); + struct d3d10_effect_variable *effect_var = impl_from_ID3D10EffectVariable((ID3D10EffectVariable *)iface); - return E_NOTIMPL; + TRACE("iface %p, values %p, offset %u, count %u.\n", iface, values, offset, count); + write_variable_array_to_cbuffer(effect_var, values, count); + + return S_OK; } static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetIntArray(ID3D10EffectScalarVariable *iface, @@ -4434,9 +4487,12 @@ static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetIntArray(ID3D10 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetBool(ID3D10EffectScalarVariable *iface, BOOL value) { - FIXME("iface %p, value %d stub!\n", iface, value); + struct d3d10_effect_variable *effect_var = impl_from_ID3D10EffectVariable((ID3D10EffectVariable *)iface); - return E_NOTIMPL; + TRACE("iface %p, value %d.\n", iface, value); + write_variable_to_cbuffer(effect_var, &value); + + return S_OK; } static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetBool(ID3D10EffectScalarVariable *iface, @@ -4450,9 +4506,12 @@ static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetBool(ID3D10Effe static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetBoolArray(ID3D10EffectScalarVariable *iface, BOOL *values, UINT offset, UINT count) { - FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count); + struct d3d10_effect_variable *effect_var = impl_from_ID3D10EffectVariable((ID3D10EffectVariable *)iface); - return E_NOTIMPL; + TRACE("iface %p, values %p, offset %u, count %u.\n", iface, values, offset, count); + write_variable_array_to_cbuffer(effect_var, values, count); + + return S_OK; } static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetBoolArray(ID3D10EffectScalarVariable *iface, -- 2.20.1

Dec. 7, 2019

[PATCH 01/10] d3d10: Allocate buffers for effect interface local_buffers.

by Connor McAdams

Create ID3D10Buffer interfaces for the constant buffers within the effect shader. Signed-off-by: Connor McAdams <conmanx360(a)gmail.com> --- dlls/d3d10/d3d10_private.h | 10 ++++++ dlls/d3d10/effect.c | 62 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 72 insertions(+) diff --git a/dlls/d3d10/d3d10_private.h b/dlls/d3d10/d3d10_private.h index 96020cd4a0..5c6c7a2d72 100644 --- a/dlls/d3d10/d3d10_private.h +++ b/dlls/d3d10/d3d10_private.h @@ -114,6 +114,15 @@ struct d3d10_effect_state_object_variable } object; }; +struct d3d10_effect_buffer_variable +{ + ID3D10Buffer *buffer; + ID3D10ShaderResourceView *resource_view; + + UINT changed; + char *local_buffer; +}; + /* ID3D10EffectType */ struct d3d10_effect_type { @@ -169,6 +178,7 @@ struct d3d10_effect_variable { struct d3d10_effect_state_object_variable state; struct d3d10_effect_shader_variable shader; + struct d3d10_effect_buffer_variable buffer; } u; }; diff --git a/dlls/d3d10/effect.c b/dlls/d3d10/effect.c index 91e713bdf5..f0932409b1 100644 --- a/dlls/d3d10/effect.c +++ b/dlls/d3d10/effect.c @@ -2096,6 +2096,53 @@ static HRESULT parse_fx10_local_variable(const char *data, size_t data_size, return S_OK; } +static HRESULT create_variable_buffer(struct d3d10_effect_variable *l, D3D10_CBUFFER_TYPE d3d10_cbuffer_type) +{ + D3D10_BUFFER_DESC buffer_desc; + D3D10_SUBRESOURCE_DATA subresource_data; + D3D10_SHADER_RESOURCE_VIEW_DESC srv_desc; + ID3D10Device *device = l->effect->device; + HRESULT hr; + + if (!(l->u.buffer.local_buffer = heap_calloc(l->type->size_unpacked, sizeof(unsigned char)))) + { + ERR("Failed to allocate local constant buffer memory.\n"); + return E_OUTOFMEMORY; + } + + buffer_desc.ByteWidth = l->type->size_unpacked; + buffer_desc.Usage = D3D10_USAGE_DEFAULT; + buffer_desc.CPUAccessFlags = 0; + buffer_desc.MiscFlags = 0; + if (d3d10_cbuffer_type == D3D10_CT_CBUFFER) + buffer_desc.BindFlags = D3D10_BIND_CONSTANT_BUFFER; + else if (d3d10_cbuffer_type == D3D10_CT_TBUFFER) + buffer_desc.BindFlags = D3D10_BIND_SHADER_RESOURCE; + + subresource_data.pSysMem = (const void *)l->u.buffer.local_buffer; + subresource_data.SysMemPitch = 0; + subresource_data.SysMemSlicePitch = 0; + + if (FAILED(hr = ID3D10Device_CreateBuffer(device, &buffer_desc, &subresource_data, &l->u.buffer.buffer))) + return hr; + + if (d3d10_cbuffer_type == D3D10_CT_TBUFFER) + { + srv_desc.Format = DXGI_FORMAT_R32G32B32A32_UINT; + srv_desc.ViewDimension = D3D_SRV_DIMENSION_BUFFER; + srv_desc.Buffer.ElementOffset = 0; + srv_desc.Buffer.ElementWidth = l->type->size_unpacked / 16; + + if (FAILED(hr = ID3D10Device_CreateShaderResourceView(device, (ID3D10Resource *)l->u.buffer.buffer, + (const D3D10_SHADER_RESOURCE_VIEW_DESC *)&srv_desc, &l->u.buffer.resource_view))) + return hr; + } + else + l->u.buffer.resource_view = NULL; + + return S_OK; +} + static HRESULT parse_fx10_local_buffer(const char *data, size_t data_size, const char **ptr, struct d3d10_effect_variable *l) { @@ -2282,6 +2329,12 @@ static HRESULT parse_fx10_local_buffer(const char *data, size_t data_size, TRACE("\tBasetype: %s.\n", debug_d3d10_shader_variable_type(l->type->basetype)); TRACE("\tTypeclass: %s.\n", debug_d3d10_shader_variable_class(l->type->type_class)); + if (l->type->size_unpacked && l->type->size_packed) + { + if (FAILED(hr = create_variable_buffer(l, d3d10_cbuffer_type))) + return hr; + } + return S_OK; } @@ -2760,6 +2813,15 @@ static void d3d10_effect_local_buffer_destroy(struct d3d10_effect_variable *l) } heap_free(l->annotations); } + + if (l->u.buffer.buffer) + ID3D10Buffer_Release(l->u.buffer.buffer); + + if (l->u.buffer.local_buffer) + heap_free(l->u.buffer.local_buffer); + + if (l->u.buffer.resource_view) + ID3D10ShaderResourceView_Release(l->u.buffer.resource_view); } /* IUnknown methods */ -- 2.20.1

Dec. 7, 2019

[PATCH 00/10] Implement d3d10 effect framework functionality

by Connor McAdams

Patch series to implement the functions that are used by steam big picture mode. Submitting for feedback/ideas on how to improve/change things. Connor McAdams (10): d3d10: Allocate buffers for effect interface local_buffers. d3d10: Implement scalar effect variable set methods. d3d10: Implement scalar effect variable get methods. d3d10: Implement vector effect variable set methods. d3d10: Implement vector effect variable get methods. d3d10: Implement matrix effect variable set methods. d3d10: Implement matrix effect variable get methods. d3d10: Implement ShaderResource effect variable set method. d3d10: Get resources used by effect shaders. d3d10: Apply shader resources for shaders used in pass. dlls/d3d10/d3d10_private.h | 28 ++ dlls/d3d10/effect.c | 758 +++++++++++++++++++++++++++++++++---- 2 files changed, 718 insertions(+), 68 deletions(-) -- 2.20.1

Dec. 7, 2019

Re: [wine-devel] Wine staging 4.21 release

by Olivier F. R. Dierick

Le samedi 07 décembre 2019 à 00:48 -0800, Alan W. Irwin a écrit : > On 2019-12-05 14:03+0100 Olivier F. R. Dierick wrote: > > > Le mercredi 04 décembre 2019 à 14:56 -0800, Alan W. Irwin a écrit : > > > On 2019-11-30 04:56-0000 Alistair Leslie-Hughes wrote: > > > > > > > Added: > > > > * [47668] kernelbase: Improve stub for ReOpenFile and add small > > > > > > [...] > > > > > > Could you explain how these patch numbers in your report are > > > related > > > with each other? > > > > > > > Hello, > > > > The numbers between brackets are winehq.org bugzilla bug numbers. > > > > Hi Olivier: > > Thanks for trying to be helpful, but your answer did not respond to > the question which was about how to account for the total number of > patches in each category mentioned in these reports. > Hello, Yes it did. The whole point is that you assume patch numbers where it is in fact patch sets referred to with bug numbers. That's why they don't account for the total number of patches. That is enough information for you to know that your assumptions are wrong and do a bit of research. You could have found that yourself had you put more effort into looking at the wine-staging code than into thinking out an over-complicated pointless formula. > Could you let me know what the correct formula is for predicting the > rebased patch number from report to report (which helps to evaluate > the reliability of the staging patch number statistics that you > present), and if that formula depends on information (my guess is it > is the number of patches in staging that have just been deleted by > thestaging maintainers because they judge those patches to not be > worthwhile) that you currently do not include in your reports, could > you include that important information in your following reports? What makes you think that the information in the report is not reliable? Have you anything against the staging maintainers? You're the only one that want to make a formula out of the reports. We don't have to provide you the formula you seek or provide the "important" (to you; What makes it important?) information that formula would need. Your whole 'predicting to evaluate the reliability of the report' thing is nonsense. Predicting the future number of patch from report statistics is pointless as the number of patches is determined by specific issues and development and there is no way to predict what will be done next, and it certainly doesn't depend on the previous changes. To me, you're just making ground for an argument in a convoluted way. Regards. -- Olivier F. R. Dierick o.dierick(a)piezo-forte.be

Dec. 7, 2019

Re: [PATCH 5/5] d3d9: Stop setting the device state when setting the default ZENABLE state.

by Marvin

Hi, While running your changed tests, I think I found new failures. Being a bot and all I'm not very good at pattern recognition, so I might be wrong, but could you please double-check? Full results can be found at: https://testbot.winehq.org/JobDetails.pl?Key=61574 Your paranoid android. === debian10 (32 bit report) === d3d9: Unhandled exception: page fault on read access to 0x00000000 in 32-bit code (0x7e8611a4). Report errors: d3d9:visual crashed (c0000005) === debian10 (32 bit Chinese:China report) === d3d9: Unhandled exception: page fault on read access to 0x00000000 in 32-bit code (0x7ead8738). Report errors: d3d9:visual crashed (c0000005) === debian10 (32 bit WoW report) === d3d9: Unhandled exception: page fault on read access to 0x00000000 in 32-bit code (0x7e85e738). Report errors: d3d9:visual crashed (c0000005) === debian10 (64 bit WoW report) === d3d9: Unhandled exception: page fault on read access to 0x00000000 in 32-bit code (0x7e85e738). Report errors: d3d9:visual crashed (c0000005)

Dec. 7, 2019

Re: [PATCH 4/5] d3d9: Stop setting the device state in d3d9_device_SetRenderState().

by Marvin

Hi, While running your changed tests, I think I found new failures. Being a bot and all I'm not very good at pattern recognition, so I might be wrong, but could you please double-check? Full results can be found at: https://testbot.winehq.org/JobDetails.pl?Key=61573 Your paranoid android. === debian10 (32 bit report) === d3d9: Unhandled exception: page fault on read access to 0x00000000 in 32-bit code (0x7e85e738). Report errors: d3d9:visual crashed (c0000005) === debian10 (32 bit Chinese:China report) === d3d9: Unhandled exception: page fault on read access to 0x00000000 in 32-bit code (0x7ead8738). Report errors: d3d9:visual crashed (c0000005) === debian10 (32 bit WoW report) === d3d9: Unhandled exception: page fault on read access to 0x00000000 in 32-bit code (0x7e85e738). Report errors: d3d9:visual crashed (c0000005) === debian10 (64 bit WoW report) === d3d9: Unhandled exception: page fault on read access to 0x00000000 in 32-bit code (0x7e8e4c70). Report errors: d3d9:visual crashed (c0000005)

Dec. 7, 2019

Re: [PATCH 3/5] d3d9: Handle multisample depth resolve in d3d9_device_SetRenderState().

by Marvin

Hi, While running your changed tests, I think I found new failures. Being a bot and all I'm not very good at pattern recognition, so I might be wrong, but could you please double-check? Full results can be found at: https://testbot.winehq.org/JobDetails.pl?Key=61572 Your paranoid android. === debian10 (32 bit report) === d3d9: Unhandled exception: page fault on read access to 0x00000000 in 32-bit code (0x7e8611a4). Report errors: d3d9:visual crashed (c0000005) === debian10 (32 bit Chinese:China report) === d3d9: Unhandled exception: page fault on read access to 0x00000000 in 32-bit code (0x7ead8738). Report errors: d3d9:visual crashed (c0000005) === debian10 (32 bit WoW report) === d3d9: Unhandled exception: page fault on read access to 0x00000000 in 32-bit code (0x7e8611a4). Report errors: d3d9:visual crashed (c0000005) === debian10 (64 bit WoW report) === d3d9: Unhandled exception: page fault on read access to 0x00000000 in 32-bit code (0x7e85e738). Report errors: d3d9:visual crashed (c0000005)

Dec. 7, 2019

Re: [PATCH 2/5] d3d9: Apply the device state before executing a draw call.

by Marvin

Hi, While running your changed tests, I think I found new failures. Being a bot and all I'm not very good at pattern recognition, so I might be wrong, but could you please double-check? Full results can be found at: https://testbot.winehq.org/JobDetails.pl?Key=61571 Your paranoid android. === debian10 (32 bit report) === d3d9: Unhandled exception: page fault on read access to 0x00000000 in 32-bit code (0x7e8611a4). Report errors: d3d9:visual crashed (c0000005) === debian10 (32 bit Chinese:China report) === d3d9: Unhandled exception: page fault on read access to 0x00000000 in 32-bit code (0x7eadb1a4). Report errors: d3d9:visual crashed (c0000005) === debian10 (32 bit WoW report) === d3d9: Unhandled exception: page fault on read access to 0x00000000 in 32-bit code (0x7e8611a4). Report errors: d3d9:visual crashed (c0000005) === debian10 (64 bit WoW report) === d3d9: Unhandled exception: page fault on read access to 0x00000000 in 32-bit code (0x7e85e738). Report errors: d3d9:visual crashed (c0000005)

Dec. 7, 2019

[PATCH 5/5] d3d9: Stop setting the device state when setting the default ZENABLE state.

by Zebediah Figura

Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- dlls/d3d9/device.c | 4 ---- 1 file changed, 4 deletions(-) diff --git a/dlls/d3d9/device.c b/dlls/d3d9/device.c index 54271240e11..a45f4baa21b 100644 --- a/dlls/d3d9/device.c +++ b/dlls/d3d9/device.c @@ -1020,8 +1020,6 @@ static HRESULT d3d9_device_reset(struct d3d9_device *device, device->auto_mipmaps = 0; wined3d_stateblock_set_render_state(device->state, WINED3D_RS_ZENABLE, !!swapchain_desc.enable_auto_depth_stencil); - wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_ZENABLE, - !!swapchain_desc.enable_auto_depth_stencil); device_reset_viewport_state(device); } @@ -4673,8 +4671,6 @@ HRESULT device_init(struct d3d9_device *device, struct d3d9 *parent, struct wine wined3d_stateblock_set_render_state(device->state, WINED3D_RS_ZENABLE, !!swapchain_desc->enable_auto_depth_stencil); - wined3d_device_set_render_state(device->wined3d_device, - WINED3D_RS_ZENABLE, !!swapchain_desc->enable_auto_depth_stencil); device_reset_viewport_state(device); if (FAILED(hr = d3d9_device_get_swapchains(device))) -- 2.23.0

Dec. 7, 2019

[PATCH 4/5] d3d9: Stop setting the device state in d3d9_device_SetRenderState().

by Zebediah Figura

Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- dlls/d3d9/device.c | 11 ----------- 1 file changed, 11 deletions(-) diff --git a/dlls/d3d9/device.c b/dlls/d3d9/device.c index 35364046936..54271240e11 100644 --- a/dlls/d3d9/device.c +++ b/dlls/d3d9/device.c @@ -2331,22 +2331,11 @@ static HRESULT WINAPI DECLSPEC_HOTPATCH d3d9_device_SetRenderState(IDirect3DDevi D3DRENDERSTATETYPE state, DWORD value) { struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); - struct wined3d_color factor; TRACE("iface %p, state %#x, value %#x.\n", iface, state, value); wined3d_mutex_lock(); wined3d_stateblock_set_render_state(device->update_state, state, value); - if (!device->recording) - { - if (state == D3DRS_BLENDFACTOR) - { - wined3d_color_from_d3dcolor(&factor, value); - wined3d_device_set_blend_state(device->wined3d_device, NULL, &factor); - } - else - wined3d_device_set_render_state(device->wined3d_device, state, value); - } if (state == D3DRS_POINTSIZE && value == WINED3D_RESZ_CODE) resolve_depth_buffer(device); wined3d_mutex_unlock(); -- 2.23.0

Dec. 7, 2019

[PATCH 3/5] d3d9: Handle multisample depth resolve in d3d9_device_SetRenderState().

by Zebediah Figura

Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- dlls/d3d9/device.c | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) diff --git a/dlls/d3d9/device.c b/dlls/d3d9/device.c index be9c2a9d5a1..35364046936 100644 --- a/dlls/d3d9/device.c +++ b/dlls/d3d9/device.c @@ -2299,6 +2299,34 @@ static HRESULT WINAPI d3d9_device_GetClipPlane(IDirect3DDevice9Ex *iface, DWORD return hr; } +static void resolve_depth_buffer(struct d3d9_device *device) +{ + const struct wined3d_stateblock_state *state = wined3d_stateblock_get_state(device->state); + struct wined3d_rendertarget_view *wined3d_dsv; + struct wined3d_resource *dst_resource; + struct wined3d_texture *dst_texture; + struct wined3d_resource_desc desc; + struct d3d9_surface *d3d9_dsv; + + if (!(dst_texture = state->textures[0])) + return; + dst_resource = wined3d_texture_get_resource(dst_texture); + wined3d_resource_get_desc(dst_resource, &desc); + if (desc.format != WINED3DFMT_D24_UNORM_S8_UINT + && desc.format != WINED3DFMT_X8D24_UNORM + && desc.format != MAKEFOURCC('D','F','1','6') + && desc.format != MAKEFOURCC('D','F','2','4') + && desc.format != WINED3DFMT_INTZ) + return; + + if (!(wined3d_dsv = wined3d_device_get_depth_stencil_view(device->wined3d_device))) + return; + d3d9_dsv = wined3d_rendertarget_view_get_sub_resource_parent(wined3d_dsv); + + wined3d_device_resolve_sub_resource(device->wined3d_device, dst_resource, 0, + wined3d_rendertarget_view_get_resource(wined3d_dsv), d3d9_dsv->sub_resource_idx, desc.format); +} + static HRESULT WINAPI DECLSPEC_HOTPATCH d3d9_device_SetRenderState(IDirect3DDevice9Ex *iface, D3DRENDERSTATETYPE state, DWORD value) { @@ -2319,6 +2347,8 @@ static HRESULT WINAPI DECLSPEC_HOTPATCH d3d9_device_SetRenderState(IDirect3DDevi else wined3d_device_set_render_state(device->wined3d_device, state, value); } + if (state == D3DRS_POINTSIZE && value == WINED3D_RESZ_CODE) + resolve_depth_buffer(device); wined3d_mutex_unlock(); return D3D_OK; -- 2.23.0

Dec. 7, 2019

[PATCH 2/5] d3d9: Apply the device state before executing a draw call.

by Zebediah Figura

Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- dlls/d3d9/device.c | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/dlls/d3d9/device.c b/dlls/d3d9/device.c index 82fba25ce73..be9c2a9d5a1 100644 --- a/dlls/d3d9/device.c +++ b/dlls/d3d9/device.c @@ -1821,6 +1821,7 @@ static HRESULT WINAPI d3d9_device_ColorFill(IDirect3DDevice9Ex *iface, return D3DERR_INVALIDCALL; } + wined3d_device_apply_stateblock(device->wined3d_device, device->state); rtv = d3d9_surface_acquire_rendertarget_view(surface_impl); hr = wined3d_device_clear_rendertarget_view(device->wined3d_device, rtv, rect, WINED3DCLEAR_TARGET, &c, 0.0f, 0); @@ -2071,6 +2072,7 @@ static HRESULT WINAPI d3d9_device_Clear(IDirect3DDevice9Ex *iface, DWORD rect_co wined3d_color_from_d3dcolor(&c, color); wined3d_mutex_lock(); + wined3d_device_apply_stateblock(device->wined3d_device, device->state); hr = wined3d_device_clear(device->wined3d_device, rect_count, (const RECT *)rects, flags, &c, z, stencil); if (SUCCEEDED(hr)) d3d9_rts_flag_auto_gen_mipmap(device); @@ -2654,6 +2656,7 @@ static HRESULT WINAPI d3d9_device_ValidateDevice(IDirect3DDevice9Ex *iface, DWOR TRACE("iface %p, pass_count %p.\n", iface, pass_count); wined3d_mutex_lock(); + wined3d_device_apply_stateblock(device->wined3d_device, device->state); hr = wined3d_device_validate_device(device->wined3d_device, pass_count); wined3d_mutex_unlock(); @@ -2885,6 +2888,7 @@ static HRESULT WINAPI d3d9_device_DrawPrimitive(IDirect3DDevice9Ex *iface, WARN("Called without a valid vertex declaration set.\n"); return D3DERR_INVALIDCALL; } + wined3d_device_apply_stateblock(device->wined3d_device, device->state); vertex_count = vertex_count_from_primitive_count(primitive_type, primitive_count); d3d9_device_upload_sysmem_vertex_buffers(device, 0, start_vertex, vertex_count); d3d9_generate_auto_mipmaps(device); @@ -2917,6 +2921,7 @@ static HRESULT WINAPI d3d9_device_DrawIndexedPrimitive(IDirect3DDevice9Ex *iface WARN("Called without a valid vertex declaration set.\n"); return D3DERR_INVALIDCALL; } + wined3d_device_apply_stateblock(device->wined3d_device, device->state); index_count = vertex_count_from_primitive_count(primitive_type, primitive_count); d3d9_device_upload_sysmem_vertex_buffers(device, base_vertex_idx, min_vertex_idx, vertex_count); d3d9_device_upload_sysmem_index_buffer(device, start_idx, index_count); @@ -3003,6 +3008,7 @@ static HRESULT WINAPI d3d9_device_DrawPrimitiveUP(IDirect3DDevice9Ex *iface, return D3DERR_INVALIDCALL; } + wined3d_device_apply_stateblock(device->wined3d_device, device->state); hr = d3d9_device_prepare_vertex_buffer(device, size); if (FAILED(hr)) goto done; @@ -3119,6 +3125,7 @@ static HRESULT WINAPI d3d9_device_DrawIndexedPrimitiveUP(IDirect3DDevice9Ex *ifa return D3DERR_INVALIDCALL; } + wined3d_device_apply_stateblock(device->wined3d_device, device->state); hr = d3d9_device_prepare_vertex_buffer(device, vtx_size); if (FAILED(hr)) goto done; @@ -3203,6 +3210,8 @@ static HRESULT WINAPI d3d9_device_ProcessVertices(IDirect3DDevice9Ex *iface, wined3d_mutex_lock(); + wined3d_device_apply_stateblock(device->wined3d_device, device->state); + /* Note that an alternative approach would be to simply create these * buffers with WINED3D_RESOURCE_ACCESS_MAP_R and update them here like we * do for draws. In some regards that would be easier, but it seems less -- 2.23.0

Dec. 7, 2019

[PATCH 1/5] wined3d: Introduce wined3d_device_apply_stateblock().

by Zebediah Figura

Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- dlls/wined3d/device.c | 93 +++++++++++++++++++++++++++++++++++++++ dlls/wined3d/wined3d.spec | 1 + include/wine/wined3d.h | 1 + 3 files changed, 95 insertions(+) diff --git a/dlls/wined3d/device.c b/dlls/wined3d/device.c index 0ae841d4e35..50029dfbec2 100644 --- a/dlls/wined3d/device.c +++ b/dlls/wined3d/device.c @@ -3829,6 +3829,99 @@ struct wined3d_texture * CDECL wined3d_device_get_texture(const struct wined3d_d return device->state.textures[stage]; } +void CDECL wined3d_device_apply_stateblock(struct wined3d_device *device, + struct wined3d_stateblock *stateblock) +{ + const struct wined3d_d3d_info *d3d_info = &stateblock->device->adapter->d3d_info; + const struct wined3d_stateblock_state *state = &stateblock->stateblock_state; + unsigned int i, j; + + TRACE("device %p, stateblock %p.\n", device, stateblock); + + wined3d_stateblock_init_contained_states(stateblock); + + wined3d_device_set_vertex_shader(device, state->vs); + wined3d_device_set_pixel_shader(device, state->ps); + + for (i = 0; i < d3d_info->limits.vs_uniform_count; ++i) + wined3d_device_set_vs_consts_f(device, i, 1, &state->vs_consts_f[i]); + for (i = 0; i < ARRAY_SIZE(state->vs_consts_i); ++i) + wined3d_device_set_vs_consts_i(device, i, 1, &state->vs_consts_i[i]); + for (i = 0; i < ARRAY_SIZE(state->vs_consts_b); ++i) + wined3d_device_set_vs_consts_b(device, i, 1, &state->vs_consts_b[i]); + + for (i = 0; i < ARRAY_SIZE(state->ps_consts_f); ++i) + wined3d_device_set_ps_consts_f(device, i, 1, &state->ps_consts_f[i]); + for (i = 0; i < ARRAY_SIZE(state->ps_consts_i); ++i) + wined3d_device_set_ps_consts_i(device, i, 1, &state->ps_consts_i[i]); + for (i = 0; i < ARRAY_SIZE(state->ps_consts_b); ++i) + wined3d_device_set_ps_consts_b(device, i, 1, &state->ps_consts_b[i]); + + for (i = 0; i < ARRAY_SIZE(state->light_state->light_map); ++i) + { + const struct wined3d_light_info *light; + + LIST_FOR_EACH_ENTRY(light, &state->light_state->light_map[i], struct wined3d_light_info, entry) + { + wined3d_device_set_light(device, light->OriginalIndex, &light->OriginalParms); + wined3d_device_set_light_enable(device, light->OriginalIndex, light->glIndex != -1); + } + } + + for (i = 0; i < ARRAY_SIZE(state->rs); ++i) + { + if (i == WINED3D_RS_BLENDFACTOR) + { + struct wined3d_color color; + wined3d_color_from_d3dcolor(&color, state->rs[i]); + wined3d_device_set_blend_state(device, NULL, &color); + } + else + wined3d_device_set_render_state(device, i, state->rs[i]); + } + + for (i = 0; i < ARRAY_SIZE(state->texture_states); ++i) + { + for (j = 0; j < ARRAY_SIZE(state->texture_states[i]); ++j) + wined3d_device_set_texture_stage_state(device, i, j, state->texture_states[i][j]); + } + + for (i = 0; i < ARRAY_SIZE(state->sampler_states); ++i) + { + DWORD stage = i; + if (stage >= WINED3D_MAX_FRAGMENT_SAMPLERS) stage += WINED3DVERTEXTEXTURESAMPLER0 - WINED3D_MAX_FRAGMENT_SAMPLERS; + for (j = 0; j < ARRAY_SIZE(state->sampler_states[j]); ++j) + wined3d_device_set_sampler_state(device, stage, j, state->sampler_states[i][j]); + } + + for (i = 0; i < ARRAY_SIZE(state->transforms); ++i) + wined3d_device_set_transform(device, i, &state->transforms[i]); + + wined3d_device_set_index_buffer(device, state->index_buffer, state->index_format, 0); + wined3d_device_set_base_vertex_index(device, state->base_vertex_index); + wined3d_device_set_vertex_declaration(device, state->vertex_declaration); + wined3d_device_set_material(device, &state->material); + wined3d_device_set_viewports(device, 1, &state->viewport); + wined3d_device_set_scissor_rects(device, 1, &state->scissor_rect); + + for (i = 0; i < ARRAY_SIZE(state->streams); ++i) + { + wined3d_device_set_stream_source(device, i, state->streams[i].buffer, + state->streams[i].offset, state->streams[i].stride); + wined3d_device_set_stream_source_freq(device, i, + state->streams[i].frequency | state->streams[i].flags); + } + + for (i = 0; i < ARRAY_SIZE(state->textures); ++i) + wined3d_device_set_texture(device, i < WINED3D_MAX_FRAGMENT_SAMPLERS ? i + : WINED3DVERTEXTEXTURESAMPLER0 + i - WINED3D_MAX_FRAGMENT_SAMPLERS, state->textures[i]); + + for (i = 0; i < ARRAY_SIZE(state->clip_planes); ++i) + wined3d_device_set_clip_plane(device, i, &state->clip_planes[i]); + + TRACE("Applied stateblock %p.\n", stateblock); +} + HRESULT CDECL wined3d_device_get_device_caps(const struct wined3d_device *device, struct wined3d_caps *caps) { TRACE("device %p, caps %p.\n", device, caps); diff --git a/dlls/wined3d/wined3d.spec b/dlls/wined3d/wined3d.spec index e03c57055b7..c8ef442c72d 100644 --- a/dlls/wined3d/wined3d.spec +++ b/dlls/wined3d/wined3d.spec @@ -37,6 +37,7 @@ @ cdecl wined3d_buffer_incref(ptr) @ cdecl wined3d_device_acquire_focus_window(ptr ptr) +@ cdecl wined3d_device_apply_stateblock(ptr ptr) @ cdecl wined3d_device_begin_scene(ptr) @ cdecl wined3d_device_clear(ptr long ptr long ptr float long) @ cdecl wined3d_device_clear_rendertarget_view(ptr ptr ptr long ptr float long) diff --git a/include/wine/wined3d.h b/include/wine/wined3d.h index 4b5d4e02f9b..a6eaaca468c 100644 --- a/include/wine/wined3d.h +++ b/include/wine/wined3d.h @@ -2287,6 +2287,7 @@ struct wined3d_resource * __cdecl wined3d_buffer_get_resource(struct wined3d_buf ULONG __cdecl wined3d_buffer_incref(struct wined3d_buffer *buffer); HRESULT __cdecl wined3d_device_acquire_focus_window(struct wined3d_device *device, HWND window); +void __cdecl wined3d_device_apply_stateblock(struct wined3d_device *device, struct wined3d_stateblock *stateblock); HRESULT __cdecl wined3d_device_begin_scene(struct wined3d_device *device); HRESULT __cdecl wined3d_device_clear(struct wined3d_device *device, DWORD rect_count, const RECT *rects, DWORD flags, const struct wined3d_color *color, float z, DWORD stencil); -- 2.23.0

Dec. 7, 2019

Re: [PATCH] wineqtdecoder: Fix macos compile error

by Zebediah Figura

On 12/7/19 12:03 AM, Alistair Leslie-Hughes wrote: > Regression of 498179b4482026091bf7376c0d2ac9a036e7ca0e > > Signed-off-by: Alistair Leslie-Hughes <leslie_alistair(a)hotmail.com> > --- > dlls/wineqtdecoder/qtsplitter.c | 10 ++++------ > 1 file changed, 4 insertions(+), 6 deletions(-) > Hello Alistair, thanks for catching these errors. > diff --git a/dlls/wineqtdecoder/qtsplitter.c b/dlls/wineqtdecoder/qtsplitter.c > index 5b1e82ebc9b..956dd0a7d0d 100644 > --- a/dlls/wineqtdecoder/qtsplitter.c > +++ b/dlls/wineqtdecoder/qtsplitter.c > @@ -285,7 +285,7 @@ static HRESULT qt_splitter_start_stream(struct strmbase_filter *iface, REFERENCE > QTSplitter *filter = impl_from_strmbase_filter(iface); > HRESULT hr = VFW_E_NOT_CONNECTED, pin_hr; > > - EnterCriticalSection(&This->csReceive); > + EnterCriticalSection(&filter->csReceive); > > if (filter->pVideo_Pin) > pin_hr = BaseOutputPinImpl_Active(&filter->pVideo_Pin->pin); > @@ -297,7 +297,7 @@ static HRESULT qt_splitter_start_stream(struct strmbase_filter *iface, REFERENCE > hr = pin_hr; > SetEvent(filter->runEvent); > > - LeaveCriticalSection(&This->csReceive); > + LeaveCriticalSection(&filter->csReceive); > > return hr; > } > @@ -306,10 +306,10 @@ static HRESULT qt_splitter_cleanup_stream(struct strmbase_filter *iface) > { > QTSplitter *filter = impl_from_strmbase_filter(iface); > > - EnterCriticalSection(&This->csReceive); > + EnterCriticalSection(&filter->csReceive); > IAsyncReader_BeginFlush(filter->pInputPin.pReader); > IAsyncReader_EndFlush(filter->pInputPin.pReader); > - LeaveCriticalSection(&This->csReceive); > + LeaveCriticalSection(&filter->csReceive); > > return S_OK; > } > @@ -1170,8 +1170,6 @@ static HRESULT WINAPI QTOutPin_QueryInterface(IPin *iface, REFIID riid, void **p > *ppv = iface; > else if (IsEqualIID(riid, &IID_IPin)) > *ppv = iface; > - else if (IsEqualIID(riid, &IID_IMediaSeeking)) > - *ppv = &This->sourceSeeking.IMediaSeeking_iface; > else if (IsEqualIID(riid, &IID_IQualityControl)) > *ppv = &This->IQualityControl_iface; > > Did you mean to do this?

Dec. 7, 2019

Re: Winter is coming

by Sveinar Søpler

All i want for christmas is... for someone to make a huge push towards releasing vkd3d_1.2, so that it would not pass yet another year to actually have working D3D12 out-of-the-box with a release version of wine :) Yeah, i know its a huge wish in the likes of "world peace" and the likes, but well.. one can always wish :) Sveinar On 06.12.2019 20:25, Alexandre Julliard wrote: > Folks, > > As you are probably aware, we are now entering the code freeze season. > The plan is to start the code freeze after the next release, i.e. one > week from today. So if there are things you want to see in Wine 5.0, now > is the last moment to submit them... >

Dec. 7, 2019

[PATCH vkd3d v4] Support RS 1.0 VOLATILE descriptors

by Sveinar Søpler

This fixes bug: https://bugs.winehq.org/show_bug.cgi?id=46410 v4: Rebase and resubmit patch. Original commit message: From: post(a)arntzen-software.no Use EXT_descriptor_indexing's UPDATE_AFTER_BIND feature to support semantics required by RS 1.0 VOLATILE descriptors. We implement this by deferring all updates of desciptor sets until Submit time. This is fine, as command buffers cannot be executed simultaneously on D3D12, so at Submit time, we know that the command buffer is not being executed on the GPU, and updating descriptors for multiple submissions is correct. If EXT_descriptor_indexing is not available, the fallback is the older method, which matches RS 1.1 STATIC descriptor model. Signed-off-by: Sveinar Søpler <cybermax(a)dexter.no>

Dec. 7, 2019

[PATCH vkd3d v4] Allocate one large buffer for a heap and offset into it.

by Hans-Kristian Arntzen

Greatly reduce VA allocations we have to make and makes returned VA more sensible, and better matches returned VAs we see on native drivers. D3D12 usage flags for buffers seem generic enough that there is no obvious benefit to place smaller VkBuffers on top of VkDeviceMemory. Ideally, physical_buffer_address is used here, but this works as a good fallback if that path is added later. With this patch and previous VA optimization, I'm observing a 2.0-2.5% FPS uplift on SOTTR when CPU bound. Signed-off-by: Hans-Kristian Arntzen <post(a)arntzen-software.no> --- libs/vkd3d/command.c | 14 ++-- libs/vkd3d/resource.c | 133 ++++++++++++++++++++++++++++++++----- libs/vkd3d/vkd3d_private.h | 2 + 3 files changed, 128 insertions(+), 21 deletions(-) diff --git a/libs/vkd3d/command.c b/libs/vkd3d/command.c index 8a7ff66..8bff7ea 100644 --- a/libs/vkd3d/command.c +++ b/libs/vkd3d/command.c @@ -3081,8 +3081,8 @@ static void STDMETHODCALLTYPE d3d12_command_list_CopyBufferRegion(ID3D12Graphics d3d12_command_list_end_current_render_pass(list); - buffer_copy.srcOffset = src_offset; - buffer_copy.dstOffset = dst_offset; + buffer_copy.srcOffset = src_offset + src_resource->heap_offset; + buffer_copy.dstOffset = dst_offset + dst_resource->heap_offset; buffer_copy.size = byte_count; VK_CALL(vkCmdCopyBuffer(list->vk_command_buffer, @@ -3395,6 +3395,7 @@ static void STDMETHODCALLTYPE d3d12_command_list_CopyTextureRegion(ID3D12Graphic vk_image_buffer_copy_from_d3d12(&buffer_image_copy, &dst->u.PlacedFootprint, src->u.SubresourceIndex, &src_resource->desc, dst_format, src_box, dst_x, dst_y, dst_z); + buffer_image_copy.bufferOffset += dst_resource->heap_offset; VK_CALL(vkCmdCopyImageToBuffer(list->vk_command_buffer, src_resource->u.vk_image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, dst_resource->u.vk_buffer, 1, &buffer_image_copy)); @@ -3424,6 +3425,7 @@ static void STDMETHODCALLTYPE d3d12_command_list_CopyTextureRegion(ID3D12Graphic vk_buffer_image_copy_from_d3d12(&buffer_image_copy, &src->u.PlacedFootprint, dst->u.SubresourceIndex, &dst_resource->desc, src_format, src_box, dst_x, dst_y, dst_z); + buffer_image_copy.bufferOffset += src_resource->heap_offset; VK_CALL(vkCmdCopyBufferToImage(list->vk_command_buffer, src_resource->u.vk_buffer, dst_resource->u.vk_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &buffer_image_copy)); @@ -3504,8 +3506,8 @@ static void STDMETHODCALLTYPE d3d12_command_list_CopyResource(ID3D12GraphicsComm assert(d3d12_resource_is_buffer(src_resource)); assert(src_resource->desc.Width == dst_resource->desc.Width); - vk_buffer_copy.srcOffset = 0; - vk_buffer_copy.dstOffset = 0; + vk_buffer_copy.srcOffset = src_resource->heap_offset; + vk_buffer_copy.dstOffset = dst_resource->heap_offset; vk_buffer_copy.size = dst_resource->desc.Width; VK_CALL(vkCmdCopyBuffer(list->vk_command_buffer, src_resource->u.vk_buffer, dst_resource->u.vk_buffer, 1, &vk_buffer_copy)); @@ -3962,8 +3964,8 @@ static void STDMETHODCALLTYPE d3d12_command_list_ResourceBarrier(ID3D12GraphicsC vk_barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; vk_barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; vk_barrier.buffer = resource->u.vk_buffer; - vk_barrier.offset = 0; - vk_barrier.size = VK_WHOLE_SIZE; + vk_barrier.offset = resource->heap_offset; + vk_barrier.size = resource->desc.Width; VK_CALL(vkCmdPipelineBarrier(list->vk_command_buffer, src_stage_mask, dst_stage_mask, 0, 0, NULL, 1, &vk_barrier, 0, NULL)); diff --git a/libs/vkd3d/resource.c b/libs/vkd3d/resource.c index f40d986..ed2b18f 100644 --- a/libs/vkd3d/resource.c +++ b/libs/vkd3d/resource.c @@ -315,6 +315,8 @@ static ULONG STDMETHODCALLTYPE d3d12_heap_AddRef(ID3D12Heap *iface) return refcount; } +static ULONG d3d12_resource_decref(struct d3d12_resource *resource); + static void d3d12_heap_destroy(struct d3d12_heap *heap) { struct d3d12_device *device = heap->device; @@ -322,6 +324,9 @@ static void d3d12_heap_destroy(struct d3d12_heap *heap) TRACE("Destroying heap %p.\n", heap); + if (heap->buffer_resource) + d3d12_resource_decref(heap->buffer_resource); + vkd3d_private_store_destroy(&heap->private_store); VK_CALL(vkFreeMemory(device->vk_device, heap->vk_memory, NULL)); @@ -562,6 +567,12 @@ static HRESULT validate_heap_desc(const D3D12_HEAP_DESC *desc, const struct d3d1 return S_OK; } +static HRESULT d3d12_resource_create(struct d3d12_device *device, + const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags, + const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_STATES initial_state, + const D3D12_CLEAR_VALUE *optimized_clear_value, bool placed, + struct d3d12_resource **resource); + static HRESULT d3d12_heap_init(struct d3d12_heap *heap, struct d3d12_device *device, const D3D12_HEAP_DESC *desc, const struct d3d12_resource *resource) { @@ -569,6 +580,9 @@ static HRESULT d3d12_heap_init(struct d3d12_heap *heap, VkDeviceSize vk_memory_size; HRESULT hr; int rc; + bool buffers_allowed; + D3D12_RESOURCE_DESC resource_desc; + D3D12_RESOURCE_STATES initial_resource_state; heap->ID3D12Heap_iface.lpVtbl = &d3d12_heap_vtbl; heap->refcount = 1; @@ -579,6 +593,7 @@ static HRESULT d3d12_heap_init(struct d3d12_heap *heap, heap->map_ptr = NULL; heap->map_count = 0; + heap->buffer_resource = NULL; if (!heap->desc.Properties.CreationNodeMask) heap->desc.Properties.CreationNodeMask = 1; @@ -606,6 +621,53 @@ static HRESULT d3d12_heap_init(struct d3d12_heap *heap, return hr; } + buffers_allowed = !(heap->desc.Flags & D3D12_HEAP_FLAG_DENY_BUFFERS); + if (buffers_allowed && !resource) + { + /* Create a single omnipotent buffer which fills the entire heap. + * Whenever we place buffer resources on this heap, we'll just offset this VkBuffer. + * This allows us to keep VA space somewhat sane, and keeps number of (limited) VA allocations down. + * One possible downside is that the buffer might be slightly slower to access, + * but D3D12 has very lenient usage flags for buffers. */ + + memset(&resource_desc, 0, sizeof(resource_desc)); + resource_desc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER; + resource_desc.Width = desc->SizeInBytes; + resource_desc.Height = 1; + resource_desc.DepthOrArraySize = 1; + resource_desc.MipLevels = 1; + resource_desc.SampleDesc.Count = 1; + resource_desc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR; + + switch (desc->Properties.Type) + { + case D3D12_HEAP_TYPE_UPLOAD: + initial_resource_state = D3D12_RESOURCE_STATE_GENERIC_READ; + break; + + case D3D12_HEAP_TYPE_READBACK: + initial_resource_state = D3D12_RESOURCE_STATE_COPY_DEST; + break; + + default: + /* Upload and readback heaps do not allow UAV access, only enable this flag for other heaps. */ + resource_desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS; + initial_resource_state = D3D12_RESOURCE_STATE_COMMON; + break; + } + + if (FAILED(hr = d3d12_resource_create(device, &desc->Properties, desc->Flags, + &resource_desc, initial_resource_state, + NULL, false, &heap->buffer_resource))) + { + heap->buffer_resource = NULL; + return hr; + } + /* This internal resource should not own a reference on the device. + * d3d12_resource_create takes a reference on the device. */ + d3d12_device_release(device); + } + if (resource) { if (d3d12_resource_is_buffer(resource)) @@ -623,8 +685,16 @@ static HRESULT d3d12_heap_init(struct d3d12_heap *heap, heap->desc.SizeInBytes = vk_memory_size; } + else if (heap->buffer_resource) + { + hr = vkd3d_allocate_buffer_memory(device, heap->buffer_resource->u.vk_buffer, + &heap->desc.Properties, heap->desc.Flags, + &heap->vk_memory, &heap->vk_memory_type, &vk_memory_size); + } else { + /* Allocate generic memory which should hopefully match up with whatever resources + * we want to place here. */ memory_requirements.size = heap->desc.SizeInBytes; memory_requirements.alignment = heap->desc.Alignment; memory_requirements.memoryTypeBits = ~(uint32_t)0; @@ -637,6 +707,11 @@ static HRESULT d3d12_heap_init(struct d3d12_heap *heap, { vkd3d_private_store_destroy(&heap->private_store); pthread_mutex_destroy(&heap->mutex); + if (heap->buffer_resource) + { + d3d12_resource_decref(heap->buffer_resource); + heap->buffer_resource = NULL; + } return hr; } @@ -1030,13 +1105,16 @@ static void d3d12_resource_destroy(struct d3d12_resource *resource, struct d3d12 if (resource->flags & VKD3D_RESOURCE_EXTERNAL) return; - if (resource->gpu_address) - vkd3d_gpu_va_allocator_free(&device->gpu_va_allocator, resource->gpu_address); + if (!(resource->flags & VKD3D_RESOURCE_PLACED_BUFFER)) + { + if (resource->gpu_address) + vkd3d_gpu_va_allocator_free(&device->gpu_va_allocator, resource->gpu_address); - if (d3d12_resource_is_buffer(resource)) - VK_CALL(vkDestroyBuffer(device->vk_device, resource->u.vk_buffer, NULL)); - else - VK_CALL(vkDestroyImage(device->vk_device, resource->u.vk_image, NULL)); + if (d3d12_resource_is_buffer(resource)) + VK_CALL(vkDestroyBuffer(device->vk_device, resource->u.vk_buffer, NULL)); + else + VK_CALL(vkDestroyImage(device->vk_device, resource->u.vk_image, NULL)); + } if (resource->flags & VKD3D_RESOURCE_DEDICATED_HEAP) d3d12_heap_destroy(resource->heap); @@ -1738,7 +1816,7 @@ static bool d3d12_resource_validate_heap_properties(const struct d3d12_resource static HRESULT d3d12_resource_init(struct d3d12_resource *resource, struct d3d12_device *device, const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags, const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_STATES initial_state, - const D3D12_CLEAR_VALUE *optimized_clear_value) + const D3D12_CLEAR_VALUE *optimized_clear_value, bool placed) { HRESULT hr; @@ -1768,6 +1846,8 @@ static HRESULT d3d12_resource_init(struct d3d12_resource *resource, struct d3d12 resource->gpu_address = 0; resource->flags = 0; + if (placed && d3d12_resource_is_buffer(resource)) + resource->flags |= VKD3D_RESOURCE_PLACED_BUFFER; if (FAILED(hr = d3d12_resource_validate_desc(&resource->desc, device))) return hr; @@ -1775,6 +1855,13 @@ static HRESULT d3d12_resource_init(struct d3d12_resource *resource, struct d3d12 switch (desc->Dimension) { case D3D12_RESOURCE_DIMENSION_BUFFER: + /* We'll inherit a VkBuffer reference from the heap with an implied offset. */ + if (placed) + { + resource->u.vk_buffer = VK_NULL_HANDLE; + break; + } + if (FAILED(hr = vkd3d_create_buffer(device, heap_properties, heap_flags, &resource->desc, &resource->u.vk_buffer))) return hr; @@ -1825,7 +1912,7 @@ static HRESULT d3d12_resource_init(struct d3d12_resource *resource, struct d3d12 static HRESULT d3d12_resource_create(struct d3d12_device *device, const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags, const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_STATES initial_state, - const D3D12_CLEAR_VALUE *optimized_clear_value, struct d3d12_resource **resource) + const D3D12_CLEAR_VALUE *optimized_clear_value, bool placed, struct d3d12_resource **resource) { struct d3d12_resource *object; HRESULT hr; @@ -1834,7 +1921,7 @@ static HRESULT d3d12_resource_create(struct d3d12_device *device, return E_OUTOFMEMORY; if (FAILED(hr = d3d12_resource_init(object, device, heap_properties, heap_flags, - desc, initial_state, optimized_clear_value))) + desc, initial_state, optimized_clear_value, placed))) { vkd3d_free(object); return hr; @@ -1876,7 +1963,7 @@ HRESULT d3d12_committed_resource_create(struct d3d12_device *device, } if (FAILED(hr = d3d12_resource_create(device, heap_properties, heap_flags, - desc, initial_state, optimized_clear_value, &object))) + desc, initial_state, optimized_clear_value, false, &object))) return hr; if (FAILED(hr = vkd3d_allocate_resource_memory(device, object, heap_properties, heap_flags))) @@ -1900,6 +1987,16 @@ static HRESULT vkd3d_bind_heap_memory(struct d3d12_device *device, VkMemoryRequirements requirements; VkResult vr; + if (resource->flags & VKD3D_RESOURCE_PLACED_BUFFER) + { + /* Just inherit the buffer from the heap. */ + resource->u.vk_buffer = heap->buffer_resource->u.vk_buffer; + resource->heap = heap; + resource->heap_offset = heap_offset; + resource->gpu_address = heap->buffer_resource->gpu_address + heap_offset; + return S_OK; + } + if (d3d12_resource_is_buffer(resource)) VK_CALL(vkGetBufferMemoryRequirements(vk_device, resource->u.vk_buffer, &requirements)); else @@ -1949,7 +2046,7 @@ HRESULT d3d12_placed_resource_create(struct d3d12_device *device, struct d3d12_h HRESULT hr; if (FAILED(hr = d3d12_resource_create(device, &heap->desc.Properties, heap->desc.Flags, - desc, initial_state, optimized_clear_value, &object))) + desc, initial_state, optimized_clear_value, true, &object))) return hr; if (FAILED(hr = vkd3d_bind_heap_memory(device, object, heap, heap_offset))) @@ -1973,7 +2070,7 @@ HRESULT d3d12_reserved_resource_create(struct d3d12_device *device, HRESULT hr; if (FAILED(hr = d3d12_resource_create(device, NULL, 0, - desc, initial_state, optimized_clear_value, &object))) + desc, initial_state, optimized_clear_value, false, &object))) return hr; TRACE("Created reserved resource %p.\n", object); @@ -2275,7 +2372,7 @@ static bool vkd3d_create_buffer_view_for_resource(struct d3d12_device *device, assert(d3d12_resource_is_buffer(resource)); return vkd3d_create_buffer_view(device, resource->u.vk_buffer, - format, offset * element_size, size * element_size, view); + format, resource->heap_offset + offset * element_size, size * element_size, view); } static void vkd3d_set_view_swizzle_for_format(VkComponentMapping *components, @@ -2869,7 +2966,7 @@ static void vkd3d_create_buffer_uav(struct d3d12_desc *descriptor, struct d3d12_ format = vkd3d_get_format(device, DXGI_FORMAT_R32_UINT, false); if (!vkd3d_create_vk_buffer_view(device, counter_resource->u.vk_buffer, format, - desc->u.Buffer.CounterOffsetInBytes, sizeof(uint32_t), &view->vk_counter_view)) + desc->u.Buffer.CounterOffsetInBytes + resource->heap_offset, sizeof(uint32_t), &view->vk_counter_view)) { WARN("Failed to create counter buffer view.\n"); view->vk_counter_view = VK_NULL_HANDLE; @@ -2960,12 +3057,18 @@ bool vkd3d_create_raw_buffer_view(struct d3d12_device *device, { const struct vkd3d_format *format; struct d3d12_resource *resource; + uint64_t range; + uint64_t offset; format = vkd3d_get_format(device, DXGI_FORMAT_R32_UINT, false); resource = vkd3d_gpu_va_allocator_dereference(&device->gpu_va_allocator, gpu_address); assert(d3d12_resource_is_buffer(resource)); + + offset = gpu_address - resource->gpu_address; + range = min(resource->desc.Width - offset, device->vk_info.device_limits.maxStorageBufferRange); + return vkd3d_create_vk_buffer_view(device, resource->u.vk_buffer, format, - gpu_address - resource->gpu_address, VK_WHOLE_SIZE, vk_buffer_view); + offset, range, vk_buffer_view); } /* samplers */ diff --git a/libs/vkd3d/vkd3d_private.h b/libs/vkd3d/vkd3d_private.h index 0c031d2..206e550 100644 --- a/libs/vkd3d/vkd3d_private.h +++ b/libs/vkd3d/vkd3d_private.h @@ -379,6 +379,7 @@ struct d3d12_heap unsigned int map_count; uint32_t vk_memory_type; + struct d3d12_resource *buffer_resource; struct d3d12_device *device; struct vkd3d_private_store private_store; @@ -393,6 +394,7 @@ struct d3d12_heap *unsafe_impl_from_ID3D12Heap(ID3D12Heap *iface) DECLSPEC_HIDDE #define VKD3D_RESOURCE_EXTERNAL 0x00000004 #define VKD3D_RESOURCE_DEDICATED_HEAP 0x00000008 #define VKD3D_RESOURCE_LINEAR_TILING 0x00000010 +#define VKD3D_RESOURCE_PLACED_BUFFER 0x00000020 /* ID3D12Resource */ struct d3d12_resource -- 2.24.0

Dec. 7, 2019

Re: [PATCH] kernel32/tests: Trace the mapped string when FoldStringW fails.

by Marvin

Hi, While running your changed tests, I think I found new failures. Being a bot and all I'm not very good at pattern recognition, so I might be wrong, but could you please double-check? Full results can be found at: https://testbot.winehq.org/JobDetails.pl?Key=61569 Your paranoid android. === wxppro (32 bit report) === kernel32: locale.c:3586: Test failed: Got unexpected string L"Wine\0348\0551\1323\280dWine\03c5\0308j\030c\00a0\00aa". === w2003std (32 bit report) === kernel32: locale.c:3586: Test failed: Got unexpected string L"Wine\0348\0551\1323\280dWine\03c5\0308j\030c\00a0\00aa".

Dec. 7, 2019

[PATCH] kernel32/tests: Trace the mapped string when FoldStringW fails.

by Mathew Hodson

Signed-off-by: Mathew Hodson <mathew.hodson(a)gmail.com> --- dlls/kernel32/tests/locale.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/dlls/kernel32/tests/locale.c b/dlls/kernel32/tests/locale.c index e43eee2..9328666 100644 --- a/dlls/kernel32/tests/locale.c +++ b/dlls/kernel32/tests/locale.c @@ -3585,7 +3585,7 @@ static void test_FoldStringW(void) ok(ret == ARRAY_SIZE(foldczone_dst), "Got %d, error %d\n", ret, GetLastError()); ok(!memcmp(dst, foldczone_dst, sizeof(foldczone_dst)) || broken(!memcmp(dst, foldczone_broken_dst, sizeof(foldczone_broken_dst))), - "MAP_FOLDCZONE: Expanded incorrectly\n"); + "Got unexpected string %s.\n", wine_dbgstr_w(dst)); /* MAP_EXPAND_LIGATURES */ SetLastError(0); @@ -3594,7 +3594,7 @@ static void test_FoldStringW(void) if (!(ret == 0 && GetLastError() == ERROR_INVALID_FLAGS)) { ok(ret == ARRAY_SIZE(ligatures_dst), "Got %d, error %d\n", ret, GetLastError()); ok(!memcmp(dst, ligatures_dst, sizeof(ligatures_dst)), - "MAP_EXPAND_LIGATURES: Expanded incorrectly\n"); + "Got unexpected string %s.\n", wine_dbgstr_w(dst)); } /* FIXME: MAP_PRECOMPOSED : MAP_COMPOSITE */ -- 2.7.4

Dec. 7, 2019

[PATCH 4/4] d3d8: Support texture dirty regions.

by Akihiro Sagawa

Signed-off-by: Akihiro Sagawa <sagawa.aki(a)gmail.com> --- dlls/d3d8/tests/visual.c | 12 ++++++------ dlls/d3d8/texture.c | 12 +++++++++++- 2 files changed, 17 insertions(+), 7 deletions(-)

Dec. 7, 2019

[PATCH 3/4] wined3d: Update a part of the texture if dirty regions is tracked.

by Akihiro Sagawa

Wine-Bugs: https://bugs.winehq.org/show_bug.cgi?id=35205 Signed-off-by: Akihiro Sagawa <sagawa.aki(a)gmail.com> --- dlls/d3d9/tests/visual.c | 12 ++++++------ dlls/wined3d/device.c | 49 +++++++++++++++++++++++++++++++++++++++++------- dlls/wined3d/texture.c | 11 ++++------- 3 files changed, 52 insertions(+), 20 deletions(-)

Dec. 7, 2019

[PATCH 2/4] wined3d: Record texture dirty regions.

by Akihiro Sagawa

Signed-off-by: Akihiro Sagawa <sagawa.aki(a)gmail.com> --- dlls/wined3d/device.c | 2 ++ dlls/wined3d/texture.c | 66 ++++++++++++++++++++++++++++++++++++++++++ dlls/wined3d/wined3d_private.h | 3 ++ 3 files changed, 71 insertions(+)

Dec. 7, 2019

[PATCH 1/4] wined3d: Add dirty region members for d3d9 textures.

by Akihiro Sagawa

Signed-off-by: Akihiro Sagawa <sagawa.aki(a)gmail.com> --- dlls/d3d9/texture.c | 9 ++++++++- dlls/wined3d/texture.c | 13 +++++++++++++ dlls/wined3d/wined3d_private.h | 7 +++++++ include/wine/wined3d.h | 1 + 4 files changed, 29 insertions(+), 1 deletion(-)

Dec. 7, 2019

Re: [wine-devel] Wine staging 4.21 release

by Alistair Leslie-Hughes

Hi Alan, On 7/12/19 7:48 pm, Alan W. Irwin wrote: > On 2019-12-05 14:03+0100 Olivier F. R. Dierick wrote: > > Version rebased upstreamed added updated predicted predicted-rebased > T U A u P D > > 4.17 855 5 9 7 n/a n/a > 4.18 850 1 1 3 855 5 > 4.19 840 8 1 1 843 3 > 4.20 832 8 1 3 833 1 > 4.21 833 0 6 2 838 5 > These rebased number is the total number of patches applied to the current wine. The numbers aren't always going to add up as you expect, For example: we might disable a patchset from one version to another while we workout a regression or drop a patch(s) because they aren't correct or add patches to a patchset to increase functionally. This release will have two patches listed as upstreamed but were actually part of the previous release since I initial disabled the patchset until I could verify that these patches were no longer required. Likewise we might drop/disable the remaining wusa patch since we are unable to verify whether is actually required anymore, which wont be listed in the release notes. Regards Alistair.

Dec. 7, 2019

Re: [wine-devel] Wine staging 4.21 release

by Alan W. Irwin

On 2019-12-05 14:03+0100 Olivier F. R. Dierick wrote: > Le mercredi 04 décembre 2019 à 14:56 -0800, Alan W. Irwin a écrit : >> On 2019-11-30 04:56-0000 Alistair Leslie-Hughes wrote: >> >>> Added: >>> * [47668] kernelbase: Improve stub for ReOpenFile and add small >> [...] >> >> Could you explain how these patch numbers in your report are related >> with each other? >> > > Hello, > > The numbers between brackets are winehq.org bugzilla bug numbers. > Hi Olivier: Thanks for trying to be helpful, but your answer did not respond to the question which was about how to account for the total number of patches in each category mentioned in these reports. To explain further, my curiosity about this question was stimulated by these staging "accounting" numbers from recent reports: Version rebased upstreamed added updated predicted predicted-rebased T U A u P D 4.17 855 5 9 7 n/a n/a 4.18 850 1 1 3 855 5 4.19 840 8 1 1 843 3 4.20 832 8 1 3 833 1 4.21 833 0 6 2 838 5 I assume the "T" column is the total number of patches in staging, i.e., the report is only sent out when the rebasing work is completed, but could someone confirm that? I also assume U reduces the total number in staging by that number, A increases the total number in staging by that number, and u leaves the total number in staging unchanged. And I have used P = T' - U - A to calculate the predicted number of patches from one report to the next and D = P - T to calculate the discrepancy between predicted and actual values where T' is taken from the previous report and T, U and A are taken from the current report. In every case D is positive (P always greater than T) so I hypothesize there is another kind of patch category not currently mentioned in the report that explains this discrepancy (e.g., patches which the staging developers have removed from staging). Could someone please describe the true reason why D is always positive? Furthermore, my view is it would be helpful if patch categories (deletions from staging or whatever) that are currently not mentioned in these reports should be mentioned in future reports. Alan __________________________ Alan W. Irwin Programming affiliations with the FreeEOS equation-of-state implementation for stellar interiors (freeeos.sf.net) the Time Ephemerides project (timeephem.sf.net) PLplot scientific plotting software package (plplot.org) the libLASi project (unifont.org/lasi) the Loads of Linux Links project (loll.sf.net) and the Linux Brochure Project (lbproject.sf.net) __________________________ Linux-powered Science __________________________

Dec. 7, 2019