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

[PATCH] wined3d: Avoid using float literals for MAX_FLOAT in GLSL when possible.
by Paul Gofman April 5, 2019

April 5, 2019

When application uses FLT_MAX in shader local constants, GLSL shader code gets 3.40282347e+38 string literal. Sometimes (seemingly depending on some side factors) NVIDIA GLSL compiler rejects such shaders with 'floating point constant overflow' error. Signed-off-by: Paul Gofman <gofmanp(a)gmail.com> --- dlls/d3d9/tests/visual.c | 48 ++++++++++++++++++++++++++++++++++++-- dlls/wined3d/glsl_shader.c | 33 +++++++++++++++++--------- dlls/wined3d/utils.c | 2 ++ 3 files changed, 70 insertions(+), 13 deletions(-) diff --git a/dlls/d3d9/tests/visual.c b/dlls/d3d9/tests/visual.c index 85c1fa1bf8..36465f2156 100644 --- a/dlls/d3d9/tests/visual.c +++ b/dlls/d3d9/tests/visual.c @@ -28,6 +28,7 @@ * causes visible results in games can be tested in a way that does not depend on pixel exactness */ +#include <float.h> #include <limits.h> #include <math.h> @@ -16644,7 +16645,23 @@ static void fp_special_test(void) 0x0000ffff, /* end */ }; - struct + static const DWORD ps_fltmax_code[] = + { + 0xffff0200, /* ps_2_0 */ + 0x05000051, 0xa00f0000, 0x7f7fffff, 0xff7fffff, 0x7f7fffff, 0xff7fffff, /* def c0, FLT_MAX, -FLT_MAX, + * FLT_MAX, -FLT_MAX */ + 0x05000051, 0xa00f0002, 0x3f800000, 0x3f800000, 0x3f800000, 0x3f800000, /* def c2, 1.0, 1.0, 1.0, 1.0 */ + 0x05000051, 0xa00f0003, 0x3f000000, 0x3f000000, 0x3f000000, 0x3f000000, /* def c3, 0.5, 0.5, 0.5, 0.5 */ + 0x02000001, 0x800f0001, 0xa0e40001, /* mov r1, c1 */ + 0x03000002, 0x800f0000, 0xa0e40000, 0x81e40001, /* add r0, c0, -r1 */ + 0x02000023, 0x800f0000, 0x80e40000, /* abs r0, r0 */ + 0x02000001, 0x800f0001, 0xa0e40003, /* mov r1, c3 */ + 0x04000058, 0x800f0000, 0x81e40000, 0xa0e40002, 0x80e40001, /* cmp r0, -r0, c2, r1 */ + 0x02000001, 0x800f0800, 0x80e40000, /* mov oC0, r0 */ + 0x0000ffff, /* end */ + }; + + static const struct { float x, y, z; float s; @@ -16657,10 +16674,12 @@ static void fp_special_test(void) { 1.0f, -1.0f, 1.0f, 0.0f}, }; + static const struct vec4 const_max_flt = {FLT_MAX, -FLT_MAX, FLT_MAX, -FLT_MAX}; IDirect3DPixelShader9 *ps; IDirect3DDevice9 *device; UINT body_size = 0; IDirect3D9 *d3d; + D3DCOLOR color; DWORD *vs_code; ULONG refcount; D3DCAPS9 caps; @@ -16712,7 +16731,6 @@ static void fp_special_test(void) { DWORD offset = ARRAY_SIZE(vs_header); IDirect3DVertexShader9 *vs; - D3DCOLOR color; memcpy(vs_code + offset, vs_body[i].ops, vs_body[i].size); offset += vs_body[i].size / sizeof(*vs_body[i].ops); @@ -16752,6 +16770,32 @@ static void fp_special_test(void) hr = IDirect3DDevice9_SetPixelShader(device, NULL); ok(SUCCEEDED(hr), "SetPixelShader failed, hr %#x.\n", hr); IDirect3DPixelShader9_Release(ps); + + hr = IDirect3DDevice9_CreatePixelShader(device, ps_fltmax_code, &ps); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + hr = IDirect3DDevice9_SetPixelShader(device, ps); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + + hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 1, &const_max_flt.x, 1); + ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %08x\n", hr); + + hr = IDirect3DDevice9_BeginScene(device); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(*quad)); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + hr = IDirect3DDevice9_EndScene(device); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + + color = getPixelColor(device, 320, 240); + ok(color == 0x00ffffff, "Got unexpected color 0x%08x.\n", color); + + hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + + hr = IDirect3DDevice9_SetPixelShader(device, NULL); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + IDirect3DPixelShader9_Release(ps); + refcount = IDirect3DDevice9_Release(device); ok(!refcount, "Device has %u references left.\n", refcount); done: diff --git a/dlls/wined3d/glsl_shader.c b/dlls/wined3d/glsl_shader.c index 746d7cfa36..4a60f6e0e4 100644 --- a/dlls/wined3d/glsl_shader.c +++ b/dlls/wined3d/glsl_shader.c @@ -432,14 +432,25 @@ static void shader_glsl_add_version_declaration(struct wined3d_string_buffer *bu shader_addline(buffer, "#version %u\n", shader_glsl_get_version(gl_info)); } -static void shader_glsl_append_imm_vec4(struct wined3d_string_buffer *buffer, const float *values) +static void shader_glsl_imm_float_literal(float value, char *str, + const struct wined3d_gl_info *gl_info) +{ + if (fabsf(value) == FLT_MAX && isfinite(value) && gl_info->supported[ARB_SHADER_BIT_ENCODING]) + strcpy(str, value == FLT_MAX ? "uintBitsToFloat(0x7f7fffffu)" + : "uintBitsToFloat(0xff7fffffu)"); + else + wined3d_ftoa(value, str); +} + +static void shader_glsl_append_imm_vec4(struct wined3d_string_buffer *buffer, const float *values, + const struct wined3d_gl_info *gl_info) { - char str[4][17]; + char str[4][29]; - wined3d_ftoa(values[0], str[0]); - wined3d_ftoa(values[1], str[1]); - wined3d_ftoa(values[2], str[2]); - wined3d_ftoa(values[3], str[3]); + shader_glsl_imm_float_literal(values[0], str[0], gl_info); + shader_glsl_imm_float_literal(values[1], str[1], gl_info); + shader_glsl_imm_float_literal(values[2], str[2], gl_info); + shader_glsl_imm_float_literal(values[3], str[3], gl_info); shader_addline(buffer, "vec4(%s, %s, %s, %s)", str[0], str[1], str[2], str[3]); } @@ -2932,7 +2943,7 @@ static void shader_generate_glsl_declarations(const struct wined3d_context *cont LIST_FOR_EACH_ENTRY(lconst, &shader->constantsF, struct wined3d_shader_lconst, entry) { shader_addline(buffer, "const vec4 %s_lc%u = ", prefix, lconst->idx); - shader_glsl_append_imm_vec4(buffer, (const float *)lconst->value); + shader_glsl_append_imm_vec4(buffer, (const float *)lconst->value, gl_info); shader_addline(buffer, ";\n"); } } @@ -8104,10 +8115,10 @@ static GLuint shader_glsl_generate_pshader(const struct wined3d_context *context if (args->srgb_correction) { shader_addline(buffer, "const vec4 srgb_const0 = "); - shader_glsl_append_imm_vec4(buffer, wined3d_srgb_const0); + shader_glsl_append_imm_vec4(buffer, wined3d_srgb_const0, gl_info); shader_addline(buffer, ";\n"); shader_addline(buffer, "const vec4 srgb_const1 = "); - shader_glsl_append_imm_vec4(buffer, wined3d_srgb_const1); + shader_glsl_append_imm_vec4(buffer, wined3d_srgb_const1, gl_info); shader_addline(buffer, ";\n"); } if (reg_maps->vpos || reg_maps->usesdsy) @@ -10001,10 +10012,10 @@ static GLuint shader_glsl_generate_ffp_fragment_shader(struct shader_glsl_priv * if (settings->sRGB_write) { shader_addline(buffer, "const vec4 srgb_const0 = "); - shader_glsl_append_imm_vec4(buffer, wined3d_srgb_const0); + shader_glsl_append_imm_vec4(buffer, wined3d_srgb_const0, gl_info); shader_addline(buffer, ";\n"); shader_addline(buffer, "const vec4 srgb_const1 = "); - shader_glsl_append_imm_vec4(buffer, wined3d_srgb_const1); + shader_glsl_append_imm_vec4(buffer, wined3d_srgb_const1, gl_info); shader_addline(buffer, ";\n"); } diff --git a/dlls/wined3d/utils.c b/dlls/wined3d/utils.c index 6595eaaf10..912038deeb 100644 --- a/dlls/wined3d/utils.c +++ b/dlls/wined3d/utils.c @@ -6406,6 +6406,8 @@ void wined3d_ftoa(float value, char *s) { int idx = 1; + value = min(max(value, -1e38), 1e38); + if (copysignf(1.0f, value) < 0.0f) ++idx; -- 2.20.1

1 0

[PATCH] mshtml.idl: Add some SVG interfaces declaration.
by Jacek Caban April 5, 2019

April 5, 2019

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- include/mshtmdid.h | 280 +++++++++ include/mshtml.idl | 1422 ++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 1702 insertions(+)

1 0

[PATCH 5/6] wined3d: Map GL_EXT_texture_swizzle to GL_ARB_texture_swizzle.
by Józef Kucia April 5, 2019

April 5, 2019

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/wined3d/adapter_gl.c | 5 +++++ dlls/wined3d/wined3d_gl.h | 1 + 2 files changed, 6 insertions(+) diff --git a/dlls/wined3d/adapter_gl.c b/dlls/wined3d/adapter_gl.c index 3157c49a59ae..ff7d345f32fb 100644 --- a/dlls/wined3d/adapter_gl.c +++ b/dlls/wined3d/adapter_gl.c @@ -204,6 +204,7 @@ static const struct wined3d_extension_map gl_extension_map[] = {"GL_EXT_texture_snorm", EXT_TEXTURE_SNORM }, {"GL_EXT_texture_sRGB", EXT_TEXTURE_SRGB }, {"GL_EXT_texture_sRGB_decode", EXT_TEXTURE_SRGB_DECODE }, + {"GL_EXT_texture_swizzle", EXT_TEXTURE_SWIZZLE }, {"GL_EXT_vertex_array_bgra", EXT_VERTEX_ARRAY_BGRA }, /* NV */ @@ -3645,6 +3646,10 @@ static BOOL wined3d_adapter_init_gl_caps(struct wined3d_adapter *adapter, TRACE("Disabling ARB_clip_control because ARB_viewport_array is not supported.\n"); gl_info->supported[ARB_CLIP_CONTROL] = FALSE; } + if (!gl_info->supported[ARB_TEXTURE_SWIZZLE] && gl_info->supported[EXT_TEXTURE_SWIZZLE]) + { + gl_info->supported[ARB_TEXTURE_SWIZZLE] = TRUE; + } if (gl_info->supported[ARB_STENCIL_TEXTURING] && !gl_info->supported[ARB_TEXTURE_SWIZZLE]) { /* The stencil value needs to be placed in the green channel. */ diff --git a/dlls/wined3d/wined3d_gl.h b/dlls/wined3d/wined3d_gl.h index ae067e65805a..102ab06988a1 100644 --- a/dlls/wined3d/wined3d_gl.h +++ b/dlls/wined3d/wined3d_gl.h @@ -186,6 +186,7 @@ enum wined3d_gl_extension EXT_TEXTURE_SNORM, EXT_TEXTURE_SRGB, EXT_TEXTURE_SRGB_DECODE, + EXT_TEXTURE_SWIZZLE, EXT_VERTEX_ARRAY_BGRA, /* NVIDIA */ NV_FENCE, -- 2.19.2

2 1

[PATCH 3/6] wined3d: Introduce support for Vulkan formats.
by Józef Kucia April 5, 2019

April 5, 2019

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/wined3d/adapter_vk.c | 2 +- dlls/wined3d/utils.c | 159 ++++++++++++++++++++++++++++++++- dlls/wined3d/wined3d_private.h | 15 +++- 3 files changed, 172 insertions(+), 4 deletions(-) diff --git a/dlls/wined3d/adapter_vk.c b/dlls/wined3d/adapter_vk.c index 6dbfaa607592..23d9a448624b 100644 --- a/dlls/wined3d/adapter_vk.c +++ b/dlls/wined3d/adapter_vk.c @@ -369,7 +369,7 @@ static BOOL wined3d_adapter_vk_init(struct wined3d_adapter_vk *adapter_vk, } wined3d_driver_info_init(&adapter->driver_info, gpu_description, wined3d_settings.emulated_textureram); - if (!wined3d_adapter_vk_init_format_info(adapter)) + if (!wined3d_adapter_vk_init_format_info(adapter_vk, vk_info)) goto fail_vulkan; adapter->vertex_pipe = &none_vertex_pipe; diff --git a/dlls/wined3d/utils.c b/dlls/wined3d/utils.c index be76dbbfc1a7..ade29b08fbde 100644 --- a/dlls/wined3d/utils.c +++ b/dlls/wined3d/utils.c @@ -1938,6 +1938,11 @@ static struct wined3d_format_gl *wined3d_format_gl_mutable(struct wined3d_format return CONTAINING_RECORD(format, struct wined3d_format_gl, f); } +static struct wined3d_format_vk *wined3d_format_vk_mutable(struct wined3d_format *format) +{ + return CONTAINING_RECORD(format, struct wined3d_format_vk, f); +} + static struct wined3d_format *get_format_by_idx(const struct wined3d_adapter *adapter, int fmt_idx) { return (struct wined3d_format *)((BYTE *)adapter->formats + fmt_idx * adapter->format_size); @@ -4067,9 +4072,159 @@ fail: return FALSE; } -BOOL wined3d_adapter_vk_init_format_info(struct wined3d_adapter *adapter) +static void init_vulkan_format_info(struct wined3d_format_vk *format, + const struct wined3d_vk_info *vk_info, VkPhysicalDevice vk_physical_device) +{ + static const struct + { + enum wined3d_format_id id; + VkFormat vk_format; + } + vulkan_formats[] = + { + {WINED3DFMT_R32G32B32A32_FLOAT, VK_FORMAT_R32G32B32A32_SFLOAT, }, + {WINED3DFMT_R32G32B32A32_UINT, VK_FORMAT_R32G32B32A32_UINT, }, + {WINED3DFMT_R32G32B32A32_SINT, VK_FORMAT_R32G32B32A32_SINT, }, + {WINED3DFMT_R32G32B32_FLOAT, VK_FORMAT_R32G32B32_SFLOAT, }, + {WINED3DFMT_R32G32B32_UINT, VK_FORMAT_R32G32B32_UINT, }, + {WINED3DFMT_R32G32B32_SINT, VK_FORMAT_R32G32B32_SINT, }, + {WINED3DFMT_R16G16B16A16_FLOAT, VK_FORMAT_R16G16B16A16_SFLOAT, }, + {WINED3DFMT_R16G16B16A16_UNORM, VK_FORMAT_R16G16B16A16_UNORM, }, + {WINED3DFMT_R16G16B16A16_UINT, VK_FORMAT_R16G16B16A16_UINT, }, + {WINED3DFMT_R16G16B16A16_SNORM, VK_FORMAT_R16G16B16A16_SNORM, }, + {WINED3DFMT_R16G16B16A16_SINT, VK_FORMAT_R16G16B16A16_SINT, }, + {WINED3DFMT_R32G32_FLOAT, VK_FORMAT_R32G32_SFLOAT, }, + {WINED3DFMT_R32G32_UINT, VK_FORMAT_R32G32_UINT, }, + {WINED3DFMT_R32G32_SINT, VK_FORMAT_R32G32_SINT, }, + {WINED3DFMT_R10G10B10A2_UNORM, VK_FORMAT_A2B10G10R10_UNORM_PACK32,}, + {WINED3DFMT_R11G11B10_FLOAT, VK_FORMAT_B10G11R11_UFLOAT_PACK32, }, + {WINED3DFMT_R8G8_UNORM, VK_FORMAT_R8G8_UNORM, }, + {WINED3DFMT_R8G8_UINT, VK_FORMAT_R8G8_UINT, }, + {WINED3DFMT_R8G8_SNORM, VK_FORMAT_R8G8_SNORM, }, + {WINED3DFMT_R8G8_SINT, VK_FORMAT_R8G8_SINT, }, + {WINED3DFMT_R8G8B8A8_UNORM, VK_FORMAT_R8G8B8A8_UNORM, }, + {WINED3DFMT_R8G8B8A8_UNORM_SRGB, VK_FORMAT_R8G8B8A8_SRGB, }, + {WINED3DFMT_R8G8B8A8_UINT, VK_FORMAT_R8G8B8A8_UINT, }, + {WINED3DFMT_R8G8B8A8_SNORM, VK_FORMAT_R8G8B8A8_SNORM, }, + {WINED3DFMT_R8G8B8A8_SINT, VK_FORMAT_R8G8B8A8_SINT, }, + {WINED3DFMT_R16G16_FLOAT, VK_FORMAT_R16G16_SFLOAT, }, + {WINED3DFMT_R16G16_UNORM, VK_FORMAT_R16G16_UNORM, }, + {WINED3DFMT_R16G16_UINT, VK_FORMAT_R16G16_UINT, }, + {WINED3DFMT_R16G16_SNORM, VK_FORMAT_R16G16_SNORM, }, + {WINED3DFMT_R16G16_SINT, VK_FORMAT_R16G16_SINT, }, + {WINED3DFMT_D32_FLOAT, VK_FORMAT_D32_SFLOAT, }, + {WINED3DFMT_R32_FLOAT, VK_FORMAT_R32_SFLOAT, }, + {WINED3DFMT_R32_UINT, VK_FORMAT_R32_UINT, }, + {WINED3DFMT_R32_SINT, VK_FORMAT_R32_SINT, }, + {WINED3DFMT_R16_FLOAT, VK_FORMAT_R16_SFLOAT, }, + {WINED3DFMT_D16_UNORM, VK_FORMAT_D16_UNORM, }, + {WINED3DFMT_R16_UNORM, VK_FORMAT_R16_UNORM, }, + {WINED3DFMT_R16_UINT, VK_FORMAT_R16_UINT, }, + {WINED3DFMT_R16_SNORM, VK_FORMAT_R16_SNORM, }, + {WINED3DFMT_R16_SINT, VK_FORMAT_R16_SINT, }, + {WINED3DFMT_R8_UNORM, VK_FORMAT_R8_UNORM, }, + {WINED3DFMT_R8_UINT, VK_FORMAT_R8_UINT, }, + {WINED3DFMT_R8_SNORM, VK_FORMAT_R8_SNORM, }, + {WINED3DFMT_R8_SINT, VK_FORMAT_R8_SINT, }, + {WINED3DFMT_A8_UNORM, VK_FORMAT_R8_UNORM, }, + {WINED3DFMT_B8G8R8A8_UNORM, VK_FORMAT_B8G8R8A8_UNORM, }, + {WINED3DFMT_B8G8R8A8_UNORM_SRGB, VK_FORMAT_B8G8R8A8_SRGB, }, + {WINED3DFMT_BC1_UNORM, VK_FORMAT_BC1_RGBA_UNORM_BLOCK, }, + {WINED3DFMT_BC1_UNORM_SRGB, VK_FORMAT_BC1_RGBA_SRGB_BLOCK, }, + {WINED3DFMT_BC2_UNORM, VK_FORMAT_BC2_UNORM_BLOCK, }, + {WINED3DFMT_BC2_UNORM_SRGB, VK_FORMAT_BC2_SRGB_BLOCK, }, + {WINED3DFMT_BC3_UNORM, VK_FORMAT_BC3_UNORM_BLOCK, }, + {WINED3DFMT_BC3_UNORM_SRGB, VK_FORMAT_BC3_SRGB_BLOCK, }, + {WINED3DFMT_BC4_UNORM, VK_FORMAT_BC4_UNORM_BLOCK, }, + {WINED3DFMT_BC4_SNORM, VK_FORMAT_BC4_SNORM_BLOCK, }, + {WINED3DFMT_BC5_UNORM, VK_FORMAT_BC5_UNORM_BLOCK, }, + {WINED3DFMT_BC5_SNORM, VK_FORMAT_BC5_SNORM_BLOCK, }, + {WINED3DFMT_BC6H_UF16, VK_FORMAT_BC6H_UFLOAT_BLOCK, }, + {WINED3DFMT_BC6H_SF16, VK_FORMAT_BC6H_SFLOAT_BLOCK, }, + {WINED3DFMT_BC7_UNORM, VK_FORMAT_BC7_UNORM_BLOCK, }, + {WINED3DFMT_BC7_UNORM_SRGB, VK_FORMAT_BC7_SRGB_BLOCK, }, + }; + VkFormat vk_format = VK_FORMAT_UNDEFINED; + VkFormatFeatureFlags texture_flags; + VkFormatProperties properties; + unsigned int flags; + unsigned int i; + + for (i = 0; i < ARRAY_SIZE(vulkan_formats); ++i) + { + if (vulkan_formats[i].id == format->f.id) + { + vk_format = vulkan_formats[i].vk_format; + break; + } + } + if (!vk_format) + { + WARN("Unsupported format %s.\n", debug_d3dformat(format->f.id)); + return; + } + + format->vk_format = vk_format; + + VK_CALL(vkGetPhysicalDeviceFormatProperties(vk_physical_device, vk_format, &properties)); + + if (properties.bufferFeatures & VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT) + format->f.flags[WINED3D_GL_RES_TYPE_BUFFER] |= WINED3DFMT_FLAG_VERTEX_ATTRIBUTE; + if (properties.bufferFeatures & VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT) + format->f.flags[WINED3D_GL_RES_TYPE_BUFFER] |= WINED3DFMT_FLAG_TEXTURE; + + flags = 0; + texture_flags = properties.linearTilingFeatures | properties.optimalTilingFeatures; + if (texture_flags & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) + { + flags |= WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_VTF; + } + if (texture_flags & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT) + { + flags |= WINED3DFMT_FLAG_RENDERTARGET; + } + if (texture_flags & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT) + { + flags |= WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING; + } + if (texture_flags & VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT) + { + flags |= WINED3DFMT_FLAG_FILTERING; + } + + format->f.flags[WINED3D_GL_RES_TYPE_TEX_1D] |= flags; + format->f.flags[WINED3D_GL_RES_TYPE_TEX_2D] |= flags; + format->f.flags[WINED3D_GL_RES_TYPE_TEX_3D] |= flags; + format->f.flags[WINED3D_GL_RES_TYPE_TEX_CUBE] |= flags; +} + +BOOL wined3d_adapter_vk_init_format_info(struct wined3d_adapter_vk *adapter_vk, + const struct wined3d_vk_info *vk_info) { - return wined3d_adapter_init_format_info(adapter, sizeof(struct wined3d_format)); + VkPhysicalDevice vk_physical_device = adapter_vk->physical_device; + struct wined3d_adapter *adapter = &adapter_vk->a; + struct wined3d_format_vk *format; + unsigned int i; + + if (!wined3d_adapter_init_format_info(adapter, sizeof(*format))) + return FALSE; + + for (i = 0; i < WINED3D_FORMAT_COUNT; ++i) + { + format = wined3d_format_vk_mutable(get_format_by_idx(adapter, i)); + + if (format->f.id) + init_vulkan_format_info(format, vk_info, vk_physical_device); + } + + if (!init_typeless_formats(adapter)) goto fail; + + return TRUE; + +fail: + heap_free(adapter->formats); + adapter->formats = NULL; + return FALSE; } const struct wined3d_format *wined3d_get_format(const struct wined3d_adapter *adapter, diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index fd62d67a675d..33c567b86be6 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -2784,7 +2784,8 @@ struct wined3d_caps_gl_ctx BOOL wined3d_adapter_gl_init_format_info(struct wined3d_adapter *adapter, struct wined3d_caps_gl_ctx *ctx) DECLSPEC_HIDDEN; BOOL wined3d_adapter_no3d_init_format_info(struct wined3d_adapter *adapter) DECLSPEC_HIDDEN; -BOOL wined3d_adapter_vk_init_format_info(struct wined3d_adapter *adapter) DECLSPEC_HIDDEN; +BOOL wined3d_adapter_vk_init_format_info(struct wined3d_adapter_vk *adapter_vk, + const struct wined3d_vk_info *vk_info) DECLSPEC_HIDDEN; UINT64 adapter_adjust_memory(struct wined3d_adapter *adapter, INT64 amount) DECLSPEC_HIDDEN; BOOL wined3d_caps_gl_ctx_test_viewport_subpixel_bits(struct wined3d_caps_gl_ctx *ctx) DECLSPEC_HIDDEN; @@ -4632,6 +4633,18 @@ static inline const struct wined3d_format_gl *wined3d_format_gl(const struct win return CONTAINING_RECORD(format, struct wined3d_format_gl, f); } +struct wined3d_format_vk +{ + struct wined3d_format f; + + VkFormat vk_format; +}; + +static inline const struct wined3d_format_vk *wined3d_format_vk(const struct wined3d_format *format) +{ + return CONTAINING_RECORD(format, struct wined3d_format_vk, f); +} + BOOL wined3d_array_reserve(void **elements, SIZE_T *capacity, SIZE_T count, SIZE_T size) DECLSPEC_HIDDEN; static inline BOOL wined3d_format_is_typeless(const struct wined3d_format *format) -- 2.19.2

2 1

[PATCH 1/6] wined3d: Use Vulkan physical device properties to fill GPU description.
by Józef Kucia April 5, 2019

April 5, 2019

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/wined3d/adapter_vk.c | 60 +++++++++++++++++++++++++++++++++- dlls/wined3d/wined3d_private.h | 1 + 2 files changed, 60 insertions(+), 1 deletion(-) diff --git a/dlls/wined3d/adapter_vk.c b/dlls/wined3d/adapter_vk.c index ca3a0f99e766..5c4bdd0d3009 100644 --- a/dlls/wined3d/adapter_vk.c +++ b/dlls/wined3d/adapter_vk.c @@ -186,6 +186,61 @@ fail: return FALSE; } +static VkPhysicalDevice get_vulkan_physical_device(struct wined3d_vk_info *vk_info) +{ + VkPhysicalDevice physical_devices[1]; + uint32_t count; + VkResult vr; + + if ((vr = VK_CALL(vkEnumeratePhysicalDevices(vk_info->instance, &count, NULL))) < 0) + { + WARN("Failed to enumerate physical devices, vr %d.\n", vr); + return VK_NULL_HANDLE; + } + if (!count) + { + WARN("No physical device.\n"); + return VK_NULL_HANDLE; + } + if (count > 1) + { + /* TODO: Create wined3d_adapter for each device. */ + FIXME("Multiple physical devices available.\n"); + count = 1; + } + + if ((vr = VK_CALL(vkEnumeratePhysicalDevices(vk_info->instance, &count, physical_devices))) < 0) + { + WARN("Failed to get physical devices, vr %d.\n", vr); + return VK_NULL_HANDLE; + } + + return physical_devices[0]; +} + +const struct wined3d_gpu_description *get_vulkan_gpu_description(const struct wined3d_vk_info *vk_info, + VkPhysicalDevice physical_device) +{ + const struct wined3d_gpu_description *description; + VkPhysicalDeviceProperties properties; + + VK_CALL(vkGetPhysicalDeviceProperties(physical_device, &properties)); + + TRACE("Device name: %s.\n", debugstr_a(properties.deviceName)); + TRACE("Vendor ID: 0x%04x, Device ID: 0x%04x.\n", properties.vendorID, properties.deviceID); + TRACE("Driver version: %#x.\n", properties.driverVersion); + TRACE("API version: %u.%u.%u.\n", VK_VERSION_MAJOR(properties.apiVersion), + VK_VERSION_MINOR(properties.apiVersion), VK_VERSION_PATCH(properties.apiVersion)); + + if ((description = wined3d_get_gpu_description(properties.vendorID, properties.deviceID))) + return description; + + FIXME("Failed to retrieve GPU description for device %s %04x:%04x.\n", + debugstr_a(properties.deviceName), properties.vendorID, properties.deviceID); + + return wined3d_get_gpu_description(HW_VENDOR_AMD, CARD_AMD_RADEON_RX_VEGA); +} + static BOOL wined3d_adapter_vk_init(struct wined3d_adapter_vk *adapter_vk, unsigned int ordinal, unsigned int wined3d_creation_flags) { @@ -205,7 +260,10 @@ static BOOL wined3d_adapter_vk_init(struct wined3d_adapter_vk *adapter_vk, goto fail; } - if (!(gpu_description = wined3d_get_gpu_description(HW_VENDOR_AMD, CARD_AMD_RADEON_RX_VEGA))) + if (!(adapter_vk->physical_device = get_vulkan_physical_device(vk_info))) + goto fail_vulkan; + + if (!(gpu_description = get_vulkan_gpu_description(vk_info, adapter_vk->physical_device))) { ERR("Failed to get GPU description.\n"); goto fail_vulkan; diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index c2fbf1dae519..fa9d1d71829a 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -2755,6 +2755,7 @@ struct wined3d_adapter_vk struct wined3d_adapter a; struct wined3d_vk_info vk_info; + VkPhysicalDevice physical_device; }; static inline struct wined3d_adapter_vk *wined3d_adapter_vk(struct wined3d_adapter *adapter) -- 2.19.2

2 1

[PATCH 2/6] wined3d: Implement adapter_vk_get_wined3d_caps().
by Józef Kucia April 5, 2019

April 5, 2019

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/wined3d/adapter_vk.c | 125 +++++++++++++++++++++++++++++---- dlls/wined3d/directx.c | 6 +- dlls/wined3d/wined3d_private.h | 2 + 3 files changed, 117 insertions(+), 16 deletions(-) diff --git a/dlls/wined3d/adapter_vk.c b/dlls/wined3d/adapter_vk.c index 5c4bdd0d3009..6dbfaa607592 100644 --- a/dlls/wined3d/adapter_vk.c +++ b/dlls/wined3d/adapter_vk.c @@ -24,6 +24,11 @@ WINE_DEFAULT_DEBUG_CHANNEL(d3d); +static inline const struct wined3d_adapter_vk *wined3d_adapter_vk_const(const struct wined3d_adapter *adapter) +{ + return CONTAINING_RECORD(adapter, struct wined3d_adapter_vk, a); +} + #ifdef USE_WIN32_VULKAN static BOOL wined3d_load_vulkan(struct wined3d_vk_info *vk_info) { @@ -93,6 +98,100 @@ static BOOL adapter_vk_create_context(struct wined3d_context *context, static void adapter_vk_get_wined3d_caps(const struct wined3d_adapter *adapter, struct wined3d_caps *caps) { + const struct wined3d_adapter_vk *adapter_vk = wined3d_adapter_vk_const(adapter); + const VkPhysicalDeviceLimits *limits = &adapter_vk->device_limits; + BOOL sampler_anisotropy = limits->maxSamplerAnisotropy > 1.0f; + + caps->ddraw_caps.dds_caps |= WINEDDSCAPS_3DDEVICE + | WINEDDSCAPS_MIPMAP + | WINEDDSCAPS_TEXTURE + | WINEDDSCAPS_VIDEOMEMORY + | WINEDDSCAPS_ZBUFFER; + caps->ddraw_caps.caps |= WINEDDCAPS_3D; + + caps->Caps2 |= WINED3DCAPS2_CANGENMIPMAP; + + caps->PrimitiveMiscCaps |= WINED3DPMISCCAPS_BLENDOP + | WINED3DPMISCCAPS_SEPARATEALPHABLEND + | WINED3DPMISCCAPS_INDEPENDENTWRITEMASKS + | WINED3DPMISCCAPS_POSTBLENDSRGBCONVERT; + + if (sampler_anisotropy) + { + caps->RasterCaps |= WINED3DPRASTERCAPS_ANISOTROPY + | WINED3DPRASTERCAPS_ZBIAS + | WINED3DPRASTERCAPS_MIPMAPLODBIAS; + + caps->TextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFANISOTROPIC + | WINED3DPTFILTERCAPS_MINFANISOTROPIC; + + caps->MaxAnisotropy = limits->maxSamplerAnisotropy; + } + + caps->SrcBlendCaps |= WINED3DPBLENDCAPS_BLENDFACTOR; + caps->DestBlendCaps |= WINED3DPBLENDCAPS_BLENDFACTOR + | WINED3DPBLENDCAPS_SRCALPHASAT; + + caps->TextureCaps |= WINED3DPTEXTURECAPS_VOLUMEMAP + | WINED3DPTEXTURECAPS_MIPVOLUMEMAP + | WINED3DPTEXTURECAPS_VOLUMEMAP_POW2; + caps->VolumeTextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFLINEAR + | WINED3DPTFILTERCAPS_MAGFPOINT + | WINED3DPTFILTERCAPS_MINFLINEAR + | WINED3DPTFILTERCAPS_MINFPOINT + | WINED3DPTFILTERCAPS_MIPFLINEAR + | WINED3DPTFILTERCAPS_MIPFPOINT + | WINED3DPTFILTERCAPS_LINEAR + | WINED3DPTFILTERCAPS_LINEARMIPLINEAR + | WINED3DPTFILTERCAPS_LINEARMIPNEAREST + | WINED3DPTFILTERCAPS_MIPLINEAR + | WINED3DPTFILTERCAPS_MIPNEAREST + | WINED3DPTFILTERCAPS_NEAREST; + caps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_INDEPENDENTUV + | WINED3DPTADDRESSCAPS_CLAMP + | WINED3DPTADDRESSCAPS_WRAP; + caps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_BORDER + | WINED3DPTADDRESSCAPS_MIRROR + | WINED3DPTADDRESSCAPS_MIRRORONCE; + + caps->MaxVolumeExtent = limits->maxImageDimension3D; + + caps->TextureCaps |= WINED3DPTEXTURECAPS_CUBEMAP + | WINED3DPTEXTURECAPS_MIPCUBEMAP + | WINED3DPTEXTURECAPS_CUBEMAP_POW2; + caps->CubeTextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFLINEAR + | WINED3DPTFILTERCAPS_MAGFPOINT + | WINED3DPTFILTERCAPS_MINFLINEAR + | WINED3DPTFILTERCAPS_MINFPOINT + | WINED3DPTFILTERCAPS_MIPFLINEAR + | WINED3DPTFILTERCAPS_MIPFPOINT + | WINED3DPTFILTERCAPS_LINEAR + | WINED3DPTFILTERCAPS_LINEARMIPLINEAR + | WINED3DPTFILTERCAPS_LINEARMIPNEAREST + | WINED3DPTFILTERCAPS_MIPLINEAR + | WINED3DPTFILTERCAPS_MIPNEAREST + | WINED3DPTFILTERCAPS_NEAREST; + + if (sampler_anisotropy) + { + caps->CubeTextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFANISOTROPIC + | WINED3DPTFILTERCAPS_MINFANISOTROPIC; + } + + caps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_BORDER + | WINED3DPTADDRESSCAPS_MIRROR + | WINED3DPTADDRESSCAPS_MIRRORONCE; + + caps->StencilCaps |= WINED3DSTENCILCAPS_DECR + | WINED3DSTENCILCAPS_INCR + | WINED3DSTENCILCAPS_TWOSIDED; + + caps->DeclTypes |= WINED3DDTCAPS_FLOAT16_2 | WINED3DDTCAPS_FLOAT16_4; + + caps->MaxPixelShader30InstructionSlots = WINED3DMAX30SHADERINSTRUCTIONS; + caps->MaxVertexShader30InstructionSlots = WINED3DMAX30SHADERINSTRUCTIONS; + caps->PS20Caps.temp_count = WINED3DPS20_MAX_NUMTEMPS; + caps->VS20Caps.temp_count = WINED3DVS20_MAX_NUMTEMPS; } static BOOL adapter_vk_check_format(const struct wined3d_adapter *adapter, @@ -218,25 +317,21 @@ static VkPhysicalDevice get_vulkan_physical_device(struct wined3d_vk_info *vk_in return physical_devices[0]; } -const struct wined3d_gpu_description *get_vulkan_gpu_description(const struct wined3d_vk_info *vk_info, - VkPhysicalDevice physical_device) +const struct wined3d_gpu_description *get_vulkan_gpu_description(const VkPhysicalDeviceProperties* properties) { const struct wined3d_gpu_description *description; - VkPhysicalDeviceProperties properties; - - VK_CALL(vkGetPhysicalDeviceProperties(physical_device, &properties)); - TRACE("Device name: %s.\n", debugstr_a(properties.deviceName)); - TRACE("Vendor ID: 0x%04x, Device ID: 0x%04x.\n", properties.vendorID, properties.deviceID); - TRACE("Driver version: %#x.\n", properties.driverVersion); - TRACE("API version: %u.%u.%u.\n", VK_VERSION_MAJOR(properties.apiVersion), - VK_VERSION_MINOR(properties.apiVersion), VK_VERSION_PATCH(properties.apiVersion)); + TRACE("Device name: %s.\n", debugstr_a(properties->deviceName)); + TRACE("Vendor ID: 0x%04x, Device ID: 0x%04x.\n", properties->vendorID, properties->deviceID); + TRACE("Driver version: %#x.\n", properties->driverVersion); + TRACE("API version: %u.%u.%u.\n", VK_VERSION_MAJOR(properties->apiVersion), + VK_VERSION_MINOR(properties->apiVersion), VK_VERSION_PATCH(properties->apiVersion)); - if ((description = wined3d_get_gpu_description(properties.vendorID, properties.deviceID))) + if ((description = wined3d_get_gpu_description(properties->vendorID, properties->deviceID))) return description; FIXME("Failed to retrieve GPU description for device %s %04x:%04x.\n", - debugstr_a(properties.deviceName), properties.vendorID, properties.deviceID); + debugstr_a(properties->deviceName), properties->vendorID, properties->deviceID); return wined3d_get_gpu_description(HW_VENDOR_AMD, CARD_AMD_RADEON_RX_VEGA); } @@ -247,6 +342,7 @@ static BOOL wined3d_adapter_vk_init(struct wined3d_adapter_vk *adapter_vk, struct wined3d_vk_info *vk_info = &adapter_vk->vk_info; const struct wined3d_gpu_description *gpu_description; struct wined3d_adapter *adapter = &adapter_vk->a; + VkPhysicalDeviceProperties properties; TRACE("adapter_vk %p, ordinal %u, wined3d_creation_flags %#x.\n", adapter_vk, ordinal, wined3d_creation_flags); @@ -263,7 +359,10 @@ static BOOL wined3d_adapter_vk_init(struct wined3d_adapter_vk *adapter_vk, if (!(adapter_vk->physical_device = get_vulkan_physical_device(vk_info))) goto fail_vulkan; - if (!(gpu_description = get_vulkan_gpu_description(vk_info, adapter_vk->physical_device))) + VK_CALL(vkGetPhysicalDeviceProperties(adapter_vk->physical_device, &properties)); + adapter_vk->device_limits = properties.limits; + + if (!(gpu_description = get_vulkan_gpu_description(&properties))) { ERR("Failed to get GPU description.\n"); goto fail_vulkan; diff --git a/dlls/wined3d/directx.c b/dlls/wined3d/directx.c index 49e56e0c847c..e21b8beaa884 100644 --- a/dlls/wined3d/directx.c +++ b/dlls/wined3d/directx.c @@ -2004,14 +2004,14 @@ HRESULT CDECL wined3d_get_device_caps(const struct wined3d *wined3d, unsigned in caps->VS20Caps.static_flow_control_depth = WINED3DVS20_MAX_STATICFLOWCONTROLDEPTH; caps->MaxVShaderInstructionsExecuted = 65535; /* VS 3.0 needs at least 65535, some cards even use 2^32-1 */ - caps->MaxVertexShader30InstructionSlots = 512; + caps->MaxVertexShader30InstructionSlots = WINED3DMIN30SHADERINSTRUCTIONS; caps->VertexTextureFilterCaps = WINED3DPTFILTERCAPS_MINFPOINT | WINED3DPTFILTERCAPS_MAGFPOINT; } else if (caps->VertexShaderVersion == 2) { caps->VS20Caps.caps = 0; caps->VS20Caps.dynamic_flow_control_depth = WINED3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH; - caps->VS20Caps.temp_count = 12; + caps->VS20Caps.temp_count = WINED3DVS20_MIN_NUMTEMPS; caps->VS20Caps.static_flow_control_depth = 1; caps->MaxVShaderInstructionsExecuted = 65535; @@ -2059,7 +2059,7 @@ HRESULT CDECL wined3d_get_device_caps(const struct wined3d *wined3d, unsigned in /* Below we assume PS2.0 specs, not extended 2.0a(GeforceFX)/2.0b(Radeon R3xx) ones */ caps->PS20Caps.caps = 0; caps->PS20Caps.dynamic_flow_control_depth = 0; /* WINED3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH = 0 */ - caps->PS20Caps.temp_count = 12; + caps->PS20Caps.temp_count = WINED3DPS20_MIN_NUMTEMPS; caps->PS20Caps.static_flow_control_depth = WINED3DPS20_MIN_STATICFLOWCONTROLDEPTH; /* Minimum: 1 */ /* Minimum number (64 ALU + 32 Texture), a GeforceFX uses 512 */ caps->PS20Caps.instruction_slot_count = WINED3DPS20_MIN_NUMINSTRUCTIONSLOTS; diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index fa9d1d71829a..fd62d67a675d 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -2756,6 +2756,8 @@ struct wined3d_adapter_vk struct wined3d_vk_info vk_info; VkPhysicalDevice physical_device; + + VkPhysicalDeviceLimits device_limits; }; static inline struct wined3d_adapter_vk *wined3d_adapter_vk(struct wined3d_adapter *adapter) -- 2.19.2

2 1

[PATCH 1/6] ddraw/tests: Add some tests for calling stateblock methods while recording.
by Zebediah Figura April 5, 2019

April 5, 2019

Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- dlls/ddraw/tests/ddraw7.c | 72 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 72 insertions(+) diff --git a/dlls/ddraw/tests/ddraw7.c b/dlls/ddraw/tests/ddraw7.c index 423dba57c9..168253e468 100644 --- a/dlls/ddraw/tests/ddraw7.c +++ b/dlls/ddraw/tests/ddraw7.c @@ -15822,6 +15822,77 @@ static void test_clipper_refcount(void) DestroyWindow(window); } +static void test_begin_end_state_block(void) +{ + DWORD stateblock, stateblock2; + IDirect3DDevice7 *device; + ULONG refcount; + DWORD value; + HWND window; + HRESULT hr; + + window = create_window(); + if (!(device = create_device(window, DDSCL_NORMAL))) + { + skip("Failed to create 3D device.\n"); + DestroyWindow(window); + return; + } + + hr = IDirect3DDevice7_BeginStateBlock(device); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + + hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_LIGHTING, FALSE); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + + stateblock = 0xdeadbeef; + hr = IDirect3DDevice7_EndStateBlock(device, &stateblock); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + ok(!!stateblock && stateblock != 0xdeadbeef, "Got unexpected stateblock %#x.\n", stateblock); + + stateblock2 = 0xdeadbeef; + hr = IDirect3DDevice7_EndStateBlock(device, &stateblock2); + todo_wine ok(hr == D3DERR_NOTINBEGINSTATEBLOCK, "Got unexpected hr %#x.\n", hr); + todo_wine ok(stateblock2 == 0xdeadbeef, "Got unexpected stateblock %#x.\n", stateblock2); + + hr = IDirect3DDevice7_GetRenderState(device, D3DRENDERSTATE_LIGHTING, &value); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + ok(value == TRUE, "Got unexpected value %#x.\n", value); + + hr = IDirect3DDevice7_BeginStateBlock(device); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + + hr = IDirect3DDevice7_BeginStateBlock(device); + todo_wine ok(hr == D3DERR_INBEGINSTATEBLOCK, "Got unexpected hr %#x.\n", hr); + + hr = IDirect3DDevice7_ApplyStateBlock(device, stateblock); + todo_wine ok(hr == D3DERR_INBEGINSTATEBLOCK, "Got unexpected hr %#x.\n", hr); + + hr = IDirect3DDevice7_CaptureStateBlock(device, stateblock); + todo_wine ok(hr == D3DERR_INBEGINSTATEBLOCK, "Got unexpected hr %#x.\n", hr); + + hr = IDirect3DDevice7_CreateStateBlock(device, D3DSBT_ALL, &stateblock2); + todo_wine ok(hr == D3DERR_INBEGINSTATEBLOCK, "Got unexpected hr %#x.\n", hr); + + hr = IDirect3DDevice7_GetRenderState(device, D3DRENDERSTATE_LIGHTING, &value); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + ok(value == TRUE, "Got unexpected value %#x.\n", value); + + hr = IDirect3DDevice7_EndStateBlock(device, &stateblock2); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + + hr = IDirect3DDevice7_ApplyStateBlock(device, stateblock2); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + + hr = IDirect3DDevice7_GetRenderState(device, D3DRENDERSTATE_LIGHTING, &value); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + todo_wine ok(value == TRUE, "Got unexpected value %#x.\n", value); + + refcount = IDirect3DDevice7_Release(device); + ok(!refcount, "Device has %u references left.\n", refcount); + DestroyWindow(window); +} + START_TEST(ddraw7) { DDDEVICEIDENTIFIER2 identifier; @@ -15966,4 +16037,5 @@ START_TEST(ddraw7) test_multiply_transform(); test_alphatest(); test_clipper_refcount(); + test_begin_end_state_block(); } -- 2.20.1

3 17

[PATCH] d3d8: Keep previous stream source stride only when setting NULL buffer.
by Paul Gofman April 5, 2019

April 5, 2019

Signed-off-by: Paul Gofman <gofmanp(a)gmail.com> --- dlls/d3d8/device.c | 11 ++++----- dlls/d3d8/tests/device.c | 50 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 54 insertions(+), 7 deletions(-) diff --git a/dlls/d3d8/device.c b/dlls/d3d8/device.c index 5016ac4f17..40b5c86027 100644 --- a/dlls/d3d8/device.c +++ b/dlls/d3d8/device.c @@ -3264,16 +3264,13 @@ static HRESULT WINAPI d3d8_device_SetStreamSource(IDirect3DDevice8 *iface, iface, stream_idx, buffer, stride); wined3d_mutex_lock(); - if (!stride) - { - unsigned int cur_offset; - - hr = wined3d_device_get_stream_source(device->wined3d_device, stream_idx, &wined3d_buffer, - &cur_offset, &stride); - } if (!buffer_impl) + { + wined3d_device_get_stream_source(device->wined3d_device, stream_idx, &wined3d_buffer, + NULL, &stride); wined3d_buffer = NULL; + } else if (buffer_impl->draw_buffer) wined3d_buffer = buffer_impl->draw_buffer; else diff --git a/dlls/d3d8/tests/device.c b/dlls/d3d8/tests/device.c index c5ec9aa736..b602ebe3bb 100644 --- a/dlls/d3d8/tests/device.c +++ b/dlls/d3d8/tests/device.c @@ -2310,6 +2310,55 @@ cleanup: DestroyWindow(window); } +static void test_set_stream_source(void) +{ + IDirect3DVertexBuffer8 *vb, *current_vb; + IDirect3DDevice8 *device; + unsigned int stride; + IDirect3D8 *d3d8; + ULONG refcount; + HWND window; + HRESULT hr; + + window = create_window(); + ok(!!window, "Failed to create a window.\n"); + d3d8 = Direct3DCreate8(D3D_SDK_VERSION); + ok(!!d3d8, "Failed to create a D3D object.\n"); + if (!(device = create_device(d3d8, window, NULL))) + { + skip("Failed to create a 3D device, skipping test.\n"); + goto cleanup; + } + + hr = IDirect3DDevice8_CreateVertexBuffer(device, 512, 0, 0, D3DPOOL_DEFAULT, &vb); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + + hr = IDirect3DDevice8_SetStreamSource(device, 0, vb, 32); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + + hr = IDirect3DDevice8_SetStreamSource(device, 0, NULL, 0); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + hr = IDirect3DDevice8_GetStreamSource(device, 0, &current_vb, &stride); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + ok(!current_vb, "Got unexpected vb %p.\n", current_vb); + ok(stride == 32, "Got unexpected stride %u.\n", stride); + + hr = IDirect3DDevice8_SetStreamSource(device, 0, vb, 0); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + hr = IDirect3DDevice8_GetStreamSource(device, 0, &current_vb, &stride); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + ok(current_vb == vb, "Got unexpected vb %p.\n", current_vb); + IDirect3DVertexBuffer8_Release(current_vb); + ok(!stride, "Got unexpected stride %u.\n", stride); + + IDirect3DVertexBuffer8_Release(vb); + refcount = IDirect3DDevice8_Release(device); + ok(!refcount, "Device has %u references left.\n", refcount); +cleanup: + IDirect3D8_Release(d3d8); + DestroyWindow(window); +} + static void test_render_zero_triangles(void) { IDirect3DDevice8 *device; @@ -9747,6 +9796,7 @@ START_TEST(device) test_shader(); test_limits(); test_lights(); + test_set_stream_source(); test_ApplyStateBlock(); test_render_zero_triangles(); test_depth_stencil_reset(); -- 2.20.1

3 2

[PATCH v2 2/2] wined3d: Store and use stream offset in state block.
by Paul Gofman April 5, 2019

April 5, 2019

Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=21161 Signed-off-by: Paul Gofman <gofmanp(a)gmail.com> --- v2 changes: - use store_stream_offset bit field instead of stream_offset_ignore boolean; - removed an unused variable; - use array size in execute_test_chain_all(); - fixed test expected data reference in capture_reapply_stateblock_events[] and put exact comparison in light_check_data() back. dlls/d3d9/tests/stateblock.c | 79 ++++++++++++++++++++++++++-------- dlls/wined3d/device.c | 1 + dlls/wined3d/stateblock.c | 30 ++++++++++--- dlls/wined3d/wined3d_private.h | 3 +- 4 files changed, 87 insertions(+), 26 deletions(-) diff --git a/dlls/d3d9/tests/stateblock.c b/dlls/d3d9/tests/stateblock.c index 0983cf7b4f..5de5d4fcc6 100644 --- a/dlls/d3d9/tests/stateblock.c +++ b/dlls/d3d9/tests/stateblock.c @@ -67,6 +67,7 @@ struct state_test /* Apparently recorded stateblocks record and apply vertex declarations, * but don't capture them */ #define SB_QUIRK_RECORDED_VDECL_CAPTURE 0x00000001 +#define SB_QUIRK_STREAM_OFFSET_NOT_UPDATED 0x00000002 struct event_data { @@ -135,6 +136,7 @@ static void execute_test_chain(IDirect3DDevice9 *device, struct state_test *test { const void *data; + trace("event %u.\n", j); /* Execute the next event handler (if available). */ if (event[j].event_fn) { @@ -349,16 +351,17 @@ static void execute_test_chain_all(IDirect3DDevice9 *device, struct state_test * struct event capture_reapply_stateblock_events[] = { {begin_stateblock, SB_DATA_NONE, SB_DATA_TEST_IN}, - {end_stateblock, SB_DATA_NONE, SB_DATA_NONE}, + {end_stateblock, SB_DATA_NONE, SB_DATA_DEFAULT}, {capture_stateblock, SB_DATA_DEFAULT, SB_DATA_TEST_IN}, - {apply_stateblock, SB_DATA_DEFAULT, SB_DATA_NONE, SB_QUIRK_RECORDED_VDECL_CAPTURE}, + {capture_stateblock, SB_DATA_TEST_ALL, SB_DATA_DEFAULT}, + {apply_stateblock, SB_DATA_TEST_ALL, SB_DATA_DEFAULT, SB_QUIRK_RECORDED_VDECL_CAPTURE}, }; struct event create_stateblock_capture_apply_all_events[] = { {create_stateblock_all, SB_DATA_DEFAULT, SB_DATA_TEST_IN}, {capture_stateblock, SB_DATA_TEST_ALL, SB_DATA_DEFAULT}, - {apply_stateblock, SB_DATA_TEST_ALL, SB_DATA_NONE}, + {apply_stateblock, SB_DATA_TEST_ALL, SB_DATA_NONE, SB_QUIRK_STREAM_OFFSET_NOT_UPDATED}, }; struct event create_stateblock_apply_all_events[] = @@ -421,43 +424,52 @@ static void execute_test_chain_all(IDirect3DDevice9 *device, struct state_test * } trace("Running initial read state tests\n"); - execute_test_chain(device, test, ntests, read_events, 1, NULL); + execute_test_chain(device, test, ntests, read_events, ARRAY_SIZE(read_events), NULL); trace("Running write-read state tests\n"); - execute_test_chain(device, test, ntests, write_read_events, 2, NULL); + execute_test_chain(device, test, ntests, write_read_events, ARRAY_SIZE(write_read_events), NULL); trace("Running stateblock abort state tests\n"); - execute_test_chain(device, test, ntests, abort_stateblock_events, 3, &arg); + execute_test_chain(device, test, ntests, abort_stateblock_events, ARRAY_SIZE(abort_stateblock_events), &arg); trace("Running stateblock apply state tests\n"); - execute_test_chain(device, test, ntests, apply_stateblock_events, 3, &arg); + execute_test_chain(device, test, ntests, apply_stateblock_events, ARRAY_SIZE(apply_stateblock_events), &arg); trace("Running stateblock capture/reapply state tests\n"); - execute_test_chain(device, test, ntests, capture_reapply_stateblock_events, 4, &arg); + execute_test_chain(device, test, ntests, capture_reapply_stateblock_events, + ARRAY_SIZE(capture_reapply_stateblock_events), &arg); trace("Running create stateblock capture/apply all state tests\n"); - execute_test_chain(device, test, ntests, create_stateblock_capture_apply_all_events, 3, &arg); + execute_test_chain(device, test, ntests, create_stateblock_capture_apply_all_events, + ARRAY_SIZE(create_stateblock_capture_apply_all_events), &arg); trace("Running create stateblock apply state all tests\n"); - execute_test_chain(device, test, ntests, create_stateblock_apply_all_events, 3, &arg); + execute_test_chain(device, test, ntests, create_stateblock_apply_all_events, + ARRAY_SIZE(create_stateblock_apply_all_events), &arg); trace("Running create stateblock capture/apply vertex state tests\n"); - execute_test_chain(device, test, ntests, create_stateblock_capture_apply_vertex_events, 3, &arg); + execute_test_chain(device, test, ntests, create_stateblock_capture_apply_vertex_events, + ARRAY_SIZE(create_stateblock_capture_apply_vertex_events), &arg); trace("Running create stateblock apply vertex state tests\n"); - execute_test_chain(device, test, ntests, create_stateblock_apply_vertex_events, 3, &arg); + execute_test_chain(device, test, ntests, create_stateblock_apply_vertex_events, + ARRAY_SIZE(create_stateblock_apply_vertex_events), &arg); trace("Running create stateblock capture/apply pixel state tests\n"); - execute_test_chain(device, test, ntests, create_stateblock_capture_apply_pixel_events, 3, &arg); + execute_test_chain(device, test, ntests, create_stateblock_capture_apply_pixel_events, + ARRAY_SIZE(create_stateblock_capture_apply_pixel_events), &arg); trace("Running create stateblock apply pixel state tests\n"); - execute_test_chain(device, test, ntests, create_stateblock_apply_pixel_events, 3, &arg); + execute_test_chain(device, test, ntests, create_stateblock_apply_pixel_events, + ARRAY_SIZE(create_stateblock_apply_pixel_events), &arg); trace("Running rendertarget switch state tests\n"); - execute_test_chain(device, test, ntests, rendertarget_switch_events, 3, &arg); + execute_test_chain(device, test, ntests, rendertarget_switch_events, + ARRAY_SIZE(rendertarget_switch_events), &arg); trace("Running stateblock apply over rendertarget switch interrupt tests\n"); - execute_test_chain(device, test, ntests, rendertarget_stateblock_events, 5, &arg); + execute_test_chain(device, test, ntests, rendertarget_stateblock_events, + ARRAY_SIZE(rendertarget_stateblock_events), &arg); /* Cleanup resources */ for (i = 0; i < ntests; ++i) @@ -649,6 +661,7 @@ static const struct light_data light_poison_data = 0x1337c0de, }; + static const struct light_data light_default_data = { { @@ -1666,6 +1679,7 @@ struct resource_test_data IDirect3DPixelShader9 *ps; IDirect3DIndexBuffer9 *ib; IDirect3DVertexBuffer9 **vb; + unsigned int stream_offset, stream_stride; IDirect3DTexture9 **tex; }; @@ -1682,6 +1696,7 @@ static void resource_apply_data(IDirect3DDevice9 *device, const struct state_tes { const struct resource_test_arg *arg = test->test_arg; const struct resource_test_data *d = data; + IDirect3DVertexBuffer9 *temp_vb = NULL; unsigned int i; HRESULT hr; @@ -1699,10 +1714,26 @@ static void resource_apply_data(IDirect3DDevice9 *device, const struct state_tes for (i = 0; i < arg->stream_count; ++i) { - hr = IDirect3DDevice9_SetStreamSource(device, i, d->vb[i], 0, 64); - ok(SUCCEEDED(hr), "SetStreamSource (%u, %p, 0, 64) returned %#x.\n", - i, d->vb[i], hr); + if (!d->vb[i]) + { + /* Use a non NULL vertex buffer to really set offset and stride and avoid leftover values. */ + if (!temp_vb) + { + hr = IDirect3DDevice9_CreateVertexBuffer(device, 64, D3DUSAGE_DYNAMIC, + 0, D3DPOOL_DEFAULT, &temp_vb, NULL); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + } + hr = IDirect3DDevice9_SetStreamSource(device, i, temp_vb, d->stream_offset, d->stream_stride); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + } + + hr = IDirect3DDevice9_SetStreamSource(device, i, d->vb[i], d->stream_offset, d->stream_stride); + ok(hr == D3D_OK, "Unexpected SetStreamSource result, i %u, vb %p, " + "stream_offset %u, stream_stride %u), hr %#x.\n", + i, d->vb[i], d->stream_offset, d->stream_stride, hr); } + if (temp_vb) + IDirect3DVertexBuffer9_Release(temp_vb); for (i = 0; i < arg->tex_count; ++i) { @@ -1718,6 +1749,7 @@ static void resource_check_data(IDirect3DDevice9 *device, const struct state_tes const struct resource_test_data *poison = &ctx->poison_data; const struct resource_test_arg *arg = test->test_arg; const struct resource_test_data *d = expected_data; + unsigned int expected_offset; unsigned int i; HRESULT hr; void *ptr; @@ -1771,6 +1803,7 @@ static void resource_check_data(IDirect3DDevice9 *device, const struct state_tes IDirect3DIndexBuffer9_Release((IDirect3DIndexBuffer9 *)ptr); } + expected_offset = quirk & SB_QUIRK_STREAM_OFFSET_NOT_UPDATED ? 0 : d->stream_offset; for (i = 0; i < arg->stream_count; ++i) { ptr = poison->vb[i]; @@ -1778,6 +1811,8 @@ static void resource_check_data(IDirect3DDevice9 *device, const struct state_tes ok(SUCCEEDED(hr), "GetStreamSource (%u) returned %#x.\n", i, hr); ok(ptr == d->vb[i], "Chain stage %u, stream %u, expected vertex buffer %p, received %p.\n", chain_stage, i, d->vb[i], ptr); + ok(v == expected_offset, "Stream source offset %u, expected %u, stride %u.\n", v, expected_offset, w); + ok(w == d->stream_stride, "Stream source stride %u, expected %u.\n", w, d->stream_stride); if (SUCCEEDED(hr) && ptr) { IDirect3DIndexBuffer9_Release((IDirect3DVertexBuffer9 *)ptr); @@ -1811,6 +1846,8 @@ static void resource_default_data_init(struct resource_test_data *data, const st { data->vb[i] = NULL; } + data->stream_offset = 0; + data->stream_stride = 0; data->tex = HeapAlloc(GetProcessHeap(), 0, arg->tex_count * sizeof(*data->tex)); for (i = 0; i < arg->tex_count; ++i) { @@ -1885,6 +1922,8 @@ static void resource_test_data_init(IDirect3DDevice9 *device, 0, D3DPOOL_DEFAULT, &data->vb[i], NULL); ok(SUCCEEDED(hr), "CreateVertexBuffer (%u) returned %#x.\n", i, hr); } + data->stream_offset = 4; + data->stream_stride = 64; data->tex = HeapAlloc(GetProcessHeap(), 0, arg->tex_count * sizeof(*data->tex)); for (i = 0; i < arg->tex_count; ++i) { @@ -1908,6 +1947,8 @@ static void resource_poison_data_init(struct resource_test_data *data, const str { data->vb[i] = (IDirect3DVertexBuffer9 *)poison++; } + data->stream_offset = 16; + data->stream_stride = 128; data->tex = HeapAlloc(GetProcessHeap(), 0, arg->tex_count * sizeof(*data->tex)); for (i = 0; i < arg->tex_count; ++i) { diff --git a/dlls/wined3d/device.c b/dlls/wined3d/device.c index 9556aeef83..517fd55c8c 100644 --- a/dlls/wined3d/device.c +++ b/dlls/wined3d/device.c @@ -1388,6 +1388,7 @@ HRESULT CDECL wined3d_device_set_stream_source(struct wined3d_device *device, UI wined3d_buffer_decref(device->update_stateblock_state->streams[stream_idx].buffer); device->update_stateblock_state->streams[stream_idx].buffer = buffer; device->update_stateblock_state->streams[stream_idx].stride = stride; + device->update_stateblock_state->streams[stream_idx].offset = offset; if (device->recording) { diff --git a/dlls/wined3d/stateblock.c b/dlls/wined3d/stateblock.c index 36239207ae..05149ad1af 100644 --- a/dlls/wined3d/stateblock.c +++ b/dlls/wined3d/stateblock.c @@ -916,13 +916,17 @@ void CDECL wined3d_stateblock_capture(struct wined3d_stateblock *stateblock) if (!(map & 1)) continue; if (stateblock->stateblock_state.streams[i].stride != state->streams[i].stride + || stateblock->stateblock_state.streams[i].offset != state->streams[i].offset || stateblock->stateblock_state.streams[i].buffer != state->streams[i].buffer) { - TRACE("Updating stream source %u to %p, stride to %u.\n", - i, state->streams[i].buffer, - state->streams[i].stride); + TRACE("stateblock %p, stream source %u, buffer %p, stride %u, offset %u.\n", + stateblock, i, state->streams[i].buffer, state->streams[i].stride, + state->streams[i].offset); stateblock->stateblock_state.streams[i].stride = state->streams[i].stride; + if (stateblock->changed.store_stream_offset) + stateblock->stateblock_state.streams[i].offset = state->streams[i].offset; + if (state->streams[i].buffer) wined3d_buffer_incref(state->streams[i].buffer); if (stateblock->stateblock_state.streams[i].buffer) @@ -1211,18 +1215,23 @@ void CDECL wined3d_stateblock_apply(const struct wined3d_stateblock *stateblock) map = stateblock->changed.streamSource; for (i = 0; map; map >>= 1, ++i) { + unsigned int offset, stride; + if (!(map & 1)) continue; - state->streams[i].stride = stateblock->stateblock_state.streams[i].stride; if (stateblock->stateblock_state.streams[i].buffer) wined3d_buffer_incref(stateblock->stateblock_state.streams[i].buffer); if (state->streams[i].buffer) wined3d_buffer_decref(state->streams[i].buffer); state->streams[i].buffer = stateblock->stateblock_state.streams[i].buffer; + offset = stateblock->stateblock_state.streams[i].offset; + stride = stateblock->stateblock_state.streams[i].stride; + + state->streams[i].stride = stride; + state->streams[i].offset = offset; wined3d_device_set_stream_source(device, i, - stateblock->stateblock_state.streams[i].buffer, - 0, stateblock->stateblock_state.streams[i].stride); + stateblock->stateblock_state.streams[i].buffer, offset, stride); } map = stateblock->changed.streamFreq; @@ -1554,6 +1563,7 @@ void wined3d_stateblock_state_init(struct wined3d_stateblock_state *state, if (flags & WINED3D_STATE_INIT_DEFAULT) stateblock_state_init_default(state, &device->adapter->d3d_info); + } static HRESULT stateblock_init(struct wined3d_stateblock *stateblock, @@ -1565,6 +1575,8 @@ static HRESULT stateblock_init(struct wined3d_stateblock *stateblock, stateblock->device = device; wined3d_stateblock_state_init(&stateblock->stateblock_state, device, 0); + stateblock->changed.store_stream_offset = 1; + if (type == WINED3D_SBT_RECORDED) return WINED3D_OK; @@ -1599,6 +1611,12 @@ static HRESULT stateblock_init(struct wined3d_stateblock *stateblock, stateblock_init_contained_states(stateblock); wined3d_stateblock_capture(stateblock); + /* According to the tests, stream offset is not updated in the captured state if + * the state was captured on state block creation. This is not the case for + * state blocks initialized with BeginStateBlock / EndStateBlock, multiple + * captures get stream offsets updated. */ + stateblock->changed.store_stream_offset = 0; + return WINED3D_OK; } diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index 3243d07e17..0e984ae1bb 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -3666,7 +3666,8 @@ struct wined3d_saved_states DWORD vertexShader : 1; DWORD scissorRect : 1; DWORD blend_state : 1; - DWORD padding : 4; + DWORD store_stream_offset : 1; + DWORD padding : 3; }; struct StageState { -- 2.20.1

2 1

[PATCH] wineps: Include the meta region in the clip region.
by Huw Davies April 5, 2019

April 5, 2019

Signed-off-by: Huw Davies <huw(a)codeweavers.com> --- dlls/wineps.drv/clipping.c | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/dlls/wineps.drv/clipping.c b/dlls/wineps.drv/clipping.c index 59c8817bc2..62022c97c0 100644 --- a/dlls/wineps.drv/clipping.c +++ b/dlls/wineps.drv/clipping.c @@ -88,8 +88,8 @@ void PSDRV_SetClip( PHYSDEV dev ) return; } - hrgn = CreateRectRgn(0,0,0,0); - if (GetClipRgn(dev->hdc, hrgn)) + hrgn = CreateRectRgn(0, 0, 0, 0); + if (GetRandomRgn(dev->hdc, hrgn, 3) == 1) /* clip && meta */ { PSDRV_WriteGSave(dev); PSDRV_AddClip( dev, hrgn ); @@ -104,11 +104,12 @@ void PSDRV_SetClip( PHYSDEV dev ) void PSDRV_ResetClip( PHYSDEV dev ) { PSDRV_PDEVICE *physDev = get_psdrv_dev( dev ); - HRGN hrgn = CreateRectRgn(0,0,0,0); - BOOL empty; + HRGN hrgn; + + if (physDev->pathdepth) return; - empty = !GetClipRgn(dev->hdc, hrgn); - if(!empty && !physDev->pathdepth) + hrgn = CreateRectRgn(0, 0, 0, 0); + if (GetRandomRgn(dev->hdc, hrgn, 3) == 1) /* clip && meta */ PSDRV_WriteGRestore(dev); DeleteObject(hrgn); } -- 2.18.0

1 0