wine-devel October 2018

60 participants
608 discussions

[PATCH vkd3d 4/5] tests: Fix unsupported formats tests on WARP.

by Józef Kucia

From: Józef Kucia <jkucia(a)codeweavers.com> A recent version of WARP supports B8G8R8A8 UAVs even on D3D_FEATURE_LEVEL_11_0. Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- include/private/vkd3d_test.h | 6 ++++++ tests/d3d12.c | 39 ++++++++++++++++++++++++++------------- 2 files changed, 32 insertions(+), 13 deletions(-) diff --git a/include/private/vkd3d_test.h b/include/private/vkd3d_test.h index 8e657ac02c49..fd3ed1572da6 100644 --- a/include/private/vkd3d_test.h +++ b/include/private/vkd3d_test.h @@ -90,6 +90,12 @@ vkd3d_test_platform_is_windows(void) return !strcmp(vkd3d_test_platform, "windows"); } +static inline bool +broken(bool condition) +{ + return condition && vkd3d_test_platform_is_windows(); +} + static void vkd3d_test_check_ok(unsigned int line, bool result, const char *fmt, va_list args) { diff --git a/tests/d3d12.c b/tests/d3d12.c index cff43974697b..dd842bc461ae 100644 --- a/tests/d3d12.c +++ b/tests/d3d12.c @@ -869,6 +869,11 @@ static ID3D12Device *create_device(void) return device; } +static bool broken_on_warp(bool condition) +{ + return broken(use_warp_device && condition); +} + static bool is_min_max_filtering_supported(ID3D12Device *device) { D3D12_FEATURE_DATA_D3D12_OPTIONS options; @@ -1307,12 +1312,18 @@ static void test_format_support(void) unsigned int i; HRESULT hr; - static const D3D12_FEATURE_DATA_FORMAT_SUPPORT unsupported_format_features[] = + static const struct { - {DXGI_FORMAT_B8G8R8A8_TYPELESS, D3D12_FORMAT_SUPPORT1_TYPED_UNORDERED_ACCESS_VIEW, - D3D12_FORMAT_SUPPORT2_UAV_TYPED_LOAD | D3D12_FORMAT_SUPPORT2_UAV_TYPED_STORE}, - {DXGI_FORMAT_B8G8R8A8_UNORM, D3D12_FORMAT_SUPPORT1_TYPED_UNORDERED_ACCESS_VIEW, - D3D12_FORMAT_SUPPORT2_UAV_TYPED_LOAD | D3D12_FORMAT_SUPPORT2_UAV_TYPED_STORE}, + D3D12_FEATURE_DATA_FORMAT_SUPPORT f; + bool broken; + } + unsupported_format_features[] = + { + /* A recent version of WARP suppots B8G8R8A8 UAVs even on D3D_FEATURE_LEVEL_11_0. */ + {{DXGI_FORMAT_B8G8R8A8_TYPELESS, D3D12_FORMAT_SUPPORT1_TYPED_UNORDERED_ACCESS_VIEW, + D3D12_FORMAT_SUPPORT2_UAV_TYPED_LOAD | D3D12_FORMAT_SUPPORT2_UAV_TYPED_STORE}, true}, + {{DXGI_FORMAT_B8G8R8A8_UNORM, D3D12_FORMAT_SUPPORT1_TYPED_UNORDERED_ACCESS_VIEW, + D3D12_FORMAT_SUPPORT2_UAV_TYPED_LOAD | D3D12_FORMAT_SUPPORT2_UAV_TYPED_STORE}, true}, }; if (!(device = create_device())) @@ -1333,16 +1344,18 @@ static void test_format_support(void) for (i = 0; i < ARRAY_SIZE(unsupported_format_features); ++i) { memset(&format_support, 0, sizeof(format_support)); - format_support.Format = unsupported_format_features[i].Format; + format_support.Format = unsupported_format_features[i].f.Format; hr = ID3D12Device_CheckFeatureSupport(device, D3D12_FEATURE_FORMAT_SUPPORT, &format_support, sizeof(format_support)); ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); - ok(!(format_support.Support1 & unsupported_format_features[i].Support1), - "Format %#x supports %#x.\n", unsupported_format_features[i].Format, - format_support.Support1 & unsupported_format_features[i].Support1); - ok(!(format_support.Support2 & unsupported_format_features[i].Support2), - "Format %#x supports %#x.\n", unsupported_format_features[i].Format, - format_support.Support2 & unsupported_format_features[i].Support2); + ok(!(format_support.Support1 & unsupported_format_features[i].f.Support1) + || broken_on_warp(unsupported_format_features[i].broken), + "Format %#x supports %#x.\n", unsupported_format_features[i].f.Format, + format_support.Support1 & unsupported_format_features[i].f.Support1); + ok(!(format_support.Support2 & unsupported_format_features[i].f.Support2) + || broken_on_warp(unsupported_format_features[i].broken), + "Format %#x supports %#x.\n", unsupported_format_features[i].f.Format, + format_support.Support2 & unsupported_format_features[i].f.Support2); } refcount = ID3D12Device_Release(device); @@ -1709,7 +1722,7 @@ static void test_create_committed_resource(void) hr = ID3D12Device_CreateCommittedResource(device, &heap_properties, D3D12_HEAP_FLAG_NONE, &resource_desc, D3D12_RESOURCE_STATE_RENDER_TARGET, NULL, &IID_ID3D12Resource, (void **)&resource); - todo(hr == E_INVALIDARG, "Got unexpected hr %#x.\n", hr); + todo(hr == E_INVALIDARG || broken_on_warp(true), "Got unexpected hr %#x.\n", hr); if (SUCCEEDED(hr)) ID3D12Resource_Release(resource); -- 2.16.4

5 years, 7 months

[PATCH vkd3d 2/5] vkd3d: Allocate memory for resource if heap memory cannot be used.

by Józef Kucia

From: Józef Kucia <jkucia(a)codeweavers.com> Anvil has additional restrictions for index and vertex buffers. Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- Index and vertex buffers can be allocated only from the 32-bit heap in Anvil because of a Vertex Fetch cache bug. --- libs/vkd3d/resource.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/libs/vkd3d/resource.c b/libs/vkd3d/resource.c index d6330941127a..68c189ad5bd4 100644 --- a/libs/vkd3d/resource.c +++ b/libs/vkd3d/resource.c @@ -1121,9 +1121,10 @@ static HRESULT vkd3d_bind_heap_memory(struct d3d12_device *device, if (!(requirements.memoryTypeBits & (1u << heap->vk_memory_type))) { - FIXME("Memory type %u cannot be bound to resource %p (allowed types %#x).\n", + FIXME("Memory type %u cannot be bound to resource %p (allowed types %#x), " + "allocating device memory.\n", heap->vk_memory_type, resource, requirements.memoryTypeBits); - return E_NOTIMPL; + return vkd3d_allocate_resource_memory(device, resource, &heap->desc.Properties, heap->desc.Flags); } if (d3d12_resource_is_buffer(resource)) -- 2.16.4

5 years, 7 months

[PATCH vkd3d 3/5] tests: Add simple test for creating placed resources.

by Józef Kucia

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- tests/d3d12.c | 87 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 87 insertions(+) diff --git a/tests/d3d12.c b/tests/d3d12.c index c7f4977aa300..cff43974697b 100644 --- a/tests/d3d12.c +++ b/tests/d3d12.c @@ -1921,6 +1921,92 @@ done: ok(!refcount, "ID3D12Device has %u references left.\n", (unsigned int)refcount); } +static void test_create_placed_resource(void) +{ + D3D12_GPU_VIRTUAL_ADDRESS gpu_address; + D3D12_RESOURCE_DESC resource_desc; + ID3D12Device *device, *tmp_device; + D3D12_CLEAR_VALUE clear_value; + D3D12_HEAP_DESC heap_desc; + ID3D12Resource *resource; + ID3D12Heap *heap; + ULONG refcount; + HRESULT hr; + + if (!(device = create_device())) + { + skip("Failed to create device.\n"); + return; + } + + heap_desc.SizeInBytes = D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT; + memset(&heap_desc.Properties, 0, sizeof(heap_desc.Properties)); + heap_desc.Properties.Type = D3D12_HEAP_TYPE_DEFAULT; + heap_desc.Alignment = 0; + heap_desc.Flags = D3D12_HEAP_FLAG_ALLOW_ONLY_BUFFERS; + hr = ID3D12Device_CreateHeap(device, &heap_desc, &IID_ID3D12Heap, (void **)&heap); + ok(hr == S_OK, "Failed to create heap, hr %#x.\n", hr); + + resource_desc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER; + resource_desc.Alignment = 0; + resource_desc.Width = 32; + resource_desc.Height = 1; + resource_desc.DepthOrArraySize = 1; + resource_desc.MipLevels = 1; + resource_desc.Format = DXGI_FORMAT_UNKNOWN; + resource_desc.SampleDesc.Count = 1; + resource_desc.SampleDesc.Quality = 0; + resource_desc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR; + resource_desc.Flags = 0; + + clear_value.Format = DXGI_FORMAT_R8G8B8A8_UNORM; + clear_value.Color[0] = 1.0f; + clear_value.Color[1] = 0.0f; + clear_value.Color[2] = 0.0f; + clear_value.Color[3] = 1.0f; + + refcount = get_refcount(heap); + ok(refcount == 1, "Got unexpected refcount %u.\n", (unsigned int)refcount); + + hr = ID3D12Device_CreatePlacedResource(device, heap, 0, + &resource_desc, D3D12_RESOURCE_STATE_COMMON, NULL, + &IID_ID3D12Resource, (void **)&resource); + ok(hr == S_OK, "Failed to create placed resource, hr %#x.\n", hr); + + refcount = get_refcount(heap); + ok(refcount == 1, "Got unexpected refcount %u.\n", (unsigned int)refcount); + + refcount = get_refcount(device); + ok(refcount == 3, "Got unexpected refcount %u.\n", (unsigned int)refcount); + hr = ID3D12Resource_GetDevice(resource, &IID_ID3D12Device, (void **)&tmp_device); + ok(hr == S_OK, "Failed to get device, hr %#x.\n", hr); + refcount = get_refcount(device); + ok(refcount == 4, "Got unexpected refcount %u.\n", (unsigned int)refcount); + refcount = ID3D12Device_Release(tmp_device); + ok(refcount == 3, "Got unexpected refcount %u.\n", (unsigned int)refcount); + + check_interface(resource, &IID_ID3D12Object, TRUE); + check_interface(resource, &IID_ID3D12DeviceChild, TRUE); + check_interface(resource, &IID_ID3D12Pageable, TRUE); + check_interface(resource, &IID_ID3D12Resource, TRUE); + + gpu_address = ID3D12Resource_GetGPUVirtualAddress(resource); + ok(gpu_address, "Got unexpected GPU virtual address %#"PRIx64".\n", gpu_address); + + refcount = ID3D12Resource_Release(resource); + ok(!refcount, "ID3D12Resource has %u references left.\n", (unsigned int)refcount); + + /* The clear value must be NULL for buffers. */ + hr = ID3D12Device_CreatePlacedResource(device, heap, 0, + &resource_desc, D3D12_RESOURCE_STATE_COMMON, &clear_value, + &IID_ID3D12Resource, (void **)&resource); + ok(hr == E_INVALIDARG, "Got unexpected hr %#x.\n", hr); + + ID3D12Heap_Release(heap); + refcount = ID3D12Device_Release(device); + ok(!refcount, "ID3D12Device has %u references left.\n", (unsigned int)refcount); +} + static void test_create_descriptor_heap(void) { D3D12_DESCRIPTOR_HEAP_DESC heap_desc; @@ -20415,6 +20501,7 @@ START_TEST(d3d12) run_test(test_create_command_queue); run_test(test_create_committed_resource); run_test(test_create_heap); + run_test(test_create_placed_resource); run_test(test_create_descriptor_heap); run_test(test_create_sampler); run_test(test_create_unordered_access_view); -- 2.16.4

5 years, 7 months

[PATCH 4/5] wined3d: Add core context support for A8_UNORM render targets.

by Józef Kucia

Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=44655 Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/wined3d/cs.c | 8 ++++++++ dlls/wined3d/glsl_shader.c | 11 +++++++---- dlls/wined3d/shader.c | 10 ++++++++++ dlls/wined3d/utils.c | 3 ++- dlls/wined3d/wined3d_private.h | 3 ++- 5 files changed, 29 insertions(+), 6 deletions(-) diff --git a/dlls/wined3d/cs.c b/dlls/wined3d/cs.c index 2aae559a6cb9..af1dbef84ce1 100644 --- a/dlls/wined3d/cs.c +++ b/dlls/wined3d/cs.c @@ -1084,9 +1084,17 @@ void wined3d_cs_emit_set_scissor_rects(struct wined3d_cs *cs, unsigned int rect_ static void wined3d_cs_exec_set_rendertarget_view(struct wined3d_cs *cs, const void *data) { const struct wined3d_cs_set_rendertarget_view *op = data; + BOOL prev_alpha_swizzle, curr_alpha_swizzle; + struct wined3d_rendertarget_view *prev; + prev = cs->state.fb->render_targets[op->view_idx]; cs->fb.render_targets[op->view_idx] = op->view; device_invalidate_state(cs->device, STATE_FRAMEBUFFER); + + prev_alpha_swizzle = prev && prev->format->id == WINED3DFMT_A8_UNORM; + curr_alpha_swizzle = op->view && op->view->format->id == WINED3DFMT_A8_UNORM; + if (prev_alpha_swizzle != curr_alpha_swizzle) + device_invalidate_state(cs->device, STATE_SHADER(WINED3D_SHADER_TYPE_PIXEL)); } void wined3d_cs_emit_set_rendertarget_view(struct wined3d_cs *cs, unsigned int view_idx, diff --git a/dlls/wined3d/glsl_shader.c b/dlls/wined3d/glsl_shader.c index 0db7fdc038b0..32f82d6c3d0a 100644 --- a/dlls/wined3d/glsl_shader.c +++ b/dlls/wined3d/glsl_shader.c @@ -7694,11 +7694,12 @@ static void shader_glsl_enable_extensions(struct wined3d_string_buffer *buffer, static void shader_glsl_generate_color_output(struct wined3d_string_buffer *buffer, const struct wined3d_gl_info *gl_info, const struct wined3d_shader *shader, - struct wined3d_string_buffer_list *string_buffers) + const struct ps_compile_args *args, struct wined3d_string_buffer_list *string_buffers) { const struct wined3d_shader_signature *output_signature = &shader->output_signature; struct wined3d_string_buffer *src, *assignment; enum wined3d_data_type dst_data_type; + const char *swizzle; unsigned int i; if (output_signature->element_count) @@ -7721,7 +7722,8 @@ static void shader_glsl_generate_color_output(struct wined3d_string_buffer *buff shader_addline(buffer, "color_out%u = ", output->semantic_idx); string_buffer_sprintf(src, "ps_out[%u]", output->semantic_idx); shader_glsl_sprintf_cast(assignment, src->buffer, dst_data_type, WINED3D_DATA_FLOAT); - shader_addline(buffer, "%s;\n", assignment->buffer); + swizzle = args->rt_alpha_swizzle & (1u << output->semantic_idx) ? ".argb" : ""; + shader_addline(buffer, "%s%s;\n", assignment->buffer, swizzle); } string_buffer_release(string_buffers, src); string_buffer_release(string_buffers, assignment); @@ -7733,7 +7735,8 @@ static void shader_glsl_generate_color_output(struct wined3d_string_buffer *buff while (mask) { i = wined3d_bit_scan(&mask); - shader_addline(buffer, "color_out%u = ps_out[%u];\n", i, i); + swizzle = args->rt_alpha_swizzle & (1u << i) ? ".argb" : ""; + shader_addline(buffer, "color_out%u = ps_out[%u]%s;\n", i, i, swizzle); } } } @@ -7761,7 +7764,7 @@ static void shader_glsl_generate_ps_epilogue(const struct wined3d_gl_info *gl_in shader_addline(buffer, "gl_SampleMask[0] = floatBitsToInt(sample_mask);\n"); if (!needs_legacy_glsl_syntax(gl_info)) - shader_glsl_generate_color_output(buffer, gl_info, shader, string_buffers); + shader_glsl_generate_color_output(buffer, gl_info, shader, args, string_buffers); } /* Context activation is done by the caller. */ diff --git a/dlls/wined3d/shader.c b/dlls/wined3d/shader.c index 62ec97154141..09681725b5a7 100644 --- a/dlls/wined3d/shader.c +++ b/dlls/wined3d/shader.c @@ -4124,6 +4124,16 @@ void find_ps_compile_args(const struct wined3d_state *state, const struct wined3 args->render_offscreen = shader->reg_maps.vpos && gl_info->supported[ARB_FRAGMENT_COORD_CONVENTIONS] ? context->render_offscreen : 0; + + if (!gl_info->supported[WINED3D_GL_LEGACY_CONTEXT]) + { + for (i = 0; i < ARRAY_SIZE(state->fb->render_targets); ++i) + { + struct wined3d_rendertarget_view *rtv = state->fb->render_targets[i]; + if (rtv && rtv->format->id == WINED3DFMT_A8_UNORM) + args->rt_alpha_swizzle |= 1u << i; + } + } } static HRESULT pixel_shader_init(struct wined3d_shader *shader, struct wined3d_device *device, diff --git a/dlls/wined3d/utils.c b/dlls/wined3d/utils.c index 05579db5b2b4..e3df24ade40d 100644 --- a/dlls/wined3d/utils.c +++ b/dlls/wined3d/utils.c @@ -1519,7 +1519,8 @@ static const struct wined3d_format_texture_info format_texture_info[] = ARB_TEXTURE_RG, NULL}, {WINED3DFMT_A8_UNORM, GL_R8, GL_R8, 0, GL_RED, GL_UNSIGNED_BYTE, 0, - WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING, + WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING + | WINED3DFMT_FLAG_RENDERTARGET, ARB_TEXTURE_RG, NULL}, {WINED3DFMT_A8_UNORM, GL_ALPHA8, GL_ALPHA8, 0, GL_ALPHA, GL_UNSIGNED_BYTE, 0, diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index 9135189d026c..5f7f6fd39795 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -1345,7 +1345,8 @@ struct ps_compile_args DWORD flatshading : 1; DWORD alpha_test_func : 3; DWORD render_offscreen : 1; - DWORD padding : 26; + DWORD rt_alpha_swizzle : 8; /* MAX_RENDER_TARGET_VIEWS, 8 */ + DWORD padding : 18; }; enum fog_src_type -- 2.16.4

5 years, 7 months

[PATCH 2/5] d3d11: Implement D3D11_FEATURE_D3D11_OPTIONS3.

by Józef Kucia

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/d3d11/device.c | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/dlls/d3d11/device.c b/dlls/d3d11/device.c index 1edd41f0d404..157ff0341ae4 100644 --- a/dlls/d3d11/device.c +++ b/dlls/d3d11/device.c @@ -3515,6 +3515,29 @@ static HRESULT STDMETHODCALLTYPE d3d11_device_CheckFeatureSupport(ID3D11Device2 return S_OK; } + case D3D11_FEATURE_D3D11_OPTIONS3: + { + D3D11_FEATURE_DATA_D3D11_OPTIONS3 *options = feature_support_data; + if (feature_support_data_size != sizeof(*options)) + { + WARN("Invalid data size.\n"); + return E_INVALIDARG; + } + + wined3d_mutex_lock(); + hr = wined3d_device_get_device_caps(device->wined3d_device, &wined3d_caps); + wined3d_mutex_unlock(); + if (FAILED(hr)) + { + WARN("Failed to get device caps, hr %#x.\n", hr); + return hr; + } + + options->VPAndRTArrayIndexFromAnyShaderFeedingRasterizer + = wined3d_caps.viewport_array_index_any_shader; + return S_OK; + } + case D3D11_FEATURE_ARCHITECTURE_INFO: { D3D11_FEATURE_DATA_ARCHITECTURE_INFO *options = feature_support_data; -- 2.16.4

5 years, 7 months

[PATCH 5/5] d3d11/tests: Add test for rendering to A8_UNORM texture.

by Józef Kucia

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/d3d11/tests/d3d11.c | 112 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 112 insertions(+) diff --git a/dlls/d3d11/tests/d3d11.c b/dlls/d3d11/tests/d3d11.c index 646d41fe1b0f..3ebccf9fd3f3 100644 --- a/dlls/d3d11/tests/d3d11.c +++ b/dlls/d3d11/tests/d3d11.c @@ -935,6 +935,11 @@ static void *get_readback_data(struct resource_readback *rb, return (BYTE *)rb->map_desc.pData + z * rb->map_desc.DepthPitch + y * rb->map_desc.RowPitch + x * byte_width; } +static BYTE get_readback_byte(struct resource_readback *rb, unsigned int x, unsigned int y, unsigned int z) +{ + return *(BYTE *)get_readback_data(rb, x, y, z, sizeof(BYTE)); +} + static DWORD get_readback_color(struct resource_readback *rb, unsigned int x, unsigned int y, unsigned int z) { return *(DWORD *)get_readback_data(rb, x, y, z, sizeof(DWORD)); @@ -974,6 +979,45 @@ static DWORD get_texture_color(ID3D11Texture2D *texture, unsigned int x, unsigne return color; } +#define check_readback_data_byte(a, b, c, d) check_readback_data_byte_(__LINE__, a, b, c, d) +static void check_readback_data_byte_(unsigned int line, struct resource_readback *rb, + const RECT *rect, BYTE expected_value, BYTE max_diff) +{ + unsigned int x = 0, y = 0, z = 0; + BOOL all_match = TRUE; + RECT default_rect; + BYTE value = 0; + + if (!rect) + { + SetRect(&default_rect, 0, 0, rb->width, rb->height); + rect = &default_rect; + } + + for (z = 0; z < rb->depth; ++z) + { + for (y = rect->top; y < rect->bottom; ++y) + { + for (x = rect->left; x < rect->right; ++x) + { + value = get_readback_byte(rb, x, y, z); + if (!compare_color(value, expected_value, max_diff)) + { + all_match = FALSE; + break; + } + } + if (!all_match) + break; + } + if (!all_match) + break; + } + ok_(__FILE__, line)(all_match, + "Got 0x%02x, expected 0x%02x at (%u, %u, %u), sub-resource %u.\n", + value, expected_value, x, y, z, rb->sub_resource_idx); +} + #define check_readback_data_color(a, b, c, d) check_readback_data_color_(__LINE__, a, b, c, d) static void check_readback_data_color_(unsigned int line, struct resource_readback *rb, const RECT *rect, DWORD expected_color, BYTE max_diff) @@ -28239,6 +28283,73 @@ static void test_staging_buffers(void) release_test_context(&test_context); } +static void test_render_a8(void) +{ + static const float black[] = {0.0f, 0.0f, 0.0f, 0.0f}; + struct d3d11_test_context test_context; + D3D11_TEXTURE2D_DESC texture_desc; + ID3D11DeviceContext *context; + ID3D11RenderTargetView *rtv; + struct resource_readback rb; + ID3D11Texture2D *texture; + ID3D11PixelShader *ps; + ID3D11Device *device; + unsigned int i; + HRESULT hr; + + static const DWORD ps_code[] = + { +#if 0 + void main(out float4 target : SV_Target) + { + target = float4(0.0f, 0.25f, 0.5f, 1.0f); + } +#endif + 0x43425844, 0x8a06129f, 0x3041bde2, 0x09389749, 0xb339ba8b, 0x00000001, 0x000000b0, 0x00000003, + 0x0000002c, 0x0000003c, 0x00000070, 0x4e475349, 0x00000008, 0x00000000, 0x00000008, 0x4e47534f, + 0x0000002c, 0x00000001, 0x00000008, 0x00000020, 0x00000000, 0x00000000, 0x00000003, 0x00000000, + 0x0000000f, 0x545f5653, 0x65677261, 0xabab0074, 0x52444853, 0x00000038, 0x00000040, 0x0000000e, + 0x03000065, 0x001020f2, 0x00000000, 0x08000036, 0x001020f2, 0x00000000, 0x00004002, 0x00000000, + 0x3e800000, 0x3f000000, 0x3f800000, 0x0100003e, + }; + + if (!init_test_context(&test_context, NULL)) + return; + device = test_context.device; + context = test_context.immediate_context; + + hr = ID3D11Device_CreatePixelShader(device, ps_code, sizeof(ps_code), NULL, &ps); + ok(hr == S_OK, "Failed to create pixel shader, hr %#x.\n", hr); + ID3D11DeviceContext_PSSetShader(context, ps, NULL, 0); + + ID3D11Texture2D_GetDesc(test_context.backbuffer, &texture_desc); + texture_desc.Format = DXGI_FORMAT_A8_UNORM; + hr = ID3D11Device_CreateTexture2D(device, &texture_desc, NULL, &texture); + ok(hr == S_OK, "Failed to create texture, hr %#x.\n", hr); + hr = ID3D11Device_CreateRenderTargetView(device, (ID3D11Resource *)texture, NULL, &rtv); + ok(hr == S_OK, "Failed to create render target view, hr %#x.\n", hr); + + for (i = 0; i < 2; ++i) + { + ID3D11DeviceContext_ClearRenderTargetView(context, rtv, black); + ID3D11DeviceContext_OMSetRenderTargets(context, 1, &rtv, NULL); + draw_quad(&test_context); + get_texture_readback(texture, 0, &rb); + check_readback_data_byte(&rb, NULL, 0xff, 0); + release_resource_readback(&rb); + + ID3D11DeviceContext_ClearRenderTargetView(context, test_context.backbuffer_rtv, black); + ID3D11DeviceContext_OMSetRenderTargets(context, 1, &test_context.backbuffer_rtv, NULL); + draw_quad(&test_context); + check_texture_sub_resource_color(test_context.backbuffer, 0, NULL, 0xff7f4000, 1); + } + + ID3D11PixelShader_Release(ps); + ID3D11Texture2D_Release(texture); + ID3D11RenderTargetView_Release(rtv); + release_test_context(&test_context); +} + START_TEST(d3d11) { unsigned int argc, i; @@ -28387,6 +28498,7 @@ START_TEST(d3d11) queue_test(test_sample_mask); queue_test(test_depth_clip); queue_test(test_staging_buffers); + queue_test(test_render_a8); run_queued_tests(); } -- 2.16.4

5 years, 7 months

[PATCH 3/5] d3d11/tests: Add test for layered rendering without geometry shader.

by Józef Kucia

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/d3d11/tests/d3d11.c | 67 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 67 insertions(+) diff --git a/dlls/d3d11/tests/d3d11.c b/dlls/d3d11/tests/d3d11.c index 41afdf951327..646d41fe1b0f 100644 --- a/dlls/d3d11/tests/d3d11.c +++ b/dlls/d3d11/tests/d3d11.c @@ -1409,6 +1409,16 @@ static BOOL check_compute_shaders_via_sm4_support(ID3D11Device *device) return options.ComputeShaders_Plus_RawAndStructuredBuffers_Via_Shader_4_x; } +static BOOL check_viewport_array_index_from_any_shader_support(ID3D11Device *device) +{ + D3D11_FEATURE_DATA_D3D11_OPTIONS3 options; + + if (FAILED(ID3D11Device_CheckFeatureSupport(device, + D3D11_FEATURE_D3D11_OPTIONS3, &options, sizeof(options)))) + return FALSE; + return options.VPAndRTArrayIndexFromAnyShaderFeedingRasterizer; +} + static BOOL is_buffer(ID3D11Resource *resource) { D3D11_RESOURCE_DIMENSION dimension; @@ -9305,12 +9315,38 @@ static void test_layered_rendering(void) ID3D11RenderTargetView *rtv; ID3D11Texture2D *texture; ID3D11GeometryShader *gs; + ID3D11VertexShader *vs; ID3D11PixelShader *ps; ID3D11Device *device; ID3D11Buffer *cb; HRESULT hr; BOOL warp; + static const DWORD vs_code[] = + { +#if 0 + uint layer_offset; + + void main(float4 position : POSITION, + out float4 out_position : SV_POSITION, + out uint layer : SV_RenderTargetArrayIndex) + { + out_position = position; + layer = layer_offset; + } +#endif + 0x43425844, 0x71f7b9cd, 0x2ab8c713, 0x53e77663, 0x54a9ba68, 0x00000001, 0x00000158, 0x00000004, + 0x00000030, 0x00000064, 0x000000cc, 0x00000148, 0x4e475349, 0x0000002c, 0x00000001, 0x00000008, + 0x00000020, 0x00000000, 0x00000000, 0x00000003, 0x00000000, 0x00000f0f, 0x49534f50, 0x4e4f4954, + 0xababab00, 0x4e47534f, 0x00000060, 0x00000002, 0x00000008, 0x00000038, 0x00000000, 0x00000001, + 0x00000003, 0x00000000, 0x0000000f, 0x00000044, 0x00000000, 0x00000004, 0x00000001, 0x00000001, + 0x00000e01, 0x505f5653, 0x5449534f, 0x004e4f49, 0x525f5653, 0x65646e65, 0x72615472, 0x41746567, + 0x79617272, 0x65646e49, 0xabab0078, 0x52444853, 0x00000074, 0x00010040, 0x0000001d, 0x04000059, + 0x00208e46, 0x00000000, 0x00000001, 0x0300005f, 0x001010f2, 0x00000000, 0x04000067, 0x001020f2, + 0x00000000, 0x00000001, 0x04000067, 0x00102012, 0x00000001, 0x00000004, 0x05000036, 0x001020f2, + 0x00000000, 0x00101e46, 0x00000000, 0x06000036, 0x00102012, 0x00000001, 0x0020800a, 0x00000000, + 0x00000000, 0x0100003e, 0x30494653, 0x00000008, 0x00002000, 0x00000000, + }; static const DWORD gs_5_code[] = { #if 0 @@ -9442,6 +9478,7 @@ static void test_layered_rendering(void) {4.0f, 1.0f}, {4.0f, 3.0f}, {3.0f, 7.0f}, {5.0f, 1.0f}, {5.0f, 3.0f}, {3.0f, 6.0f}, {6.0f, 1.0f}, {6.0f, 3.0f}, {3.0f, 5.0f}, {7.0f, 1.0f}, {7.0f, 3.0f}, {3.0f, 4.0f}, }; + static const struct vec4 vs_expected_value = {1.0f, 42.0f}; if (!init_test_context(&test_context, NULL)) return; @@ -9453,6 +9490,7 @@ static void test_layered_rendering(void) memset(&constant, 0, sizeof(constant)); cb = create_buffer(device, D3D11_BIND_CONSTANT_BUFFER, sizeof(constant), &constant); + ID3D11DeviceContext_VSSetConstantBuffers(context, 0, 1, &cb); ID3D11DeviceContext_GSSetConstantBuffers(context, 0, 1, &cb); ID3D11DeviceContext_PSSetConstantBuffers(context, 0, 1, &cb); @@ -9556,6 +9594,35 @@ static void test_layered_rendering(void) check_texture_sub_resource_vec4(texture, i, NULL, &expected_values[i], 1); } + /* layered rendering without GS */ + if (!check_viewport_array_index_from_any_shader_support(device)) + { + hr = ID3D11Device_CreateVertexShader(device, vs_code, sizeof(vs_code), NULL, &vs); + todo_wine ok(hr == E_INVALIDARG, "Got unexpected hr %#x.\n", hr); + if (SUCCEEDED(hr)) + ID3D11VertexShader_Release(vs); + skip("Viewport array index not supported in vertex shaders.\n"); + goto done; + } + + ID3D11DeviceContext_GSSetShader(context, NULL, NULL, 0); + + constant.layer_offset = 1; + constant.draw_id = 42; + ID3D11DeviceContext_UpdateSubresource(context, (ID3D11Resource *)cb, 0, NULL, &constant, 0, 0); + rtv_desc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DARRAY; + U(rtv_desc).Texture2DArray.MipSlice = 0; + U(rtv_desc).Texture2DArray.FirstArraySlice = 0; + U(rtv_desc).Texture2DArray.ArraySize = ~0u; + hr = ID3D11Device_CreateRenderTargetView(device, (ID3D11Resource *)texture, &rtv_desc, &rtv); + ok(hr == S_OK, "Failed to create render target view, hr %#x.\n", hr); + ID3D11DeviceContext_OMSetRenderTargets(context, 1, &rtv, NULL); + draw_quad_vs(&test_context, vs_code, sizeof(vs_code)); + check_texture_sub_resource_vec4(texture, + constant.layer_offset * texture_desc.MipLevels, NULL, &vs_expected_value, 1); + ID3D11RenderTargetView_Release(rtv); + +done: ID3D11Texture2D_Release(texture); ID3D11Buffer_Release(cb); -- 2.16.4

5 years, 7 months

[PATCH 1/5] wined3d: Expose viewport array index capability in wined3d_caps.

by Józef Kucia

For viewport array indices in shader stages other than geometry. Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/wined3d/adapter_gl.c | 2 ++ dlls/wined3d/directx.c | 1 + dlls/wined3d/wined3d_private.h | 1 + include/wine/wined3d.h | 1 + 4 files changed, 5 insertions(+) diff --git a/dlls/wined3d/adapter_gl.c b/dlls/wined3d/adapter_gl.c index b794415fb3d6..2f2d09db794b 100644 --- a/dlls/wined3d/adapter_gl.c +++ b/dlls/wined3d/adapter_gl.c @@ -3676,6 +3676,8 @@ static BOOL wined3d_adapter_init_gl_caps(struct wined3d_adapter *adapter, d3d_info->limits.varying_count = shader_caps.varying_count; d3d_info->shader_double_precision = !!(shader_caps.wined3d_caps & WINED3D_SHADER_CAP_DOUBLE_PRECISION); + d3d_info->viewport_array_index_any_shader = !!gl_info->supported[ARB_SHADER_VIEWPORT_LAYER_ARRAY]; + adapter->vertex_pipe->vp_get_caps(gl_info, &vertex_caps); d3d_info->xyzrhw = vertex_caps.xyzrhw; d3d_info->ffp_generic_attributes = vertex_caps.ffp_generic_attributes; diff --git a/dlls/wined3d/directx.c b/dlls/wined3d/directx.c index a6184862d1d9..fb67fe4a5128 100644 --- a/dlls/wined3d/directx.c +++ b/dlls/wined3d/directx.c @@ -2406,6 +2406,7 @@ HRESULT CDECL wined3d_get_device_caps(const struct wined3d *wined3d, UINT adapte } caps->shader_double_precision = d3d_info->shader_double_precision; + caps->viewport_array_index_any_shader = d3d_info->viewport_array_index_any_shader; caps->max_feature_level = d3d_info->feature_level; diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index 8cfa4c37ef8b..9135189d026c 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -197,6 +197,7 @@ struct wined3d_d3d_info unsigned int vs_clipping : 1; unsigned int shader_color_key : 1; unsigned int shader_double_precision : 1; + unsigned int viewport_array_index_any_shader : 1; unsigned int texture_npot : 1; unsigned int texture_npot_conditional : 1; enum wined3d_feature_level feature_level; diff --git a/include/wine/wined3d.h b/include/wine/wined3d.h index e2e6a72c8466..cf44ca64a409 100644 --- a/include/wine/wined3d.h +++ b/include/wine/wined3d.h @@ -1980,6 +1980,7 @@ struct wined3d_caps struct wined3d_ddraw_caps ddraw_caps; BOOL shader_double_precision; + BOOL viewport_array_index_any_shader; enum wined3d_feature_level max_feature_level; }; -- 2.16.4

5 years, 7 months

[PATCH] dxgi: fixed typo in width/height (Coverity)

by Marcus Meissner

CID 1439782 Signed-off-by: Marcus Meissner <marcus(a)jet.franken.de> --- dlls/dxgi/tests/dxgi.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/dlls/dxgi/tests/dxgi.c b/dlls/dxgi/tests/dxgi.c index d1908ac1c2..f2bc9ed229 100644 --- a/dlls/dxgi/tests/dxgi.c +++ b/dlls/dxgi/tests/dxgi.c @@ -4392,7 +4392,7 @@ static void test_swapchain_window_messages(void) expect_messages = resize_target_messages; memset(&mode_desc, 0, sizeof(mode_desc)); mode_desc.Width = 800; - mode_desc.Width = 600; + mode_desc.Height = 600; hr = IDXGISwapChain_ResizeTarget(swapchain, &mode_desc); ok(hr == S_OK, "Failed to resize target, hr %#x.\n", hr); flush_events(); @@ -4401,7 +4401,7 @@ static void test_swapchain_window_messages(void) expect_messages = resize_target_messages; memset(&mode_desc, 0, sizeof(mode_desc)); mode_desc.Width = 400; - mode_desc.Width = 200; + mode_desc.Height = 200; hr = IDXGISwapChain_ResizeTarget(swapchain, &mode_desc); ok(hr == S_OK, "Failed to resize target, hr %#x.\n", hr); flush_events(); -- 2.19.0

5 years, 7 months

[PATCH v2 1/2] user32: Let nulldrv return some dummy monitor information.

by Bernhard Übelacker

Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=43187 Signed-off-by: Bernhard Übelacker <bernhardu(a)mailbox.org> --- Supersedes patch 151898. v2: No changes to v1. --- dlls/user32/driver.c | 19 +++++++++++++++++-- 1 file changed, 17 insertions(+), 2 deletions(-) diff --git a/dlls/user32/driver.c b/dlls/user32/driver.c index 561a126bd6..03296d518c 100644 --- a/dlls/user32/driver.c +++ b/dlls/user32/driver.c @@ -354,7 +354,12 @@ static LONG CDECL nulldrv_ChangeDisplaySettingsEx( LPCWSTR name, LPDEVMODEW mode static BOOL CDECL nulldrv_EnumDisplayMonitors( HDC hdc, LPRECT rect, MONITORENUMPROC proc, LPARAM lp ) { - return FALSE; + RECT r = {0, 0, 640, 480}; + + TRACE("(%p, %p, %p, 0x%lx)\n", hdc, rect, proc, lp); + + proc(NULL, hdc, &r, lp); + return TRUE; } static BOOL CDECL nulldrv_EnumDisplaySettingsEx( LPCWSTR name, DWORD num, LPDEVMODEW mode, DWORD flags ) @@ -364,7 +369,17 @@ static BOOL CDECL nulldrv_EnumDisplaySettingsEx( LPCWSTR name, DWORD num, LPDEVM static BOOL CDECL nulldrv_GetMonitorInfo( HMONITOR handle, LPMONITORINFO info ) { - return FALSE; + RECT r = {0, 0, 640, 480}; + const WCHAR device[] = {'W','i','n','D','i','s','c',0}; + + TRACE("(%p, %p)\n", handle, info); + + info->rcMonitor = r; + info->rcWork = r; + info->dwFlags = MONITORINFOF_PRIMARY; + if (info->cbSize >= sizeof(MONITORINFOEXW)) + lstrcpyW( ((MONITORINFOEXW *)info)->szDevice, device ); + return TRUE; } static BOOL CDECL nulldrv_CreateDesktopWindow( HWND hwnd ) -- 2.19.0

5 years, 7 months

Jump to page:

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

2003

2002

2001

wine-devel October 2018