February 2019 - Wine-devel - list.winehq.org

[PATCH v2 1/5] d3d9: Don't upload unused system memory vertex buffers.
by Matteo Bruni 26 Feb '19

26 Feb '19

Signed-off-by: Matteo Bruni <mbruni(a)codeweavers.com> --- v2: Add a couple of comments. dlls/d3d9/d3d9_private.h | 2 ++ dlls/d3d9/device.c | 26 ++++++++++++++++++++++++-- dlls/d3d9/tests/visual.c | 23 +++++++++++++++++++++++ dlls/d3d9/vertexdeclaration.c | 2 +- 4 files changed, 50 insertions(+), 3 deletions(-) diff --git a/dlls/d3d9/d3d9_private.h b/dlls/d3d9/d3d9_private.h index 3fe0376e5c1..50b18b1ed36 100644 --- a/dlls/d3d9/d3d9_private.h +++ b/dlls/d3d9/d3d9_private.h @@ -256,6 +256,8 @@ struct d3d9_vertex_declaration IDirect3DDevice9Ex *parent_device; }; +HRESULT convert_to_wined3d_declaration(const D3DVERTEXELEMENT9 *d3d9_elements, + struct wined3d_vertex_element **wined3d_elements, UINT *element_count) DECLSPEC_HIDDEN; HRESULT d3d9_vertex_declaration_create(struct d3d9_device *device, const D3DVERTEXELEMENT9 *elements, struct d3d9_vertex_declaration **declaration) DECLSPEC_HIDDEN; struct d3d9_vertex_declaration *unsafe_impl_from_IDirect3DVertexDeclaration9( diff --git a/dlls/d3d9/device.c b/dlls/d3d9/device.c index 6cc3f180b09..ef73adcc789 100644 --- a/dlls/d3d9/device.c +++ b/dlls/d3d9/device.c @@ -2730,23 +2730,45 @@ static void d3d9_generate_auto_mipmaps(struct d3d9_device *device) static void d3d9_device_upload_sysmem_vertex_buffers(struct d3d9_device *device, int base_vertex, unsigned int start_vertex, unsigned int vertex_count) { + struct wined3d_vertex_declaration *wined3d_decl; struct wined3d_box box = {0, 0, 0, 1, 0, 1}; + unsigned int i, offset, stride, map, count; + struct wined3d_vertex_element *elements; struct d3d9_vertexbuffer *d3d9_buffer; struct wined3d_resource *dst_resource; - unsigned int i, offset, stride, map; + struct d3d9_vertex_declaration *decl; struct wined3d_buffer *dst_buffer; struct wined3d_resource_desc desc; HRESULT hr; if (!device->sysmem_vb) return; + wined3d_decl = wined3d_device_get_vertex_declaration(device->wined3d_device); + if (!wined3d_decl) + return; if (base_vertex >= 0 || start_vertex >= -base_vertex) start_vertex += base_vertex; else FIXME("System memory vertex data offset is negative.\n"); - map = device->sysmem_vb; + /* Make sure to only upload buffers that are used by the current draw: + * released buffers might still be bound as stream sources. */ + decl = wined3d_vertex_declaration_get_parent(wined3d_decl); + if (!decl->elements) + { + map = 1; + } + else + { + map = 0; + if (FAILED(convert_to_wined3d_declaration(decl->elements, &elements, &count))) + return; + for (i = 0; i < count; ++i) + map |= 1u << elements[i].input_slot; + heap_free(elements); + } + map &= device->sysmem_vb; while (map) { i = wined3d_bit_scan(&map); diff --git a/dlls/d3d9/tests/visual.c b/dlls/d3d9/tests/visual.c index 52d67c81991..0e572984784 100644 --- a/dlls/d3d9/tests/visual.c +++ b/dlls/d3d9/tests/visual.c @@ -24713,6 +24713,29 @@ static void test_sysmem_draw(void) colour = getPixelColor(device, 320, 240); ok(color_match(colour, 0x00443322, 1), "Got unexpected colour 0x%08x.\n", colour); + /* Test that releasing but not unbinding a vertex buffer doesn't break. */ + hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + hr = IDirect3DDevice9_SetStreamSource(device, 0, vb, 0, sizeof(*quad)); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + hr = IDirect3DDevice9_SetIndices(device, ib); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + + IDirect3DVertexBuffer9_Release(vb_s1); + + hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0x77777777, 0.0f, 0); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + + hr = IDirect3DDevice9_BeginScene(device); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + hr = IDirect3DDevice9_DrawIndexedPrimitive(device, D3DPT_TRIANGLESTRIP, 0, 0, 4, 0, 2); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + hr = IDirect3DDevice9_EndScene(device); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + + colour = getPixelColor(device, 320, 240); + ok(color_match(colour, 0x00007f7f, 1), "Got unexpected colour 0x%08x.\n", colour); + hr = IDirect3DDevice9_CreateTexture(device, 2, 2, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_SYSTEMMEM, &texture, NULL); ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); memset(&lr, 0, sizeof(lr)); diff --git a/dlls/d3d9/vertexdeclaration.c b/dlls/d3d9/vertexdeclaration.c index b6445255238..5f07207a482 100644 --- a/dlls/d3d9/vertexdeclaration.c +++ b/dlls/d3d9/vertexdeclaration.c @@ -320,7 +320,7 @@ static const struct wined3d_parent_ops d3d9_vertexdeclaration_wined3d_parent_ops d3d9_vertexdeclaration_wined3d_object_destroyed, }; -static HRESULT convert_to_wined3d_declaration(const D3DVERTEXELEMENT9 *d3d9_elements, +HRESULT convert_to_wined3d_declaration(const D3DVERTEXELEMENT9 *d3d9_elements, struct wined3d_vertex_element **wined3d_elements, UINT *element_count) { const D3DVERTEXELEMENT9* element; -- 2.19.2

5 15

[PATCH 1/3] Mark certain internal functions, such as
by Timothy Pearson 26 Feb '19

26 Feb '19

wine_server_call(), as potentially crossing DLL module boundaries This is needed to allow some systems, such as ppc64, to update module-specific registers (TOC) Signed-off-by: Timothy Pearson <tpearson(a)raptorengineering.com> --- dlls/shell32/shell32_main.c | 2 +- include/windef.h | 7 +++++++ include/wine/library.h | 18 +++++++++--------- include/wine/server.h | 2 +- 4 files changed, 18 insertions(+), 11 deletions(-) diff --git a/dlls/shell32/shell32_main.c b/dlls/shell32/shell32_main.c index a791966031..71ebe218fb 100644 --- a/dlls/shell32/shell32_main.c +++ b/dlls/shell32/shell32_main.c @@ -810,7 +810,7 @@ static INT_PTR CALLBACK AboutDlgProc( HWND hWnd, UINT msg, WPARAM wParam, { ABOUT_INFO *info = (ABOUT_INFO *)lParam; WCHAR template[512], buffer[512], version[64]; - extern const char *wine_get_build_id(void); + extern FARCALL const char *wine_get_build_id(void); if (info) { diff --git a/include/windef.h b/include/windef.h index f9a570d9cd..ea9f32b5a0 100644 --- a/include/windef.h +++ b/include/windef.h @@ -50,6 +50,13 @@ extern "C" { # endif #endif +#if defined(__powerpc64__) && defined (__GNUC__) + /* ppc64 relies on long calls being generated for calls crossing DLL boundaries (r2 save / restore) */ +# define FARCALL __attribute__((__longcall__)) +#else +# define FARCALL +#endif + #ifndef __stdcall # ifdef __i386__ # ifdef __GNUC__ diff --git a/include/wine/library.h b/include/wine/library.h index 242bb69f17..3c09d89ac9 100644 --- a/include/wine/library.h +++ b/include/wine/library.h @@ -37,15 +37,15 @@ extern "C" { /* configuration */ -extern const char *wine_get_build_dir(void); -extern const char *wine_get_config_dir(void); -extern const char *wine_get_data_dir(void); -extern const char *wine_get_server_dir(void); -extern const char *wine_get_user_name(void); -extern const char *wine_get_version(void); -extern const char *wine_get_build_id(void); -extern void wine_init_argv0_path( const char *argv0 ); -extern void wine_exec_wine_binary( const char *name, char **argv, const char *env_var ); +extern FARCALL const char *wine_get_build_dir(void); +extern FARCALL const char *wine_get_config_dir(void); +extern FARCALL const char *wine_get_data_dir(void); +extern FARCALL const char *wine_get_server_dir(void); +extern FARCALL const char *wine_get_user_name(void); +extern FARCALL const char *wine_get_version(void); +extern FARCALL const char *wine_get_build_id(void); +extern FARCALL void wine_init_argv0_path( const char *argv0 ); +extern FARCALL void wine_exec_wine_binary( const char *name, char **argv, const char *env_var ); /* dll loading */ diff --git a/include/wine/server.h b/include/wine/server.h index d573d1f7ad..509f958a0d 100644 --- a/include/wine/server.h +++ b/include/wine/server.h @@ -49,7 +49,7 @@ struct __server_request_info struct __server_iovec data[__SERVER_MAX_DATA]; /* request variable size data */ }; -extern unsigned int wine_server_call( void *req_ptr ); +extern unsigned int FARCALL wine_server_call( void *req_ptr ); extern void CDECL wine_server_send_fd( int fd ); extern int CDECL wine_server_fd_to_handle( int fd, unsigned int access, unsigned int attributes, HANDLE *handle ); extern int CDECL wine_server_handle_to_fd( HANDLE handle, unsigned int access, int *unix_fd, unsigned int *options ); -- 2.20.1

2 1

[PATCH] wined3d: Add a setting to turn off aggressive optimization on NVIDIA.
by Paul Gofman 26 Feb '19

26 Feb '19

NVIDIA drivers perform too aggressive optimization involving change of computation order (aka 'fastmath') by default. The setting helps to workaround bugs like https://bugs.winehq.org/show_bug.cgi?id=35207. Signed-off-by: Paul Gofman <gofmanp(a)gmail.com> --- dlls/wined3d/adapter_gl.c | 17 +++++++++++++++++ dlls/wined3d/glsl_shader.c | 3 +++ dlls/wined3d/wined3d_main.c | 8 ++++++++ dlls/wined3d/wined3d_private.h | 2 ++ 4 files changed, 30 insertions(+) diff --git a/dlls/wined3d/adapter_gl.c b/dlls/wined3d/adapter_gl.c index 751e1672e2..ae1680605a 100644 --- a/dlls/wined3d/adapter_gl.c +++ b/dlls/wined3d/adapter_gl.c @@ -832,6 +832,13 @@ static BOOL match_broken_viewport_subpixel_bits(const struct wined3d_gl_info *gl return !wined3d_caps_gl_ctx_test_viewport_subpixel_bits(ctx); } +static BOOL match_disable_nvidia_fastmath(const struct wined3d_gl_info *gl_info, + struct wined3d_caps_gl_ctx *ctx, const char *gl_renderer, enum wined3d_gl_vendor gl_vendor, + enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device) +{ + return wined3d_settings.disable_nvidia_fastmath && gl_vendor == GL_VENDOR_NVIDIA; +} + static void quirk_apple_glsl_constants(struct wined3d_gl_info *gl_info) { /* MacOS needs uniforms for relative addressing offsets. This can @@ -986,6 +993,11 @@ static void quirk_broken_viewport_subpixel_bits(struct wined3d_gl_info *gl_info) } } +static void quirk_disable_nvidia_fastmath(struct wined3d_gl_info *gl_info) +{ + gl_info->quirks |= WINED3D_QUIRK_DISABLE_NVIDIA_FASTMATH; +} + static const struct wined3d_gpu_description *query_gpu_description(const struct wined3d_gl_info *gl_info, UINT64 *vram_bytes) { @@ -1130,6 +1142,11 @@ static void fixup_extensions(struct wined3d_gl_info *gl_info, struct wined3d_cap quirk_broken_viewport_subpixel_bits, "NVIDIA viewport subpixel bits bug" }, + { + match_disable_nvidia_fastmath, + quirk_disable_nvidia_fastmath, + "Disabling fastmath optimization on NVIDIA." + }, }; for (i = 0; i < ARRAY_SIZE(quirk_table); ++i) diff --git a/dlls/wined3d/glsl_shader.c b/dlls/wined3d/glsl_shader.c index 2f65b75084..8a042a82d4 100644 --- a/dlls/wined3d/glsl_shader.c +++ b/dlls/wined3d/glsl_shader.c @@ -2916,6 +2916,9 @@ static void shader_generate_glsl_declarations(const struct wined3d_context *cont shader_addline(buffer, ";\n"); } } + + if (gl_info->quirks & WINED3D_QUIRK_DISABLE_NVIDIA_FASTMATH) + shader_addline(buffer, "#pragma optionNV(fastmath off)\n"); } /* Prototypes */ diff --git a/dlls/wined3d/wined3d_main.c b/dlls/wined3d/wined3d_main.c index feab178e24..b9db439d59 100644 --- a/dlls/wined3d/wined3d_main.c +++ b/dlls/wined3d/wined3d_main.c @@ -83,6 +83,7 @@ struct wined3d_settings wined3d_settings = TRUE, /* Prefer multisample textures to multisample renderbuffers. */ ~0u, /* Don't force a specific sample count by default. */ FALSE, /* Don't range check relative addressing indices in float constants. */ + FALSE, /* Do not disable fastmath optimization on NVIDIA. */ ~0U, /* No VS shader model limit by default. */ ~0U, /* No HS shader model limit by default. */ ~0U, /* No DS shader model limit by default. */ @@ -297,6 +298,13 @@ static BOOL wined3d_dll_init(HINSTANCE hInstDLL) TRACE("Checking relative addressing indices in float constants.\n"); wined3d_settings.check_float_constants = TRUE; } + if (!get_config_key(hkey, appkey, "DisableNVIDIAFastmath", buffer, size) + && !strcmp(buffer, "enabled")) + { + TRACE("Disabling fastmath optimization on NVIDIA.\n"); + wined3d_settings.disable_nvidia_fastmath = TRUE; + } + if (!get_config_key_dword(hkey, appkey, "MaxShaderModelVS", &wined3d_settings.max_sm_vs)) TRACE("Limiting VS shader model to %u.\n", wined3d_settings.max_sm_vs); if (!get_config_key_dword(hkey, appkey, "MaxShaderModelHS", &wined3d_settings.max_sm_hs)) diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index a6bfd132f4..76b31f61e4 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -71,6 +71,7 @@ #define WINED3D_QUIRK_INFO_LOG_SPAM 0x00000080 #define WINED3D_QUIRK_LIMITED_TEX_FILTERING 0x00000100 #define WINED3D_QUIRK_BROKEN_ARB_FOG 0x00000200 +#define WINED3D_QUIRK_DISABLE_NVIDIA_FASTMATH 0x00000400 struct fragment_pipeline; struct wined3d_context; @@ -396,6 +397,7 @@ struct wined3d_settings unsigned int multisample_textures; unsigned int sample_count; BOOL check_float_constants; + BOOL disable_nvidia_fastmath; unsigned int max_sm_vs; unsigned int max_sm_hs; unsigned int max_sm_ds; -- 2.20.1

2 2

[PATCH 1/9] ntoskrnl.exe/tests: Add object reference tests.
by Jacek Caban 26 Feb '19

26 Feb '19

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/ntoskrnl.exe/ntoskrnl.exe.spec | 6 +- dlls/ntoskrnl.exe/tests/driver.c | 139 +++++++++++++++++++++++++++- 2 files changed, 140 insertions(+), 5 deletions(-)

3 6

[PATCH vkd3d 6/8] vkd3d-shader: Introduce is_control_point_phase() helper.
by Józef Kucia 26 Feb '19

26 Feb '19

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- libs/vkd3d-shader/spirv.c | 19 +++++++++++-------- 1 file changed, 11 insertions(+), 8 deletions(-) diff --git a/libs/vkd3d-shader/spirv.c b/libs/vkd3d-shader/spirv.c index 34e274fa41ec..de4c683ee8ae 100644 --- a/libs/vkd3d-shader/spirv.c +++ b/libs/vkd3d-shader/spirv.c @@ -1997,6 +1997,11 @@ struct vkd3d_dxbc_compiler size_t shader_phases_size; }; +static bool is_control_point_phase(const struct vkd3d_shader_phase *phase) +{ + return phase && phase->type == VKD3DSIH_HS_CONTROL_POINT_PHASE; +} + static void vkd3d_dxbc_compiler_emit_initial_declarations(struct vkd3d_dxbc_compiler *compiler); struct vkd3d_dxbc_compiler *vkd3d_dxbc_compiler_create(const struct vkd3d_shader_version *shader_version, @@ -3912,8 +3917,7 @@ static void vkd3d_dxbc_compiler_emit_output(struct vkd3d_dxbc_compiler *compiler shader_signature = is_patch_constant ? compiler->patch_constant_signature : compiler->output_signature; - array_size = phase && phase->type == VKD3DSIH_HS_CONTROL_POINT_PHASE - ? compiler->output_control_point_count : 0; + array_size = is_control_point_phase(phase) ? compiler->output_control_point_count : 0; if (!(signature_element = vkd3d_find_signature_element_for_reg(shader_signature, &signature_idx, reg->idx[0].offset, dst->write_mask))) @@ -3993,7 +3997,6 @@ static void vkd3d_dxbc_compiler_emit_output(struct vkd3d_dxbc_compiler *compiler storage_class = SpvStorageClassPrivate; vkd3d_symbol_make_register(&reg_symbol, reg); - if (!use_private_variable) var_id = id; else if ((entry = rb_get(&compiler->symbol_table, &reg_symbol))) @@ -4006,7 +4009,7 @@ static void vkd3d_dxbc_compiler_emit_output(struct vkd3d_dxbc_compiler *compiler vkd3d_symbol_set_register_info(&reg_symbol, var_id, storage_class, use_private_variable ? VKD3D_TYPE_FLOAT : component_type, VKD3DSP_WRITEMASK_ALL); reg_symbol.info.reg.is_aggregate = use_private_variable ? false : array_size; - if (!use_private_variable && phase && phase->type == VKD3DSIH_HS_CONTROL_POINT_PHASE) + if (!use_private_variable && is_control_point_phase(phase)) { struct vkd3d_shader_register r; @@ -4196,7 +4199,7 @@ static void vkd3d_dxbc_compiler_emit_shader_epilogue_function(struct vkd3d_dxbc_ param_id[i] = vkd3d_spirv_build_op_load(builder, type_id, param_id[i], SpvMemoryAccessMaskNone); } - if (phase && phase->type == VKD3DSIH_HS_CONTROL_POINT_PHASE) + if (is_control_point_phase(phase)) { struct vkd3d_shader_register r; uint32_t invocation_id; @@ -5227,7 +5230,7 @@ static void vkd3d_dxbc_compiler_leave_shader_phase(struct vkd3d_dxbc_compiler *c * in fork/join phases. We have to remove all output registers' symbols * when leaving the control point phase. */ - if (phase->type == VKD3DSIH_HS_CONTROL_POINT_PHASE) + if (is_control_point_phase(phase)) { memset(&reg, 0, sizeof(reg)); reg.type = VKD3DSPR_OUTPUT; @@ -5313,7 +5316,7 @@ static const struct vkd3d_shader_phase *vkd3d_dxbc_compiler_get_control_point_ph return NULL; phase = &compiler->shader_phases[0]; - if (phase->type == VKD3DSIH_HS_CONTROL_POINT_PHASE) + if (is_control_point_phase(phase)) return phase; return NULL; @@ -5438,7 +5441,7 @@ static void vkd3d_dxbc_compiler_emit_hull_shader_main(struct vkd3d_dxbc_compiler for (i = 0; i < compiler->shader_phase_count; ++i) { phase = &compiler->shader_phases[i]; - if (phase->type == VKD3DSIH_HS_CONTROL_POINT_PHASE) + if (is_control_point_phase(phase)) continue; if (phase->instance_count) -- 2.19.2

2 1

[PATCH vkd3d 4/8] vkd3d-shader: Handle partial shader output updates in epilogue functions.
by Józef Kucia 26 Feb '19

26 Feb '19

From: Józef Kucia <jkucia(a)codeweavers.com> Fork and join phases quite often write only a few components of an output variable. Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- libs/vkd3d-shader/spirv.c | 31 ++++++++++++++++++++----------- 1 file changed, 20 insertions(+), 11 deletions(-) diff --git a/libs/vkd3d-shader/spirv.c b/libs/vkd3d-shader/spirv.c index 9aee6928e993..0e6df4712ecf 100644 --- a/libs/vkd3d-shader/spirv.c +++ b/libs/vkd3d-shader/spirv.c @@ -1980,6 +1980,7 @@ struct vkd3d_dxbc_compiler uint32_t array_element_mask; } *output_info; uint32_t private_output_variable[MAX_REG_OUTPUT + 1]; /* 1 entry for oDepth */ + uint32_t private_output_variable_write_mask[MAX_REG_OUTPUT + 1]; /* 1 entry for oDepth */ uint32_t epilogue_function_id; uint32_t dummy_sampler_id; @@ -3998,6 +3999,7 @@ static void vkd3d_dxbc_compiler_emit_output(struct vkd3d_dxbc_compiler *compiler { unsigned int idx = vkd3d_dxbc_compiler_get_output_variable_index(compiler, reg->idx[0].offset); compiler->private_output_variable[idx] = var_id; + compiler->private_output_variable_write_mask[idx] |= dst->write_mask; if (!compiler->epilogue_function_id) compiler->epilogue_function_id = vkd3d_spirv_alloc_id(builder); } @@ -4045,15 +4047,16 @@ static void vkd3d_dxbc_compiler_emit_shader_phase_output(struct vkd3d_dxbc_compi static void vkd3d_dxbc_compiler_emit_store_shader_output(struct vkd3d_dxbc_compiler *compiler, const struct vkd3d_shader_signature_element *output, - const struct vkd3d_shader_output_info *output_info, uint32_t val_id) + const struct vkd3d_shader_output_info *output_info, uint32_t val_id, unsigned int write_mask) { + unsigned int dst_write_mask, use_mask, uninit_mask, swizzle, mask; struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; uint32_t type_id, zero_id, ptr_type_id, chain_id, object_id; - uint32_t write_mask, use_mask, uninit_mask, swizzle, mask; - uint32_t output_id, indexes[1]; unsigned int i, index; + uint32_t output_id; - write_mask = output->mask & 0xff; + dst_write_mask = output->mask & 0xff; + write_mask &= dst_write_mask; use_mask = (output->mask >> 8) & 0xff; if (output_info->component_type != VKD3D_TYPE_FLOAT) @@ -4063,10 +4066,11 @@ static void vkd3d_dxbc_compiler_emit_store_shader_output(struct vkd3d_dxbc_compi } swizzle = get_shader_output_swizzle(compiler, output->register_index); - uninit_mask = write_mask & use_mask; + uninit_mask = dst_write_mask & use_mask; if (uninit_mask) { /* Set values to 0 for not initialized shader output components. */ + write_mask |= uninit_mask; zero_id = vkd3d_dxbc_compiler_get_constant_vector(compiler, output_info->component_type, VKD3D_VEC4_SIZE, 0); val_id = vkd3d_dxbc_compiler_emit_vector_shuffle(compiler, @@ -4083,7 +4087,8 @@ static void vkd3d_dxbc_compiler_emit_store_shader_output(struct vkd3d_dxbc_compi if (!output_info->array_element_mask) { - vkd3d_spirv_build_op_store(builder, output_id, val_id, SpvMemoryAccessMaskNone); + vkd3d_dxbc_compiler_emit_store(compiler, + output_id, dst_write_mask, output_info->component_type, SpvStorageClassOutput, write_mask, val_id); return; } @@ -4096,12 +4101,13 @@ static void vkd3d_dxbc_compiler_emit_store_shader_output(struct vkd3d_dxbc_compi if (!(write_mask & (VKD3DSP_WRITEMASK_0 << i))) continue; - indexes[0] = vkd3d_dxbc_compiler_get_constant_uint(compiler, index++); - chain_id = vkd3d_spirv_build_op_access_chain(builder, ptr_type_id, - output_id, indexes, ARRAY_SIZE(indexes)); + chain_id = vkd3d_spirv_build_op_access_chain1(builder, + ptr_type_id, output_id, vkd3d_dxbc_compiler_get_constant_uint(compiler, index)); object_id = vkd3d_dxbc_compiler_emit_swizzle(compiler, val_id, write_mask, output_info->component_type, VKD3D_NO_SWIZZLE, VKD3DSP_WRITEMASK_0 << i); - vkd3d_spirv_build_op_store(builder, chain_id, object_id, SpvMemoryAccessMaskNone); + vkd3d_dxbc_compiler_emit_store(compiler, chain_id, VKD3DSP_WRITEMASK_0 << index, + output_info->component_type, SpvStorageClassOutput, VKD3DSP_WRITEMASK_0 << i, object_id); + ++index; } } @@ -4116,6 +4122,7 @@ static void vkd3d_dxbc_compiler_emit_shader_epilogue_function(struct vkd3d_dxbc_ STATIC_ASSERT(ARRAY_SIZE(compiler->private_output_variable) == ARRAY_SIZE(param_id)); STATIC_ASSERT(ARRAY_SIZE(compiler->private_output_variable) == ARRAY_SIZE(param_type_id)); + STATIC_ASSERT(ARRAY_SIZE(compiler->private_output_variable) == ARRAY_SIZE(compiler->private_output_variable_write_mask)); function_id = compiler->epilogue_function_id; @@ -4155,7 +4162,8 @@ static void vkd3d_dxbc_compiler_emit_shader_epilogue_function(struct vkd3d_dxbc_ continue; vkd3d_dxbc_compiler_emit_store_shader_output(compiler, - &signature->elements[i], &compiler->output_info[i], param_id[variable_idx]); + &signature->elements[i], &compiler->output_info[i], + param_id[variable_idx], compiler->private_output_variable_write_mask[variable_idx]); } vkd3d_spirv_build_op_return(&compiler->spirv_builder); @@ -4163,6 +4171,7 @@ static void vkd3d_dxbc_compiler_emit_shader_epilogue_function(struct vkd3d_dxbc_ memset(compiler->output_info, 0, signature->element_count * sizeof(*compiler->output_info)); memset(compiler->private_output_variable, 0, sizeof(compiler->private_output_variable)); + memset(compiler->private_output_variable_write_mask, 0, sizeof(compiler->private_output_variable_write_mask)); compiler->epilogue_function_id = 0; } -- 2.19.2

2 1

[PATCH vkd3d 2/8] vkd3d-shader: Remove output register symbols while leaving control point phase.
by Józef Kucia 26 Feb '19

26 Feb '19

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- libs/vkd3d-shader/spirv.c | 34 +++++++++++++++++++++++++++++++++- 1 file changed, 33 insertions(+), 1 deletion(-) diff --git a/libs/vkd3d-shader/spirv.c b/libs/vkd3d-shader/spirv.c index e169aa0567ee..a925d68eeeb4 100644 --- a/libs/vkd3d-shader/spirv.c +++ b/libs/vkd3d-shader/spirv.c @@ -5124,9 +5124,12 @@ static void vkd3d_dxbc_compiler_emit_dcl_thread_group(struct vkd3d_dxbc_compiler static void vkd3d_dxbc_compiler_leave_shader_phase(struct vkd3d_dxbc_compiler *compiler, const struct vkd3d_shader_phase *phase) { + const struct vkd3d_shader_signature *signature = compiler->output_signature; struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; struct vkd3d_shader_register reg; struct vkd3d_symbol reg_symbol; + struct rb_entry *entry; + unsigned int i; vkd3d_spirv_build_op_function_end(builder); @@ -5139,12 +5142,41 @@ static void vkd3d_dxbc_compiler_leave_shader_phase(struct vkd3d_dxbc_compiler *c compiler->temp_id = 0; compiler->temp_count = 0; + /* + * Output regsiters have a different purpose in the control point phase and + * in fork/join phases. We have to remove all output registers' symbols + * when leaving the control point phase. + */ + if (phase->type == VKD3DSIH_HS_CONTROL_POINT_PHASE) + { + memset(&reg, 0, sizeof(reg)); + reg.type = VKD3DSPR_OUTPUT; + reg.idx[1].offset = ~0u; + + for (i = 0; i < signature->element_count; ++i) + { + const struct vkd3d_shader_signature_element *e = &signature->elements[i]; + + reg.idx[0].offset = e->register_index; + vkd3d_symbol_make_register(&reg_symbol, &reg); + if ((entry = rb_get(&compiler->symbol_table, &reg_symbol))) + { + rb_remove(&compiler->symbol_table, entry); + vkd3d_symbol_free(entry, NULL); + } + } + } + if (phase->instance_count) { reg.type = phase->type == VKD3DSIH_HS_FORK_PHASE ? VKD3DSPR_FORKINSTID : VKD3DSPR_JOININSTID; reg.idx[0].offset = ~0u; vkd3d_symbol_make_register(&reg_symbol, &reg); - rb_remove_key(&compiler->symbol_table, &reg_symbol); + if ((entry = rb_get(&compiler->symbol_table, &reg_symbol))) + { + rb_remove(&compiler->symbol_table, entry); + vkd3d_symbol_free(entry, NULL); + } } } -- 2.19.2

2 1

[PATCH vkd3d 8/8] tests: Fix domain shader code in test_tessellation_dcl_index_range().
by Józef Kucia 26 Feb '19

26 Feb '19

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- tests/d3d12.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/d3d12.c b/tests/d3d12.c index 24db7a89dd5c..5ae8511fc74a 100644 --- a/tests/d3d12.c +++ b/tests/d3d12.c @@ -22815,9 +22815,9 @@ static void test_tessellation_dcl_index_range(void) static const D3D12_SHADER_BYTECODE hs = {hs_code, sizeof(hs_code)}; static const DWORD ds_code[] = { - 0x43425844, 0xeb6b7631, 0x07f5469e, 0xed0cbf4a, 0x7158b3a6, 0x00000001, 0x00000284, 0x00000004, + 0x43425844, 0x4f187d50, 0x6743fe93, 0x10dfbe63, 0xf8cfd202, 0x00000001, 0x00000284, 0x00000004, 0x00000030, 0x00000064, 0x00000128, 0x0000015c, 0x4e475349, 0x0000002c, 0x00000001, 0x00000008, - 0x00000020, 0x00000000, 0x00000000, 0x00000003, 0x00000000, 0x00000f0f, 0x505f5653, 0x5449534f, + 0x00000020, 0x00000000, 0x00000001, 0x00000003, 0x00000000, 0x00000f0f, 0x505f5653, 0x5449534f, 0x004e4f49, 0x47534350, 0x000000bc, 0x00000006, 0x00000008, 0x00000098, 0x00000000, 0x0000000b, 0x00000003, 0x00000000, 0x00000001, 0x00000098, 0x00000001, 0x0000000b, 0x00000003, 0x00000001, 0x00000001, 0x00000098, 0x00000002, 0x0000000b, 0x00000003, 0x00000002, 0x00000001, 0x00000098, -- 2.19.2

2 1

[PATCH vkd3d 7/8] tests: Add test for hull shader control point phase.
by Józef Kucia 26 Feb '19

26 Feb '19

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- tests/d3d12.c | 151 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 151 insertions(+) diff --git a/tests/d3d12.c b/tests/d3d12.c index d8a13a711156..24db7a89dd5c 100644 --- a/tests/d3d12.c +++ b/tests/d3d12.c @@ -22909,6 +22909,156 @@ static void test_tessellation_dcl_index_range(void) destroy_test_context(&context); } +static void test_hull_shader_control_point_phase(void) +{ + static const float white[] = {1.0f, 1.0f, 1.0f, 1.0f}; + D3D12_GRAPHICS_PIPELINE_STATE_DESC pso_desc; + ID3D12GraphicsCommandList *command_list; + struct test_context_desc desc; + struct test_context context; + ID3D12CommandQueue *queue; + HRESULT hr; + + static const DWORD vs_code[] = + { +#if 0 + void main() + { + } +#endif + 0x43425844, 0x590b08ae, 0x11d28adb, 0x825a5628, 0x34c0c208, 0x00000001, 0x00000064, 0x00000003, + 0x0000002c, 0x0000003c, 0x0000004c, 0x4e475349, 0x00000008, 0x00000000, 0x00000008, 0x4e47534f, + 0x00000008, 0x00000000, 0x00000008, 0x58454853, 0x00000010, 0x00010050, 0x00000004, 0x0100086a, + 0x0100003e, + }; + static const D3D12_SHADER_BYTECODE vs = {vs_code, sizeof(vs_code)}; +#if 0 + struct data + { + float4 position : SV_Position; + }; + + struct patch_constant_data + { + float edges[3] : SV_TessFactor; + float inside : SV_InsideTessFactor; + }; + + void patch_constant(out patch_constant_data output) + { + output.edges[0] = output.edges[1] = output.edges[2] = 1.0f; + output.inside = 1.0f; + } + + [domain("tri")] + [outputcontrolpoints(3)] + [partitioning("integer")] + [outputtopology("triangle_cw")] + [patchconstantfunc("patch_constant")] + data hs_main(uint i : SV_OutputControlPointID) + { + data output; + + if (i == 0) + output.position = float4(-1, 1, 0, 1); + else if (i == 1) + output.position = float4(3, 1, 0, 1); + else + output.position = float4(-1, -3, 0, 1); + + return output; + } + + [domain("tri")] + void ds_main(patch_constant_data input, + float3 tess_coord : SV_DomainLocation, + const OutputPatch<data, 3> patch, + out data output) + { + uint index = uint(tess_coord.y + 2 * tess_coord.z); + output.position = patch[index].position; + } +#endif + static const DWORD hs_code[] = + { + 0x43425844, 0x4204890e, 0x43f4f8e0, 0xbff7edfd, 0x0a48b715, 0x00000001, 0x0000028c, 0x00000004, + 0x00000030, 0x00000040, 0x00000074, 0x00000108, 0x4e475349, 0x00000008, 0x00000000, 0x00000008, + 0x4e47534f, 0x0000002c, 0x00000001, 0x00000008, 0x00000020, 0x00000000, 0x00000001, 0x00000003, + 0x00000000, 0x0000000f, 0x505f5653, 0x7469736f, 0x006e6f69, 0x47534350, 0x0000008c, 0x00000004, + 0x00000008, 0x00000068, 0x00000000, 0x0000000d, 0x00000003, 0x00000000, 0x00000e01, 0x00000068, + 0x00000001, 0x0000000d, 0x00000003, 0x00000001, 0x00000e01, 0x00000068, 0x00000002, 0x0000000d, + 0x00000003, 0x00000002, 0x00000e01, 0x00000076, 0x00000000, 0x0000000e, 0x00000003, 0x00000003, + 0x00000e01, 0x545f5653, 0x46737365, 0x6f746361, 0x56530072, 0x736e495f, 0x54656469, 0x46737365, + 0x6f746361, 0xabab0072, 0x58454853, 0x0000017c, 0x00030050, 0x0000005f, 0x01000071, 0x01000893, + 0x01001894, 0x01001095, 0x01000896, 0x01001897, 0x0100086a, 0x01000072, 0x0200005f, 0x00016000, + 0x03000065, 0x001020f2, 0x00000000, 0x02000068, 0x00000001, 0x06000020, 0x00100012, 0x00000000, + 0x00016001, 0x00004001, 0x00000001, 0x0f000037, 0x001000f2, 0x00000000, 0x00100006, 0x00000000, + 0x00004002, 0x40400000, 0x3f800000, 0x00000000, 0x3f800000, 0x00004002, 0xbf800000, 0xc0400000, + 0x00000000, 0x3f800000, 0x0b000037, 0x001020f2, 0x00000000, 0x00016001, 0x00100e46, 0x00000000, + 0x00004002, 0xbf800000, 0x3f800000, 0x00000000, 0x3f800000, 0x0100003e, 0x01000073, 0x02000099, + 0x00000003, 0x0200005f, 0x00017000, 0x04000067, 0x00102012, 0x00000000, 0x00000011, 0x04000067, + 0x00102012, 0x00000001, 0x00000012, 0x04000067, 0x00102012, 0x00000002, 0x00000013, 0x02000068, + 0x00000001, 0x0400005b, 0x00102012, 0x00000000, 0x00000003, 0x04000036, 0x00100012, 0x00000000, + 0x0001700a, 0x06000036, 0x00902012, 0x0010000a, 0x00000000, 0x00004001, 0x3f800000, 0x0100003e, + 0x01000073, 0x04000067, 0x00102012, 0x00000003, 0x00000014, 0x05000036, 0x00102012, 0x00000003, + 0x00004001, 0x3f800000, 0x0100003e, + }; + static const D3D12_SHADER_BYTECODE hs = {hs_code, sizeof(hs_code)}; + static const DWORD ds_code[] = + { + 0x43425844, 0x33c6120a, 0x2d46da82, 0x2c17dddf, 0x252ae7e0, 0x00000001, 0x000001c8, 0x00000004, + 0x00000030, 0x00000064, 0x000000f8, 0x0000012c, 0x4e475349, 0x0000002c, 0x00000001, 0x00000008, + 0x00000020, 0x00000000, 0x00000001, 0x00000003, 0x00000000, 0x00000f0f, 0x505f5653, 0x7469736f, + 0x006e6f69, 0x47534350, 0x0000008c, 0x00000004, 0x00000008, 0x00000068, 0x00000000, 0x0000000d, + 0x00000003, 0x00000000, 0x00000001, 0x00000068, 0x00000001, 0x0000000d, 0x00000003, 0x00000001, + 0x00000001, 0x00000068, 0x00000002, 0x0000000d, 0x00000003, 0x00000002, 0x00000001, 0x00000076, + 0x00000000, 0x0000000e, 0x00000003, 0x00000003, 0x00000001, 0x545f5653, 0x46737365, 0x6f746361, + 0x56530072, 0x736e495f, 0x54656469, 0x46737365, 0x6f746361, 0xabab0072, 0x4e47534f, 0x0000002c, + 0x00000001, 0x00000008, 0x00000020, 0x00000000, 0x00000001, 0x00000003, 0x00000000, 0x0000000f, + 0x505f5653, 0x7469736f, 0x006e6f69, 0x58454853, 0x00000094, 0x00040050, 0x00000025, 0x01001893, + 0x01001095, 0x0100086a, 0x0200005f, 0x0001c062, 0x0400005f, 0x002190f2, 0x00000003, 0x00000000, + 0x04000067, 0x001020f2, 0x00000000, 0x00000001, 0x02000068, 0x00000001, 0x07000032, 0x00100012, + 0x00000000, 0x0001c02a, 0x00004001, 0x40000000, 0x0001c01a, 0x0500001c, 0x00100012, 0x00000000, + 0x0010000a, 0x00000000, 0x07000036, 0x001020f2, 0x00000000, 0x00a19e46, 0x0010000a, 0x00000000, + 0x00000000, 0x0100003e, + }; + static const D3D12_SHADER_BYTECODE ds = {ds_code, sizeof(ds_code)}; + + memset(&desc, 0, sizeof(desc)); + desc.no_pipeline = true; + if (!init_test_context(&context, &desc)) + return; + command_list = context.list; + queue = context.queue; + + init_pipeline_state_desc(&pso_desc, context.root_signature, + context.render_target_desc.Format, NULL, NULL, NULL); + pso_desc.VS = vs; + pso_desc.HS = hs; + pso_desc.DS = ds; + pso_desc.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_PATCH; + hr = ID3D12Device_CreateGraphicsPipelineState(context.device, &pso_desc, + &IID_ID3D12PipelineState, (void **)&context.pipeline_state); + ok(hr == S_OK, "Failed to create state, hr %#x.\n", hr); + + ID3D12GraphicsCommandList_ClearRenderTargetView(command_list, context.rtv, white, 0, NULL); + + ID3D12GraphicsCommandList_OMSetRenderTargets(command_list, 1, &context.rtv, FALSE, NULL); + ID3D12GraphicsCommandList_SetGraphicsRootSignature(command_list, context.root_signature); + ID3D12GraphicsCommandList_SetPipelineState(command_list, context.pipeline_state); + ID3D12GraphicsCommandList_IASetPrimitiveTopology(command_list, D3D_PRIMITIVE_TOPOLOGY_3_CONTROL_POINT_PATCHLIST); + ID3D12GraphicsCommandList_RSSetViewports(command_list, 1, &context.viewport); + ID3D12GraphicsCommandList_RSSetScissorRects(command_list, 1, &context.scissor_rect); + ID3D12GraphicsCommandList_DrawInstanced(command_list, 3, 1, 0, 0); + + transition_resource_state(command_list, context.render_target, + D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_COPY_SOURCE); + + check_sub_resource_uint(context.render_target, 0, queue, command_list, 0xff00ff00, 0); + + destroy_test_context(&context); +} + static void test_render_a8(void) { static const float black[] = {0.0f, 0.0f, 0.0f, 0.0f}; @@ -25257,6 +25407,7 @@ START_TEST(d3d12) run_test(test_nop_tessellation_shaders); run_test(test_quad_tessellation); run_test(test_tessellation_dcl_index_range); + run_test(test_hull_shader_control_point_phase); run_test(test_render_a8); run_test(test_cpu_descriptors_lifetime); run_test(test_clip_distance); -- 2.19.2

2 1

[PATCH vkd3d 5/8] vkd3d-shader: Index control point phase outputs by InvocationId.
by Józef Kucia 26 Feb '19

26 Feb '19

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- libs/vkd3d-shader/spirv.c | 72 +++++++++++++++++++++++++++++++++++---- 1 file changed, 65 insertions(+), 7 deletions(-) diff --git a/libs/vkd3d-shader/spirv.c b/libs/vkd3d-shader/spirv.c index 0e6df4712ecf..34e274fa41ec 100644 --- a/libs/vkd3d-shader/spirv.c +++ b/libs/vkd3d-shader/spirv.c @@ -1754,6 +1754,7 @@ struct vkd3d_symbol_register_data unsigned int write_mask; unsigned int structure_stride; bool is_aggregate; /* An aggregate, i.e. a structure or an array. */ + bool is_dynamically_indexed; /* If member_idx is a variable ID instead of a constant. */ }; struct vkd3d_symbol_resource_data @@ -1832,6 +1833,7 @@ static void vkd3d_symbol_set_register_info(struct vkd3d_symbol *symbol, symbol->info.reg.write_mask = write_mask; symbol->info.reg.structure_stride = 0; symbol->info.reg.is_aggregate = false; + symbol->info.reg.is_dynamically_indexed = false; } static void vkd3d_symbol_make_resource(struct vkd3d_symbol *symbol, @@ -2505,6 +2507,7 @@ struct vkd3d_shader_register_info uint32_t member_idx; unsigned int structure_stride; bool is_aggregate; + bool is_dynamically_indexed; }; static bool vkd3d_dxbc_compiler_get_register_info(const struct vkd3d_dxbc_compiler *compiler, @@ -2525,6 +2528,7 @@ static bool vkd3d_dxbc_compiler_get_register_info(const struct vkd3d_dxbc_compil register_info->write_mask = VKD3DSP_WRITEMASK_ALL; register_info->structure_stride = 0; register_info->is_aggregate = false; + register_info->is_dynamically_indexed = false; return true; } @@ -2544,6 +2548,7 @@ static bool vkd3d_dxbc_compiler_get_register_info(const struct vkd3d_dxbc_compil register_info->write_mask = symbol->info.reg.write_mask; register_info->structure_stride = symbol->info.reg.structure_stride; register_info->is_aggregate = symbol->info.reg.is_aggregate; + register_info->is_dynamically_indexed = symbol->info.reg.is_dynamically_indexed; return true; } @@ -2577,8 +2582,17 @@ static void vkd3d_dxbc_compiler_emit_dereference_register(struct vkd3d_dxbc_comp if (reg->idx[1].rel_addr) FIXME("Relative addressing not implemented.\n"); - reg_idx.offset = register_info->member_idx; - indexes[index_count++] = vkd3d_dxbc_compiler_emit_register_addressing(compiler, &reg_idx); + if (register_info->is_dynamically_indexed) + { + indexes[index_count++] = vkd3d_spirv_build_op_load(builder, + vkd3d_spirv_get_type_id(builder, VKD3D_TYPE_INT, 1), + register_info->member_idx, SpvMemoryAccessMaskNone); + } + else + { + reg_idx.offset = register_info->member_idx; + indexes[index_count++] = vkd3d_dxbc_compiler_emit_register_addressing(compiler, &reg_idx); + } } else { @@ -3889,6 +3903,7 @@ static void vkd3d_dxbc_compiler_emit_output(struct vkd3d_dxbc_compiler *compiler struct rb_entry *entry = NULL; unsigned int signature_idx; bool use_private_variable; + unsigned int array_size; bool is_patch_constant; uint32_t id, var_id; @@ -3897,6 +3912,9 @@ static void vkd3d_dxbc_compiler_emit_output(struct vkd3d_dxbc_compiler *compiler shader_signature = is_patch_constant ? compiler->patch_constant_signature : compiler->output_signature; + array_size = phase && phase->type == VKD3DSIH_HS_CONTROL_POINT_PHASE + ? compiler->output_control_point_count : 0; + if (!(signature_element = vkd3d_find_signature_element_for_reg(shader_signature, &signature_idx, reg->idx[0].offset, dst->write_mask))) { @@ -3931,15 +3949,15 @@ static void vkd3d_dxbc_compiler_emit_output(struct vkd3d_dxbc_compiler *compiler { if (builtin) { - id = vkd3d_dxbc_compiler_emit_builtin_variable(compiler, builtin, storage_class, 0); + id = vkd3d_dxbc_compiler_emit_builtin_variable(compiler, builtin, storage_class, array_size); vkd3d_dxbc_compiler_emit_register_execution_mode(compiler, &dst->reg); if (component_idx) FIXME("Unhandled component index %u.\n", component_idx); } else { - id = vkd3d_dxbc_compiler_emit_variable(compiler, &builder->global_stream, - storage_class, component_type, output_component_count); + id = vkd3d_dxbc_compiler_emit_array_variable(compiler, &builder->global_stream, + storage_class, component_type, output_component_count, array_size); vkd3d_spirv_add_iface_variable(builder, id); if (is_dual_source_blending(compiler) && reg->idx[0].offset < 2) @@ -3987,6 +4005,19 @@ static void vkd3d_dxbc_compiler_emit_output(struct vkd3d_dxbc_compiler *compiler { vkd3d_symbol_set_register_info(&reg_symbol, var_id, storage_class, use_private_variable ? VKD3D_TYPE_FLOAT : component_type, VKD3DSP_WRITEMASK_ALL); + reg_symbol.info.reg.is_aggregate = use_private_variable ? false : array_size; + if (!use_private_variable && phase && phase->type == VKD3DSIH_HS_CONTROL_POINT_PHASE) + { + struct vkd3d_shader_register r; + + memset(&r, 0, sizeof(r)); + r.type = VKD3DSPR_OUTPOINTID; + r.idx[0].offset = ~0u; + r.idx[1].offset = ~0u; + + reg_symbol.info.reg.member_idx = vkd3d_dxbc_compiler_get_register_id(compiler, &r); + reg_symbol.info.reg.is_dynamically_indexed = true; + } vkd3d_dxbc_compiler_put_symbol(compiler, &reg_symbol); vkd3d_dxbc_compiler_emit_register_debug_name(builder, var_id, reg); @@ -4047,7 +4078,8 @@ static void vkd3d_dxbc_compiler_emit_shader_phase_output(struct vkd3d_dxbc_compi static void vkd3d_dxbc_compiler_emit_store_shader_output(struct vkd3d_dxbc_compiler *compiler, const struct vkd3d_shader_signature_element *output, - const struct vkd3d_shader_output_info *output_info, uint32_t val_id, unsigned int write_mask) + const struct vkd3d_shader_output_info *output_info, + uint32_t output_index_id, uint32_t val_id, unsigned int write_mask) { unsigned int dst_write_mask, use_mask, uninit_mask, swizzle, mask; struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; @@ -4084,6 +4116,13 @@ static void vkd3d_dxbc_compiler_emit_store_shader_output(struct vkd3d_dxbc_compi } output_id = output_info->id; + if (output_index_id) + { + type_id = vkd3d_spirv_get_type_id(builder, + output_info->component_type, vkd3d_write_mask_component_count(dst_write_mask)); + ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, SpvStorageClassOutput, type_id); + output_id = vkd3d_spirv_build_op_access_chain1(builder, ptr_type_id, output_id, output_index_id); + } if (!output_info->array_element_mask) { @@ -4117,6 +4156,8 @@ static void vkd3d_dxbc_compiler_emit_shader_epilogue_function(struct vkd3d_dxbc_ const struct vkd3d_shader_signature *signature = compiler->output_signature; uint32_t void_id, type_id, ptr_type_id, function_type_id, function_id; struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; + const struct vkd3d_shader_phase *phase; + uint32_t output_index_id = 0; unsigned int i, count; DWORD variable_idx; @@ -4124,6 +4165,8 @@ static void vkd3d_dxbc_compiler_emit_shader_epilogue_function(struct vkd3d_dxbc_ STATIC_ASSERT(ARRAY_SIZE(compiler->private_output_variable) == ARRAY_SIZE(param_type_id)); STATIC_ASSERT(ARRAY_SIZE(compiler->private_output_variable) == ARRAY_SIZE(compiler->private_output_variable_write_mask)); + phase = vkd3d_dxbc_compiler_get_current_shader_phase(compiler); + function_id = compiler->epilogue_function_id; void_id = vkd3d_spirv_get_op_type_void(builder); @@ -4153,6 +4196,21 @@ static void vkd3d_dxbc_compiler_emit_shader_epilogue_function(struct vkd3d_dxbc_ param_id[i] = vkd3d_spirv_build_op_load(builder, type_id, param_id[i], SpvMemoryAccessMaskNone); } + if (phase && phase->type == VKD3DSIH_HS_CONTROL_POINT_PHASE) + { + struct vkd3d_shader_register r; + uint32_t invocation_id; + + memset(&r, 0, sizeof(r)); + r.type = VKD3DSPR_OUTPOINTID; + r.idx[0].offset = ~0u; + r.idx[1].offset = ~0u; + + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_TYPE_INT, 1); + invocation_id = vkd3d_dxbc_compiler_get_register_id(compiler, &r); + output_index_id = vkd3d_spirv_build_op_load(builder, type_id, invocation_id, SpvMemoryAccessMaskNone); + } + for (i = 0; i < signature->element_count; ++i) { variable_idx = vkd3d_dxbc_compiler_get_output_variable_index(compiler, @@ -4162,7 +4220,7 @@ static void vkd3d_dxbc_compiler_emit_shader_epilogue_function(struct vkd3d_dxbc_ continue; vkd3d_dxbc_compiler_emit_store_shader_output(compiler, - &signature->elements[i], &compiler->output_info[i], + &signature->elements[i], &compiler->output_info[i], output_index_id, param_id[variable_idx], compiler->private_output_variable_write_mask[variable_idx]); } -- 2.19.2

2 1