- Wine-Commits - list.winehq.org

Nikolay Sivov : d2d1: Fix GetPropertyNameLength() return value.
by Alexandre Julliard April 11, 2024

April 11, 2024

Module: wine Branch: master Commit: 89111704a53dd8ef9ab70cee1225bc0792747ef4 URL: https://gitlab.winehq.org/wine/wine/-/commit/89111704a53dd8ef9ab70cee1225bc… Author: Nikolay Sivov <nsivov(a)codeweavers.com> Date: Thu Apr 11 00:13:04 2024 +0200 d2d1: Fix GetPropertyNameLength() return value. Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/d2d1/effect.c | 2 +- dlls/d2d1/tests/d2d1.c | 14 ++++++++++++-- 2 files changed, 13 insertions(+), 3 deletions(-) diff --git a/dlls/d2d1/effect.c b/dlls/d2d1/effect.c index b6ef46652af..aadf308c60f 100644 --- a/dlls/d2d1/effect.c +++ b/dlls/d2d1/effect.c @@ -2130,7 +2130,7 @@ static UINT32 STDMETHODCALLTYPE d2d_effect_properties_GetPropertyNameLength(ID2D if (!(prop = d2d_effect_properties_get_property_by_index(properties, index))) return D2DERR_INVALID_PROPERTY; - return wcslen(prop->name) + 1; + return wcslen(prop->name); } static D2D1_PROPERTY_TYPE STDMETHODCALLTYPE d2d_effect_properties_GetType(ID2D1Properties *iface, diff --git a/dlls/d2d1/tests/d2d1.c b/dlls/d2d1/tests/d2d1.c index 7bf1f8390e3..0337038aa8b 100644 --- a/dlls/d2d1/tests/d2d1.c +++ b/dlls/d2d1/tests/d2d1.c @@ -10862,6 +10862,7 @@ static void check_system_properties_(unsigned int line, ID2D1Effect *effect) UINT i, value_size, str_size; WCHAR name[32], buffer[256]; D2D1_PROPERTY_TYPE type; + UINT32 count; HRESULT hr; static const struct system_property_test @@ -10898,7 +10899,7 @@ static void check_system_properties_(unsigned int line, ID2D1Effect *effect) winetest_push_context("Property %u", i); name[0] = 0; - hr = ID2D1Effect_GetPropertyName(effect, test->index, name, sizeof(name)); + hr = ID2D1Effect_GetPropertyName(effect, test->index, name, ARRAY_SIZE(name)); ok_(__FILE__, line)(hr == S_OK, "Failed to get property name, hr %#lx\n", hr); if (hr == D2DERR_INVALID_PROPERTY) { @@ -10907,6 +10908,16 @@ static void check_system_properties_(unsigned int line, ID2D1Effect *effect) } ok_(__FILE__, line)(!wcscmp(name, test->name), "Got unexpected property name %s, expected %s.\n", debugstr_w(name), debugstr_w(test->name)); + count = ID2D1Effect_GetPropertyNameLength(effect, test->index); + ok_(__FILE__, line)(wcslen(name) == count, "Got unexpected property name length %u.\n", count); + + name[0] = 0; + hr = ID2D1Effect_GetPropertyName(effect, test->index, name, count); + ok_(__FILE__, line)(hr == D2DERR_INSUFFICIENT_BUFFER, "Failed to get property name, hr %#lx\n", hr); + + name[0] = 0; + hr = ID2D1Effect_GetPropertyName(effect, test->index, name, count + 1); + ok_(__FILE__, line)(hr == S_OK, "Failed to get property name, hr %#lx\n", hr); type = ID2D1Effect_GetType(effect, test->index); ok_(__FILE__, line)(type == test->type, "Got unexpected property type %#x, expected %#x.\n", @@ -14750,7 +14761,6 @@ static void test_get_effect_properties(BOOL d3d11) ok(!wcscmp(buffW, L"Rect"), "Unexpected name %s.\n", debugstr_w(buffW)); count = ID2D1Properties_GetPropertyNameLength(properties, 0); - todo_wine ok(count == 4, "Unexpected name length %u.\n", count); type = ID2D1Properties_GetType(properties, 0);

1 0

Francisco Casas : tests: Add tests for "compile" and CompileShader() syntax.
by Alexandre Julliard April 11, 2024

April 11, 2024

Module: vkd3d Branch: master Commit: 73ef6907bcb422a718b39e08631f8844d84e879b URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/73ef6907bcb422a718b39e08631f8… Author: Francisco Casas <fcasas(a)codeweavers.com> Date: Tue Mar 26 01:16:57 2024 -0300 tests: Add tests for "compile" and CompileShader() syntax. --- Makefile.am | 1 + tests/hlsl/effect-compile.shader_test | 141 ++++++++++++++++++++++++++++++++++ 2 files changed, 142 insertions(+) diff --git a/Makefile.am b/Makefile.am index 02ff69bb..ead3c1f5 100644 --- a/Makefile.am +++ b/Makefile.am @@ -91,6 +91,7 @@ vkd3d_shader_tests = \ tests/hlsl/distance.shader_test \ tests/hlsl/dot.shader_test \ tests/hlsl/duplicate-modifiers.shader_test \ + tests/hlsl/effect-compile.shader_test \ tests/hlsl/effect-shader-objects-fx_2.shader_test \ tests/hlsl/effect-shader-objects-fx_5.shader_test \ tests/hlsl/effect-technique-fx_2.shader_test \ diff --git a/tests/hlsl/effect-compile.shader_test b/tests/hlsl/effect-compile.shader_test new file mode 100644 index 00000000..dc5c3e1c --- /dev/null +++ b/tests/hlsl/effect-compile.shader_test @@ -0,0 +1,141 @@ +% Test special "compile" keyword syntax to compile pixel and vertex shaders +[pixel shader todo] +float4 fun() : sv_target +{ + return 0; +} + +sampler sam +{ + cat = compile ps_2_0 fun(); +}; + +float4 main() : sv_target { return 0; } + + +[pixel shader todo] +float4 fun() : sv_target +{ + return 0; +} + +technique +{ + pass + { + cat = compile ps_2_0 fun(); + } +} + +float4 main() : sv_target { return 0; } + + +% Only uniform arguments are expected, even if undefined identifiers are used. +[pixel shader todo] +float4 fun(uniform float4 a, float4 b, uniform float4 c) : sv_target +{ + return a + b + c; +} + +technique +{ + pass + { + cat = compile ps_2_0 fun(foobar, foobar); // Notice 2 arguments, not 3 + } +} + +float4 main() : sv_target { return 0; } + + +[pixel shader fail(sm<6)] +float4 fun(uniform float4 a, float4 b, uniform float4 c) : sv_target +{ + return a + b + c; +} + +technique +{ + pass + { + // passing 3 arguments here is not valid because the function has only 2 uniforms. + cat = compile ps_2_0 fun(1, 2, 3); + } +} + +float4 main() : sv_target { return 0; } + + +% Test the CompileShader() syntax. +[pixel shader todo fail(sm>=6)] +float arg1, arg2; + +float4 main_vertex(uniform float a) : sv_position { return a; } + +float4 main(uniform float a) : sv_target { return a; } + // ^ dxc expects a semantic here. + +PixelShader ps1 = CompileShader(ps_2_0, main(arg2)); +VertexShader vs1 = CompileShader(vs_2_0, main_vertex(arg1)); + +technique10 tech1 +{ + pass pass1 + { + SetVertexShader(vs1); + SetPixelShader(ps1); + } +} + + +% Undefined identifiers are not allowed if CompileShader() is used outside a state block. +[pixel shader fail] +float4 main(uniform float a) : sv_target { return a; } + +PixelShader ps1 = CompileShader(ps_2_0, main(foobar)); + + +% But undefined identifiers are allowed if inside a state block. +[pixel shader todo fail(sm>=6)] +float4 main_vertex(uniform float a) : sv_position { return a; } + +float4 main(uniform float a) : sv_target { return a; } + // ^ dxc expects a semantic here. + +technique tech1 +{ + pass pass1 + { + SetVertexShader(CompileShader(vs_2_0, main_vertex(foo))); + SetPixelShader(CompileShader(ps_2_0, main(bar))); + } +} + + +% Again only uniform parameters are expected +[pixel shader fail] +float aa, bb; + +float4 main(uniform float a, float b) : sv_target { return a; } + +PixelShader ps1 = CompileShader(ps_2_0, main(aa, bb)); + + +% Only a set of target profiles are allowed +[pixel shader fail(sm<6)] +float4 main() : sv_target { return 0; } + +PixelShader ps1 = CompileShader(ps_6_0, main()); + +[pixel shader fail(sm<6)] +float4 main() : sv_target { return 0; } + +PixelShader ps1 = CompileShader(fs_2_0, main()); + + +% Shaders cannot be passed around to another variable: "Initializer must be literal expressions.". +[pixel shader fail(sm<6)] +float4 main() : sv_target { return 0; } + +PixelShader ps1 = CompileShader(ps_2_0, main()); +PixelShader ps2 = ps1;

1 0

Francisco Casas : tests: Add tests for fxgroup syntax.
by Alexandre Julliard April 11, 2024

April 11, 2024

Module: vkd3d Branch: master Commit: 83f4b46fb1ba4cee127bda1a27b87462092114a8 URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/83f4b46fb1ba4cee127bda1a27b87… Author: Francisco Casas <fcasas(a)codeweavers.com> Date: Tue Mar 26 01:15:42 2024 -0300 tests: Add tests for fxgroup syntax. --- Makefile.am | 1 + tests/hlsl/fxgroup-syntax.shader_test | 39 +++++++++++++++++++++++++++++++++++ 2 files changed, 40 insertions(+) diff --git a/Makefile.am b/Makefile.am index 1ab94e51..02ff69bb 100644 --- a/Makefile.am +++ b/Makefile.am @@ -110,6 +110,7 @@ vkd3d_shader_tests = \ tests/hlsl/function-return.shader_test \ tests/hlsl/function.shader_test \ tests/hlsl/fwidth.shader_test \ + tests/hlsl/fxgroup-syntax.shader_test \ tests/hlsl/gather-offset.shader_test \ tests/hlsl/gather.shader_test \ tests/hlsl/getdimensions.shader_test \ diff --git a/tests/hlsl/fxgroup-syntax.shader_test b/tests/hlsl/fxgroup-syntax.shader_test new file mode 100644 index 00000000..e8e5fbf5 --- /dev/null +++ b/tests/hlsl/fxgroup-syntax.shader_test @@ -0,0 +1,39 @@ +% Test complex effect groups syntax +[pixel shader fail(sm>=6) todo] +fxgroup group1 +{ + technique10 + { + pass + { + TurboEncabulator = prefabulated + aluminite; + malleable = logarithmic - casing; + } + pass pass1 + { + spurving_bearings = pentametric_fan; + hydrocoptic = marzlevanes; + } + } + technique11 tech1 + { + pass + { + Lunar = Waneshaft; + } + } +} + +float4 main() : sv_target { return 0; } + + +% Effect groups cannot have a "technique" without version +[pixel shader fail] +fxgroup group1 +{ + technique + { + } +} + +float4 main() : sv_target { return 0; }

1 0

Francisco Casas : tests: Add more state block syntax tests.
by Alexandre Julliard April 11, 2024

April 11, 2024

Module: vkd3d Branch: master Commit: 9ede222714828739b9a3fab0d5ccf37665ab0c04 URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/9ede222714828739b9a3fab0d5ccf… Author: Francisco Casas <fcasas(a)codeweavers.com> Date: Tue Mar 26 01:12:13 2024 -0300 tests: Add more state block syntax tests. --- tests/hlsl/state-block-syntax.shader_test | 451 ++++++++++++++++++++++++++++++ 1 file changed, 451 insertions(+) diff --git a/tests/hlsl/state-block-syntax.shader_test b/tests/hlsl/state-block-syntax.shader_test index 1534fffd..b1071c90 100644 --- a/tests/hlsl/state-block-syntax.shader_test +++ b/tests/hlsl/state-block-syntax.shader_test @@ -171,3 +171,454 @@ float4 main() : sv_target [test] todo(glsl) draw quad probe all rgba (0, 1, 0, 1) + + +% Arbitrary names are allowed in the lhs of state block entries. +[pixel shader] +sampler sam +{ + Foobar = 3; +}; + +float4 main() : sv_target { return 0; } + + +% Undefined identifiers are allowed in state blocks. +[pixel shader] +sampler sam +{ + Filter = arbitrary_identifier; +}; + +float4 main() : sv_target { return 0; } + + +% State blocks can be empty +[pixel shader todo] +sampler sams[2] +{ + { + }, + { + } +}; + +float4 main() : sv_target { return 0; } + + +% Multiple state blocks for array variables, as a list, are a thing. +[pixel shader todo] +sampler sams[2] +{ + { + Filter = ANISOTROPIC; + }, + { + Filter = ANISOTROPIC; + } +}; + +float4 main() : sv_target { return 0; } + + +% Multiple state blocks for multi-component variables, as a list, are a thing. +[pixel shader todo] +float2 val +{ + { + Filter = ANISOTROPIC; + }, + { + Filter = ANISOTROPIC; + } +}; + +float4 main() : sv_target { return 0; } + + +% The number of state blocks in the state block list must match the number of components. +[pixel shader fail(sm<6)] +sampler sams[2] +{ + { + } +}; + +float4 main() : sv_target { return 0; } + +[pixel shader fail(sm<6)] +sampler sams[2][2] +{ + { + }, + { + } +}; + +float4 main() : sv_target { return 0; } + + +[pixel shader fail(sm<6)] +float2 arr[2] +{ + { + }, + { + } +}; + +float4 main() : sv_target { return 0; } + + +[pixel shader todo] +float3 arr[2] +{ + { + }, + { + }, + { + }, + { + }, + { + }, + { + } +}; + +float4 main() : sv_target { return 0; } + + +[pixel shader fail(sm<6)] +sampler sams[2] +{ + { + Filter = ANISOTROPIC; + }, + { + Filter = ANISOTROPIC; + }, // trailing comma not allowed. +}; + +float4 main() : sv_target { return 0; } + + +% Multiple state blocks for multi-dimensional array variables are a thing. +[pixel shader todo] +sampler sams[2][2] +{ + { + Filter = ANISOTROPIC; + }, + { + Filter = ANISOTROPIC; + }, + { + Filter = ANISOTROPIC; + }, + { + Filter = ANISOTROPIC; + } +}; + +float4 main() : sv_target { return 0; } + + +% State blocks cannot be nested further than one level, regardless of multi-dimensionality. +[pixel shader fail(sm<6)] +sampler sams[2][2] +{ + { + { + Filter = ANISOTROPIC; + }, + { + Filter = ANISOTROPIC; + } + }, + { + { + Filter = ANISOTROPIC; + }, + { + Filter = ANISOTROPIC; + } + } +}; + +float4 main() : sv_target { return 0; } + + +% Variables of 1 component can still use a single state block without the need to put it inside a list. +[pixel shader] +sampler sams[1] +{ + Filter = ANISOTROPIC; +}; + +float4 main() : sv_target { return 0; } + +[pixel shader todo] +sampler sam +{ + { + Filter = ANISOTROPIC; + } +}; + +float4 main() : sv_target { return 0; } + + +% It is possible to declare an empty state block +[pixel shader] +float f +{ +}; + +float4 main() : sv_target { return 0; } + + +% State block entries may have indexes. +[pixel shader todo] +sampler sam +{ + dogs[3] = 5; +}; + +float4 main() : sv_target { return 0; } + + +% State block entry indexes can only be integers, not even constant expressions are allowed. +[pixel shader fail(sm<6)] +sampler sam +{ + dogs[3 + 4] = 10; +}; + +float4 main() : sv_target { return 0; } + + +% State block entry indexes can not be negative integers. +[pixel shader fail(sm<6)] +sampler sam +{ + dogs[-2] = 10; +}; + +float4 main() : sv_target { return 0; } + +[pixel shader fail(sm<6)] +static const int a = 5; + +sampler sam +{ + dogs[a] = 5; +}; + +float4 main() : sv_target { return 0; } + + +% State blocks may have bracket initializers on the rhs. +[pixel shader todo] +sampler sam +{ + MaxAnisotropy = 3; + cat = {1, 2, {3, "string"}}; + dogs[3] = {1, {2, {4}}, 3, any_identifier}; +}; + +float4 main() : sv_target { return 0; } + + +% Even though using undefined identifiers is allowed, calls to undefined functions are not. +[pixel shader fail(sm<6)] +sampler sam +{ + cat = fun(); +}; + +float4 main() : sv_target { return 0; } + + +% PixelShader and VertexShader are valid identifiers for the lhs +[pixel shader todo] +sampler sam +{ + pixelShader = 20; + PixelShader = 25; + VertexShader = 30; + vertexshader = 35; +}; + +float4 main() : sv_target { return 0; } + + +% State blocks are valid for numeric types. +[pixel shader] +float f +{ + MaxAnisotropy = 3; +}; + +float4 main() : sv_target { return 0; } + + +% State blocks are valid for texture types. +[pixel shader] +Texture2D tex +{ + MaxAnisotropy = 3; +}; + +float4 main() : sv_target { return 0; } + + +% Same rules apply for technique passes +[pixel shader todo] +technique +{ + pass + { + cat = {1, 2, {3, "string"}}; + dogs[3] = {1, {2, {4}}, 3, any_identifier}; + } +} + +float4 main() : sv_target { return 0; } + + +% Multi-dimensional arrays on the lhs on state blocks are syntax errors. +[pixel shader fail(sm<6)] +sampler sam +{ + dogs[1][1] = 1; +}; + +float4 main() : sv_target { return 0; } + +[pixel shader fail(sm<6)] +technique +{ + pass + { + dogs[1][1] = 1; + } +} + +float4 main() : sv_target { return 0; } + + +% Test complex expression on the rhs, including function calls. +[pixel shader] +float4 addition(float4 a, float4 b) +{ + return a + b; +} + +sampler sam +{ + cat = addition(foo, bar) + p * q; +}; + +float4 main() : sv_target { return 0; } + + +% State blocks are valid for DepthStencilState +[pixel shader todo] +DepthStencilState dss1 +{ + DepthEnable = false; + DepthWriteMask = Zero; + DepthFunc = Less; + random_field = 12; +}; + +float4 main() : sv_target { return 0; } + + +% State blocks are valid for BlendState. +[pixel shader todo] +BlendState bs1 +{ + random_field = 1; +}; + +float4 main() : sv_target { return 0; } + + +% State blocks are valid for VertexShader and PixelShader +[pixel shader] +PixelShader ps1 +{ + random_field = 1; +}; + +VertexShader vs1 +{ + random_field = 1; +}; + +float4 main() : sv_target { return 0; } + + +% State blocks are valid for RasterizerState +[pixel shader todo] +RasterizerState rs +{ + random_field = 1; +}; + +float4 main() : sv_target { return 0; } + + +% Undefined identifiers cannot be indexed. +[pixel shader fail(sm<6)] +float4 main() : sv_target { return 0; } + +DepthStencilState dss1 +{ + RandomField = foobar[2]; +}; + + +% Undefined identifiers can be swizzled with .x which proves that they are considered scalar +[pixel shader todo] +float4 main() : sv_target { return 0; } + +DepthStencilState dss1 +{ + RandomField = foobar.x; +}; + +[pixel shader fail(sm<6)] +float4 main() : sv_target { return 0; } + +DepthStencilState dss1 +{ + RandomField = foobar.y; +}; + + +% The type of previously defined variables is respected, but array indexes are not checked. +[pixel shader todo] +float4 arr[3]; + +float4 main() : sv_target { return 0; } + +DepthStencilState dss1 +{ + RandomField = arr[90]; +}; + + +% The type of previously defined variables is respected, and swizzles are checked. +[pixel shader fail(sm<6)] +float3 vec; + +float4 main() : sv_target { return 0; } + +DepthStencilState dss1 +{ + RandomField = vec.w; +};

1 0

Francisco Casas : vkd3d-shader/hlsl: Parse list of state blocks.
by Alexandre Julliard April 11, 2024

April 11, 2024

Module: vkd3d Branch: master Commit: a99bcb1196355da500bfa6beaaad6b8a8706e718 URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/a99bcb1196355da500bfa6beaaad6… Author: Francisco Casas <fcasas(a)codeweavers.com> Date: Mon Mar 18 21:57:36 2024 -0300 vkd3d-shader/hlsl: Parse list of state blocks. --- libs/vkd3d-shader/hlsl.c | 23 +++++------ libs/vkd3d-shader/hlsl.h | 7 +++- libs/vkd3d-shader/hlsl.y | 66 ++++++++++++++++++++++++++++--- tests/hlsl/state-block-syntax.shader_test | 12 +++--- 4 files changed, 83 insertions(+), 25 deletions(-) diff --git a/libs/vkd3d-shader/hlsl.c b/libs/vkd3d-shader/hlsl.c index 1ecb14d2..ed80e2b7 100644 --- a/libs/vkd3d-shader/hlsl.c +++ b/libs/vkd3d-shader/hlsl.c @@ -156,17 +156,17 @@ void hlsl_free_state_block(struct hlsl_state_block *state_block) void hlsl_free_var(struct hlsl_ir_var *decl) { - unsigned int k; + unsigned int k, i; vkd3d_free((void *)decl->name); hlsl_cleanup_semantic(&decl->semantic); for (k = 0; k <= HLSL_REGSET_LAST_OBJECT; ++k) vkd3d_free((void *)decl->objects_usage[k]); - if (decl->state_block) - { - hlsl_free_state_block(decl->state_block); - decl->state_block = NULL; - } + + for (i = 0; i < decl->state_block_count; ++i) + hlsl_free_state_block(decl->state_blocks[i]); + vkd3d_free(decl->state_blocks); + vkd3d_free(decl); } @@ -3740,11 +3740,12 @@ static void hlsl_ctx_cleanup(struct hlsl_ctx *ctx) { LIST_FOR_EACH_ENTRY_SAFE(var, next_var, &scope->vars, struct hlsl_ir_var, scope_entry) { - if (var->state_block) - { - hlsl_free_state_block(var->state_block); - var->state_block = NULL; - } + for (i = 0; i < var->state_block_count; ++i) + hlsl_free_state_block(var->state_blocks[i]); + vkd3d_free(var->state_blocks); + var->state_blocks = NULL; + var->state_block_count = 0; + var->state_block_capacity = 0; } } diff --git a/libs/vkd3d-shader/hlsl.h b/libs/vkd3d-shader/hlsl.h index b6309ac4..4fa7fe1c 100644 --- a/libs/vkd3d-shader/hlsl.h +++ b/libs/vkd3d-shader/hlsl.h @@ -424,9 +424,12 @@ struct hlsl_ir_var /* Scope that contains annotations for this variable. */ struct hlsl_scope *annotations; - /* The state block on the variable's declaration, if any. + /* A dynamic array containing the state block on the variable's declaration, if any. + * An array variable may contain multiple state blocks. * These are only really used for effect profiles. */ - struct hlsl_state_block *state_block; + struct hlsl_state_block **state_blocks; + unsigned int state_block_count; + size_t state_block_capacity; /* Indexes of the IR instructions where the variable is first written and last read (liveness * range). The IR instructions are numerated starting from 2, because 0 means unused, and 1 diff --git a/libs/vkd3d-shader/hlsl.y b/libs/vkd3d-shader/hlsl.y index 5acbc3a3..c52bd49e 100644 --- a/libs/vkd3d-shader/hlsl.y +++ b/libs/vkd3d-shader/hlsl.y @@ -78,7 +78,9 @@ struct parse_variable_def uint32_t modifiers; struct vkd3d_shader_location modifiers_loc; - struct hlsl_state_block *state_block; + struct hlsl_state_block **state_blocks; + unsigned int state_block_count; + size_t state_block_capacity; }; struct parse_function @@ -939,8 +941,7 @@ static void free_parse_variable_def(struct parse_variable_def *v) vkd3d_free(v->arrays.sizes); vkd3d_free(v->name); hlsl_cleanup_semantic(&v->semantic); - if (v->state_block) - hlsl_free_state_block(v->state_block); + assert(!v->state_blocks); vkd3d_free(v); } @@ -2359,10 +2360,24 @@ static struct hlsl_block *initialize_vars(struct hlsl_ctx *ctx, struct list *var continue; } - var->state_block = v->state_block; - v->state_block = NULL; type = var->data_type; + var->state_blocks = v->state_blocks; + var->state_block_count = v->state_block_count; + var->state_block_capacity = v->state_block_capacity; + v->state_block_count = 0; + v->state_block_capacity = 0; + v->state_blocks = NULL; + + if (var->state_blocks && hlsl_type_component_count(type) != var->state_block_count) + { + hlsl_error(ctx, &v->loc, VKD3D_SHADER_ERROR_HLSL_WRONG_PARAMETER_COUNT, + "Expected %u state blocks, but got %u.", + hlsl_type_component_count(type), var->state_block_count); + free_parse_variable_def(v); + continue; + } + if (v->initializer.args_count) { if (v->initializer.braces) @@ -5546,6 +5561,7 @@ static bool state_block_add_entry(struct hlsl_state_block *state_block, struct h %type <type> type_no_void %type <type> typedef_type +%type <variable_def> state_block_list %type <variable_def> type_spec %type <variable_def> variable_decl %type <variable_def> variable_def @@ -6729,6 +6745,27 @@ state_block: state_block_add_entry($$, entry); } +state_block_list: + '{' state_block '}' + { + if (!($$ = hlsl_alloc(ctx, sizeof(*$$)))) + YYABORT; + + if(!(vkd3d_array_reserve((void **)&$$->state_blocks, &$$->state_block_capacity, + $$->state_block_count + 1, sizeof(*$$->state_blocks)))) + YYABORT; + $$->state_blocks[$$->state_block_count++] = $2; + } + | state_block_list ',' '{' state_block '}' + { + $$ = $1; + + if(!(vkd3d_array_reserve((void **)&$$->state_blocks, &$$->state_block_capacity, + $$->state_block_count + 1, sizeof(*$$->state_blocks)))) + YYABORT; + $$->state_blocks[$$->state_block_count++] = $4; + } + variable_def: variable_decl | variable_decl '=' complex_initializer @@ -6739,8 +6776,25 @@ variable_def: | variable_decl '{' state_block_start state_block '}' { $$ = $1; - $$->state_block = $4; ctx->in_state_block = 0; + + if(!(vkd3d_array_reserve((void **)&$$->state_blocks, &$$->state_block_capacity, + $$->state_block_count + 1, sizeof(*$$->state_blocks)))) + YYABORT; + $$->state_blocks[$$->state_block_count++] = $4; + } + | variable_decl '{' state_block_start state_block_list '}' + { + $$ = $1; + ctx->in_state_block = 0; + + $$->state_blocks = $4->state_blocks; + $$->state_block_count = $4->state_block_count; + $$->state_block_capacity = $4->state_block_capacity; + $4->state_blocks = NULL; + $4->state_block_count = 0; + $4->state_block_capacity = 0; + free_parse_variable_def($4); } variable_def_typed: diff --git a/tests/hlsl/state-block-syntax.shader_test b/tests/hlsl/state-block-syntax.shader_test index 7521516b..5c2d6f9b 100644 --- a/tests/hlsl/state-block-syntax.shader_test +++ b/tests/hlsl/state-block-syntax.shader_test @@ -194,7 +194,7 @@ float4 main() : sv_target { return 0; } % State blocks can be empty -[pixel shader todo] +[pixel shader] sampler sams[2] { { @@ -207,7 +207,7 @@ float4 main() : sv_target { return 0; } % Multiple state blocks for array variables, as a list, are a thing. -[pixel shader todo] +[pixel shader] sampler sams[2] { { @@ -222,7 +222,7 @@ float4 main() : sv_target { return 0; } % Multiple state blocks for multi-component variables, as a list, are a thing. -[pixel shader todo] +[pixel shader] float2 val { { @@ -270,7 +270,7 @@ float2 arr[2] float4 main() : sv_target { return 0; } -[pixel shader todo] +[pixel shader] float3 arr[2] { { @@ -305,7 +305,7 @@ float4 main() : sv_target { return 0; } % Multiple state blocks for multi-dimensional array variables are a thing. -[pixel shader todo] +[pixel shader] sampler sams[2][2] { { @@ -359,7 +359,7 @@ sampler sams[1] float4 main() : sv_target { return 0; } -[pixel shader todo] +[pixel shader] sampler sam { {

1 0

Francisco Casas : vkd3d-shader/hlsl: Introduce hlsl_ir_stateblock_constant.
by Alexandre Julliard April 11, 2024

April 11, 2024

Module: vkd3d Branch: master Commit: 80320f61293d51ff0202b693612a0d119e8af2d2 URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/80320f61293d51ff0202b693612a0… Author: Francisco Casas <fcasas(a)codeweavers.com> Date: Mon Mar 18 15:31:04 2024 -0300 vkd3d-shader/hlsl: Introduce hlsl_ir_stateblock_constant. --- libs/vkd3d-shader/hlsl.c | 50 ++++++++++++++++++++++++++++++++++++++++ libs/vkd3d-shader/hlsl.h | 17 ++++++++++++++ libs/vkd3d-shader/hlsl.y | 13 +++++------ libs/vkd3d-shader/hlsl_codegen.c | 6 +++++ 4 files changed, 79 insertions(+), 7 deletions(-) diff --git a/libs/vkd3d-shader/hlsl.c b/libs/vkd3d-shader/hlsl.c index 3b93c690..1ecb14d2 100644 --- a/libs/vkd3d-shader/hlsl.c +++ b/libs/vkd3d-shader/hlsl.c @@ -1586,6 +1586,27 @@ struct hlsl_ir_node *hlsl_new_swizzle(struct hlsl_ctx *ctx, uint32_t s, unsigned return &swizzle->node; } +struct hlsl_ir_node *hlsl_new_stateblock_constant(struct hlsl_ctx *ctx, const char *name, + struct vkd3d_shader_location *loc) +{ + struct hlsl_ir_stateblock_constant *constant; + struct hlsl_type *type = hlsl_get_scalar_type(ctx, HLSL_TYPE_INT); + + if (!(constant = hlsl_alloc(ctx, sizeof(*constant)))) + return NULL; + + init_node(&constant->node, HLSL_IR_STATEBLOCK_CONSTANT, type, loc); + + if (!(constant->name = hlsl_alloc(ctx, strlen(name) + 1))) + { + vkd3d_free(constant); + return NULL; + } + strcpy(constant->name, name); + + return &constant->node; +} + bool hlsl_index_is_noncontiguous(struct hlsl_ir_index *index) { struct hlsl_type *type = index->val.node->data_type; @@ -1909,6 +1930,12 @@ static struct hlsl_ir_node *clone_index(struct hlsl_ctx *ctx, struct clone_instr return dst; } +static struct hlsl_ir_node *clone_stateblock_constant(struct hlsl_ctx *ctx, + struct clone_instr_map *map, struct hlsl_ir_stateblock_constant *constant) +{ + return hlsl_new_stateblock_constant(ctx, constant->name, &constant->node.loc); +} + void hlsl_free_ir_switch_case(struct hlsl_ir_switch_case *c) { hlsl_block_cleanup(&c->body); @@ -2004,6 +2031,9 @@ static struct hlsl_ir_node *clone_instr(struct hlsl_ctx *ctx, case HLSL_IR_SWIZZLE: return clone_swizzle(ctx, map, hlsl_ir_swizzle(instr)); + + case HLSL_IR_STATEBLOCK_CONSTANT: + return clone_stateblock_constant(ctx, map, hlsl_ir_stateblock_constant(instr)); } vkd3d_unreachable(); @@ -2835,6 +2865,12 @@ static void dump_ir_index(struct vkd3d_string_buffer *buffer, const struct hlsl_ vkd3d_string_buffer_printf(buffer, "]"); } +static void dump_ir_stateblock_constant(struct vkd3d_string_buffer *buffer, + const struct hlsl_ir_stateblock_constant *constant) +{ + vkd3d_string_buffer_printf(buffer, "%s", constant->name); +} + static void dump_ir_switch(struct hlsl_ctx *ctx, struct vkd3d_string_buffer *buffer, const struct hlsl_ir_switch *s) { struct hlsl_ir_switch_case *c; @@ -2923,6 +2959,10 @@ static void dump_instr(struct hlsl_ctx *ctx, struct vkd3d_string_buffer *buffer, case HLSL_IR_SWIZZLE: dump_ir_swizzle(buffer, hlsl_ir_swizzle(instr)); break; + + case HLSL_IR_STATEBLOCK_CONSTANT: + dump_ir_stateblock_constant(buffer, hlsl_ir_stateblock_constant(instr)); + break; } } @@ -3095,6 +3135,12 @@ static void free_ir_index(struct hlsl_ir_index *index) vkd3d_free(index); } +static void free_ir_stateblock_constant(struct hlsl_ir_stateblock_constant *constant) +{ + vkd3d_free(constant->name); + vkd3d_free(constant); +} + void hlsl_free_instr(struct hlsl_ir_node *node) { assert(list_empty(&node->uses)); @@ -3152,6 +3198,10 @@ void hlsl_free_instr(struct hlsl_ir_node *node) case HLSL_IR_SWITCH: free_ir_switch(hlsl_ir_switch(node)); break; + + case HLSL_IR_STATEBLOCK_CONSTANT: + free_ir_stateblock_constant(hlsl_ir_stateblock_constant(node)); + break; } } diff --git a/libs/vkd3d-shader/hlsl.h b/libs/vkd3d-shader/hlsl.h index b53bcbd7..b6309ac4 100644 --- a/libs/vkd3d-shader/hlsl.h +++ b/libs/vkd3d-shader/hlsl.h @@ -298,6 +298,7 @@ enum hlsl_ir_node_type HLSL_IR_STORE, HLSL_IR_SWIZZLE, HLSL_IR_SWITCH, + HLSL_IR_STATEBLOCK_CONSTANT, }; /* Common data for every type of IR instruction node. */ @@ -785,6 +786,14 @@ struct hlsl_ir_constant struct hlsl_reg reg; }; +/* Stateblock constants are undeclared values found on state blocks or technique passes descriptions, + * that do not concern regular pixel, vertex, or compute shaders, except for parsing. */ +struct hlsl_ir_stateblock_constant +{ + struct hlsl_ir_node node; + char *name; +}; + struct hlsl_scope { /* Item entry for hlsl_ctx.scopes. */ @@ -1060,6 +1069,12 @@ static inline struct hlsl_ir_switch *hlsl_ir_switch(const struct hlsl_ir_node *n return CONTAINING_RECORD(node, struct hlsl_ir_switch, node); } +static inline struct hlsl_ir_stateblock_constant *hlsl_ir_stateblock_constant(const struct hlsl_ir_node *node) +{ + assert(node->type == HLSL_IR_STATEBLOCK_CONSTANT); + return CONTAINING_RECORD(node, struct hlsl_ir_stateblock_constant, node); +} + static inline void hlsl_block_init(struct hlsl_block *block) { list_init(&block->instrs); @@ -1334,6 +1349,8 @@ struct hlsl_type *hlsl_new_struct_type(struct hlsl_ctx *ctx, const char *name, struct hlsl_struct_field *fields, size_t field_count); struct hlsl_ir_node *hlsl_new_swizzle(struct hlsl_ctx *ctx, uint32_t s, unsigned int components, struct hlsl_ir_node *val, const struct vkd3d_shader_location *loc); +struct hlsl_ir_node *hlsl_new_stateblock_constant(struct hlsl_ctx *ctx, const char *name, + struct vkd3d_shader_location *loc); struct hlsl_ir_var *hlsl_new_synthetic_var(struct hlsl_ctx *ctx, const char *template, struct hlsl_type *type, const struct vkd3d_shader_location *loc); struct hlsl_ir_var *hlsl_new_synthetic_var_named(struct hlsl_ctx *ctx, const char *name, diff --git a/libs/vkd3d-shader/hlsl.y b/libs/vkd3d-shader/hlsl.y index 28347b4a..5acbc3a3 100644 --- a/libs/vkd3d-shader/hlsl.y +++ b/libs/vkd3d-shader/hlsl.y @@ -1294,6 +1294,7 @@ static unsigned int evaluate_static_expression_as_uint(struct hlsl_ctx *ctx, str case HLSL_IR_RESOURCE_STORE: case HLSL_IR_STORE: case HLSL_IR_SWITCH: + case HLSL_IR_STATEBLOCK_CONSTANT: hlsl_error(ctx, &node->loc, VKD3D_SHADER_ERROR_HLSL_INVALID_SYNTAX, "Expected literal expression."); } @@ -7365,15 +7366,13 @@ primary_expr: { if (ctx->in_state_block) { - struct hlsl_ir_load *load; - struct hlsl_ir_var *var; + struct hlsl_ir_node *constant; - if (!(var = hlsl_new_synthetic_var(ctx, "state_block_expr", - hlsl_get_scalar_type(ctx, HLSL_TYPE_INT), &@1))) + if (!(constant = hlsl_new_stateblock_constant(ctx, $1, &@1))) YYABORT; - if (!(load = hlsl_new_var_load(ctx, var, &@1))) - YYABORT; - if (!($$ = make_block(ctx, &load->node))) + vkd3d_free($1); + + if (!($$ = make_block(ctx, constant))) YYABORT; } else diff --git a/libs/vkd3d-shader/hlsl_codegen.c b/libs/vkd3d-shader/hlsl_codegen.c index 13c923b4..eaa72836 100644 --- a/libs/vkd3d-shader/hlsl_codegen.c +++ b/libs/vkd3d-shader/hlsl_codegen.c @@ -3746,6 +3746,9 @@ static bool dce(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void *context) case HLSL_IR_RESOURCE_STORE: case HLSL_IR_SWITCH: break; + case HLSL_IR_STATEBLOCK_CONSTANT: + /* Stateblock constants should not appear in the shader program. */ + vkd3d_unreachable(); } return false; @@ -3869,6 +3872,9 @@ static void compute_liveness_recurse(struct hlsl_block *block, unsigned int loop case HLSL_IR_CALL: /* We should have inlined all calls before computing liveness. */ vkd3d_unreachable(); + case HLSL_IR_STATEBLOCK_CONSTANT: + /* Stateblock constants should not appear in the shader program. */ + vkd3d_unreachable(); case HLSL_IR_STORE: {

1 0

Francisco Casas : vkd3d-shader/hlsl: Parse and store state blocks on variables.
by Alexandre Julliard April 11, 2024

April 11, 2024

Module: vkd3d Branch: master Commit: ee0d439a1be04bed0ef3b14c3614e2a21165736e URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/ee0d439a1be04bed0ef3b14c3614e… Author: Francisco Casas <fcasas(a)codeweavers.com> Date: Fri Mar 15 19:01:34 2024 -0300 vkd3d-shader/hlsl: Parse and store state blocks on variables. --- libs/vkd3d-shader/hlsl.c | 39 ++++++++++++++++ libs/vkd3d-shader/hlsl.h | 37 +++++++++++++++ libs/vkd3d-shader/hlsl.y | 77 ++++++++++++++++++++++++++++--- tests/hlsl/state-block-syntax.shader_test | 2 +- 4 files changed, 147 insertions(+), 8 deletions(-) diff --git a/libs/vkd3d-shader/hlsl.c b/libs/vkd3d-shader/hlsl.c index da6f29f1..3b93c690 100644 --- a/libs/vkd3d-shader/hlsl.c +++ b/libs/vkd3d-shader/hlsl.c @@ -134,6 +134,26 @@ struct hlsl_ir_var *hlsl_get_var(struct hlsl_scope *scope, const char *name) return hlsl_get_var(scope->upper, name); } +static void free_state_block_entry(struct hlsl_state_block_entry *entry) +{ + vkd3d_free(entry->name); + vkd3d_free(entry->args); + hlsl_block_cleanup(entry->instrs); + vkd3d_free(entry->instrs); + vkd3d_free(entry); +} + +void hlsl_free_state_block(struct hlsl_state_block *state_block) +{ + unsigned int k; + + assert(state_block); + for (k = 0; k < state_block->count; ++k) + free_state_block_entry(state_block->entries[k]); + vkd3d_free(state_block->entries); + vkd3d_free(state_block); +} + void hlsl_free_var(struct hlsl_ir_var *decl) { unsigned int k; @@ -142,6 +162,11 @@ void hlsl_free_var(struct hlsl_ir_var *decl) hlsl_cleanup_semantic(&decl->semantic); for (k = 0; k <= HLSL_REGSET_LAST_OBJECT; ++k) vkd3d_free((void *)decl->objects_usage[k]); + if (decl->state_block) + { + hlsl_free_state_block(decl->state_block); + decl->state_block = NULL; + } vkd3d_free(decl); } @@ -3659,6 +3684,20 @@ static void hlsl_ctx_cleanup(struct hlsl_ctx *ctx) rb_destroy(&ctx->functions, free_function_rb, NULL); + /* State blocks must be free before the variables, because they contain instructions that may + * refer to them. */ + LIST_FOR_EACH_ENTRY_SAFE(scope, next_scope, &ctx->scopes, struct hlsl_scope, entry) + { + LIST_FOR_EACH_ENTRY_SAFE(var, next_var, &scope->vars, struct hlsl_ir_var, scope_entry) + { + if (var->state_block) + { + hlsl_free_state_block(var->state_block); + var->state_block = NULL; + } + } + } + LIST_FOR_EACH_ENTRY_SAFE(scope, next_scope, &ctx->scopes, struct hlsl_scope, entry) { LIST_FOR_EACH_ENTRY_SAFE(var, next_var, &scope->vars, struct hlsl_ir_var, scope_entry) diff --git a/libs/vkd3d-shader/hlsl.h b/libs/vkd3d-shader/hlsl.h index fc96488c..b53bcbd7 100644 --- a/libs/vkd3d-shader/hlsl.h +++ b/libs/vkd3d-shader/hlsl.h @@ -423,6 +423,10 @@ struct hlsl_ir_var /* Scope that contains annotations for this variable. */ struct hlsl_scope *annotations; + /* The state block on the variable's declaration, if any. + * These are only really used for effect profiles. */ + struct hlsl_state_block *state_block; + /* Indexes of the IR instructions where the variable is first written and last read (liveness * range). The IR instructions are numerated starting from 2, because 0 means unused, and 1 * means function entry. */ @@ -458,6 +462,38 @@ struct hlsl_ir_var uint32_t is_separated_resource : 1; }; +/* This struct is used to represent assignments in state block entries: + * name = {args[0], args[1], ...}; + * - or - + * name = args[0] + * - or - + * name[lhs_index] = args[0] + * - or - + * name[lhs_index] = {args[0], args[1], ...}; + */ +struct hlsl_state_block_entry +{ + /* For assignments, the name in the lhs. */ + char *name; + + /* Whether the lhs in the assignment is indexed and, in that case, its index. */ + bool lhs_has_index; + unsigned int lhs_index; + + /* Instructions present in the rhs. */ + struct hlsl_block *instrs; + + /* For assignments, arguments of the rhs initializer. */ + struct hlsl_ir_node **args; + unsigned int args_count; +}; + +struct hlsl_state_block +{ + struct hlsl_state_block_entry **entries; + size_t count, capacity; +}; + /* Sized array of variables representing a function's parameters. */ struct hlsl_func_parameters { @@ -1216,6 +1252,7 @@ void hlsl_replace_node(struct hlsl_ir_node *old, struct hlsl_ir_node *new); void hlsl_free_attribute(struct hlsl_attribute *attr); void hlsl_free_instr(struct hlsl_ir_node *node); void hlsl_free_instr_list(struct list *list); +void hlsl_free_state_block(struct hlsl_state_block *state_block); void hlsl_free_type(struct hlsl_type *type); void hlsl_free_var(struct hlsl_ir_var *decl); diff --git a/libs/vkd3d-shader/hlsl.y b/libs/vkd3d-shader/hlsl.y index 3959ff84..28347b4a 100644 --- a/libs/vkd3d-shader/hlsl.y +++ b/libs/vkd3d-shader/hlsl.y @@ -77,6 +77,8 @@ struct parse_variable_def struct hlsl_type *basic_type; uint32_t modifiers; struct vkd3d_shader_location modifiers_loc; + + struct hlsl_state_block *state_block; }; struct parse_function @@ -114,6 +116,12 @@ struct parse_attribute_list const struct hlsl_attribute **attrs; }; +struct state_block_index +{ + bool has_index; + unsigned int index; +}; + } %code provides @@ -931,6 +939,8 @@ static void free_parse_variable_def(struct parse_variable_def *v) vkd3d_free(v->arrays.sizes); vkd3d_free(v->name); hlsl_cleanup_semantic(&v->semantic); + if (v->state_block) + hlsl_free_state_block(v->state_block); vkd3d_free(v); } @@ -2347,6 +2357,9 @@ static struct hlsl_block *initialize_vars(struct hlsl_ctx *ctx, struct list *var free_parse_variable_def(v); continue; } + + var->state_block = v->state_block; + v->state_block = NULL; type = var->data_type; if (v->initializer.args_count) @@ -5252,6 +5265,16 @@ static void validate_uav_type(struct hlsl_ctx *ctx, enum hlsl_sampler_dim dim, hlsl_release_string_buffer(ctx, string); } +static bool state_block_add_entry(struct hlsl_state_block *state_block, struct hlsl_state_block_entry *entry) +{ + if (!vkd3d_array_reserve((void **)&state_block->entries, &state_block->capacity, state_block->count + 1, + sizeof(*state_block->entries))) + return false; + + state_block->entries[state_block->count++] = entry; + return true; +} + } %locations @@ -5292,6 +5315,8 @@ static void validate_uav_type(struct hlsl_ctx *ctx, enum hlsl_sampler_dim dim, struct parse_attribute_list attr_list; struct hlsl_ir_switch_case *switch_case; struct hlsl_scope *scope; + struct hlsl_state_block *state_block; + struct state_block_index state_block_index; } %token KW_BLENDSTATE @@ -5493,6 +5518,7 @@ static void validate_uav_type(struct hlsl_ctx *ctx, enum hlsl_sampler_dim dim, %type <name> var_identifier %type <name> name_opt + %type <parameter> parameter %type <parameters> param_list @@ -5505,6 +5531,10 @@ static void validate_uav_type(struct hlsl_ctx *ctx, enum hlsl_sampler_dim dim, %type <semantic> semantic +%type <state_block> state_block + +%type <state_block_index> state_block_index_opt + %type <switch_case> switch_case %type <type> field_type @@ -6649,22 +6679,54 @@ variable_decl: $$->reg_reservation = $3.reg_reservation; } -state: - any_identifier '=' expr ';' +state_block_start: + %empty { - vkd3d_free($1); - destroy_block($3); + ctx->in_state_block = 1; } -state_block_start: +state_block_index_opt: %empty { - ctx->in_state_block = 1; + $$.has_index = false; + $$.index = 0; } + | '[' C_INTEGER ']' + { + if ($2 < 0) + { + hlsl_error(ctx, &@2, VKD3D_SHADER_ERROR_HLSL_INVALID_INDEX, + "State block array index is not a positive integer constant."); + YYABORT; + } + $$.has_index = true; + $$.index = $2; + } state_block: %empty - | state_block state + { + if (!($$ = hlsl_alloc(ctx, sizeof(*$$)))) + YYABORT; + } + | state_block any_identifier state_block_index_opt '=' complex_initializer ';' + { + struct hlsl_state_block_entry *entry; + + if (!(entry = hlsl_alloc(ctx, sizeof(*entry)))) + YYABORT; + + entry->name = $2; + entry->lhs_has_index = $3.has_index; + entry->lhs_index = $3.index; + + entry->instrs = $5.instrs; + entry->args = $5.args; + entry->args_count = $5.args_count; + + $$ = $1; + state_block_add_entry($$, entry); + } variable_def: variable_decl @@ -6676,6 +6738,7 @@ variable_def: | variable_decl '{' state_block_start state_block '}' { $$ = $1; + $$->state_block = $4; ctx->in_state_block = 0; } diff --git a/tests/hlsl/state-block-syntax.shader_test b/tests/hlsl/state-block-syntax.shader_test index b1071c90..7521516b 100644 --- a/tests/hlsl/state-block-syntax.shader_test +++ b/tests/hlsl/state-block-syntax.shader_test @@ -380,7 +380,7 @@ float4 main() : sv_target { return 0; } % State block entries may have indexes. -[pixel shader todo] +[pixel shader] sampler sam { dogs[3] = 5;

1 0

Francisco Casas : vkd3d-shader/hlsl: Store state block on pass variables.
by Alexandre Julliard April 11, 2024

April 11, 2024

Module: vkd3d Branch: master Commit: ef9ae22ed03f5bfb85730e9362e79e9ee7c88514 URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/ef9ae22ed03f5bfb85730e9362e79… Author: Francisco Casas <fcasas(a)codeweavers.com> Date: Tue Mar 19 15:35:59 2024 -0300 vkd3d-shader/hlsl: Store state block on pass variables. --- libs/vkd3d-shader/fx.c | 3 +++ libs/vkd3d-shader/hlsl.h | 1 + libs/vkd3d-shader/hlsl.y | 11 ++++++++--- tests/hlsl/annotations.shader_test | 4 ++-- tests/hlsl/fxgroup-syntax.shader_test | 2 +- 5 files changed, 15 insertions(+), 6 deletions(-) diff --git a/libs/vkd3d-shader/fx.c b/libs/vkd3d-shader/fx.c index 466908cd..5bed9c7e 100644 --- a/libs/vkd3d-shader/fx.c +++ b/libs/vkd3d-shader/fx.c @@ -115,6 +115,9 @@ static uint32_t write_string(const char *string, struct fx_write_context *fx) static void write_pass(struct hlsl_ir_var *var, struct fx_write_context *fx) { + if (var->state_block_count) + hlsl_fixme(fx->ctx, &var->loc, "Write state block assignments."); + fx->ops->write_pass(var, fx); } diff --git a/libs/vkd3d-shader/hlsl.h b/libs/vkd3d-shader/hlsl.h index 4fa7fe1c..3cb98b76 100644 --- a/libs/vkd3d-shader/hlsl.h +++ b/libs/vkd3d-shader/hlsl.h @@ -426,6 +426,7 @@ struct hlsl_ir_var /* A dynamic array containing the state block on the variable's declaration, if any. * An array variable may contain multiple state blocks. + * A technique pass will always contain one. * These are only really used for effect profiles. */ struct hlsl_state_block **state_blocks; unsigned int state_block_count; diff --git a/libs/vkd3d-shader/hlsl.y b/libs/vkd3d-shader/hlsl.y index c52bd49e..0d3003f4 100644 --- a/libs/vkd3d-shader/hlsl.y +++ b/libs/vkd3d-shader/hlsl.y @@ -1117,7 +1117,7 @@ static bool add_func_parameter(struct hlsl_ctx *ctx, struct hlsl_func_parameters } static bool add_pass(struct hlsl_ctx *ctx, const char *name, struct hlsl_scope *annotations, - const struct vkd3d_shader_location *loc) + struct hlsl_state_block *state_block, const struct vkd3d_shader_location *loc) { struct hlsl_ir_var *var; struct hlsl_type *type; @@ -1127,6 +1127,11 @@ static bool add_pass(struct hlsl_ctx *ctx, const char *name, struct hlsl_scope * return false; var->annotations = annotations; + var->state_blocks = hlsl_alloc(ctx, sizeof(*var->state_blocks)); + var->state_blocks[0] = state_block; + var->state_block_count = 1; + var->state_block_capacity = 1; + if (!hlsl_add_var(ctx, var, false)) { struct hlsl_ir_var *old = hlsl_get_var(ctx->cur_scope, var->name); @@ -5592,9 +5597,9 @@ name_opt: | any_identifier pass: - KW_PASS name_opt annotations_opt '{' '}' + KW_PASS name_opt annotations_opt '{' state_block_start state_block '}' { - if (!add_pass(ctx, $2, $3, &@1)) + if (!add_pass(ctx, $2, $3, $6, &@1)) YYABORT; } diff --git a/tests/hlsl/annotations.shader_test b/tests/hlsl/annotations.shader_test index 40e383aa..3963dfaa 100644 --- a/tests/hlsl/annotations.shader_test +++ b/tests/hlsl/annotations.shader_test @@ -7,14 +7,14 @@ shader model < 6.0 technique10 t1 < int a = 1; > {} technique10 t2 < int a = 2; int t1 = 3; int t2 = 4; > {} -[effect] +[effect todo] // Annotations on passes technique10 t1 < int a = 1; > { pass < int t1 = 2; > {} } -[effect] +[effect todo] // Using names from the global scope float a; diff --git a/tests/hlsl/fxgroup-syntax.shader_test b/tests/hlsl/fxgroup-syntax.shader_test index e8e5fbf5..aedbbfb1 100644 --- a/tests/hlsl/fxgroup-syntax.shader_test +++ b/tests/hlsl/fxgroup-syntax.shader_test @@ -1,5 +1,5 @@ % Test complex effect groups syntax -[pixel shader fail(sm>=6) todo] +[pixel shader fail(sm>=6)] fxgroup group1 { technique10

1 0

Francisco Casas : vkd3d-shader/hlsl: Allow KW_PIXELSHADER and KW_VERTEXSHADER as stateblock lhs.
by Alexandre Julliard April 11, 2024

April 11, 2024

Module: vkd3d Branch: master Commit: e9559c394b29f80073fdbf7d8b284794752ccb3a URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/e9559c394b29f80073fdbf7d8b284… Author: Francisco Casas <fcasas(a)codeweavers.com> Date: Wed Mar 20 17:11:49 2024 -0300 vkd3d-shader/hlsl: Allow KW_PIXELSHADER and KW_VERTEXSHADER as stateblock lhs. --- libs/vkd3d-shader/hlsl.y | 20 ++++++++++++++++++-- tests/hlsl/state-block-syntax.shader_test | 2 +- 2 files changed, 19 insertions(+), 3 deletions(-) diff --git a/libs/vkd3d-shader/hlsl.y b/libs/vkd3d-shader/hlsl.y index 0d3003f4..e81da352 100644 --- a/libs/vkd3d-shader/hlsl.y +++ b/libs/vkd3d-shader/hlsl.y @@ -5537,9 +5537,9 @@ static bool state_block_add_entry(struct hlsl_state_block *state_block, struct h %type <name> any_identifier %type <name> var_identifier +%type <name> stateblock_lhs_identifier %type <name> name_opt - %type <parameter> parameter %type <parameters> param_list @@ -6707,6 +6707,22 @@ state_block_start: ctx->in_state_block = 1; } +stateblock_lhs_identifier: + any_identifier + { + $$ = $1; + } + | KW_PIXELSHADER + { + if (!($$ = hlsl_strdup(ctx, "pixelshader"))) + YYABORT; + } + | KW_VERTEXSHADER + { + if (!($$ = hlsl_strdup(ctx, "vertexshader"))) + YYABORT; + } + state_block_index_opt: %empty { @@ -6731,7 +6747,7 @@ state_block: if (!($$ = hlsl_alloc(ctx, sizeof(*$$)))) YYABORT; } - | state_block any_identifier state_block_index_opt '=' complex_initializer ';' + | state_block stateblock_lhs_identifier state_block_index_opt '=' complex_initializer ';' { struct hlsl_state_block_entry *entry; diff --git a/tests/hlsl/state-block-syntax.shader_test b/tests/hlsl/state-block-syntax.shader_test index 5c2d6f9b..fb0e7312 100644 --- a/tests/hlsl/state-block-syntax.shader_test +++ b/tests/hlsl/state-block-syntax.shader_test @@ -442,7 +442,7 @@ float4 main() : sv_target { return 0; } % PixelShader and VertexShader are valid identifiers for the lhs -[pixel shader todo] +[pixel shader] sampler sam { pixelShader = 20;

1 0

Francisco Casas : tests: Test function call syntax for state blocks.
by Alexandre Julliard April 11, 2024

April 11, 2024

Module: vkd3d Branch: master Commit: 00c8cf1bccd5abe53f12ec736d1ffbc11fdd4dae URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/00c8cf1bccd5abe53f12ec736d1ff… Author: Francisco Casas <fcasas(a)codeweavers.com> Date: Tue Mar 26 01:14:16 2024 -0300 tests: Test function call syntax for state blocks. --- Makefile.am | 1 + tests/hlsl/state-block-function-syntax.shader_test | 99 ++++++++++++++++++++++ 2 files changed, 100 insertions(+) diff --git a/Makefile.am b/Makefile.am index 39b04150..1ab94e51 100644 --- a/Makefile.am +++ b/Makefile.am @@ -185,6 +185,7 @@ vkd3d_shader_tests = \ tests/hlsl/smoothstep.shader_test \ tests/hlsl/sqrt.shader_test \ tests/hlsl/srv-buffers.shader_test \ + tests/hlsl/state-block-function-syntax.shader_test \ tests/hlsl/state-block-syntax.shader_test \ tests/hlsl/static-initializer.shader_test \ tests/hlsl/step.shader_test \ diff --git a/tests/hlsl/state-block-function-syntax.shader_test b/tests/hlsl/state-block-function-syntax.shader_test new file mode 100644 index 00000000..8af53ec5 --- /dev/null +++ b/tests/hlsl/state-block-function-syntax.shader_test @@ -0,0 +1,99 @@ +% Unlike assignment syntax, only these names are allowed. +% The parameter count is also checked. +[pixel shader todo] +sampler sam +{ + SetBlendState(foo, bar, baz); // 3 parameters + SetDepthStencilState(foo, 2); // 2 parameters + SetRasterizerState(foo); // 1 parameter + SetVertexShader(vs); // 1 parameter + SetDomainShader(ds); // 1 paramter + SetHullShader(100); // 1 parameter + SetGeometryShader(foo + bar); // 1 parameter + SetPixelShader(ps1); // 1 parameter + SetComputeShader("random string"); // 1 parameter + OMSetRenderTargets(RTV0, RTV1, RTV2, RTV3, RTV4, RTV5, RTV6, RTV7, DSV); // 2 to 9 parameters +}; + +float4 main() : sv_target { return 0; } + + +[pixel shader fail(sm<6)] +sampler sam +{ + SetSomeotherState(); +}; + +float4 main() : sv_target { return 0; } + + +% It is allowed to use functions together with assignment syntax. +[pixel shader todo] +sampler sam +{ + SetDepthStencilState(foo, bar); + arbitrary_field = 42; +}; + +float4 main() : sv_target { return 0; } + + +% Test complex expression on the arguments, including function calls. +[pixel shader todo] +float4 addition(float4 a, float4 b) +{ + return a + b; +} + +sampler sam +{ + SetBlendState(addition(foo, bar), p + q, p / q); +}; + +float4 main() : sv_target { return 0; } + + +% Test the same thing on technique passes +[pixel shader todo] +technique tech1 +{ + pass pass1 + { + SetBlendState(foo, bar, baz); + SetDepthStencilState(foo, 2); + SetRasterizerState(foo); + SetVertexShader(vs); + } +} + +float4 main() : sv_target { return 0; } + + +% It is not allowed to call the functions to set state blocks on the rhs using the assignment syntax +% for state groups or passes. +[pixel shader fail(sm<6)] +float4 main() : sv_target { return 0; } + +technique +{ + pass + { + cat = SetPixelShader(foobar); + } +} + + +% It not allowed to call the functions to set states outside state blocks or passes. +[pixel shader fail] +DepthStencilState dss1 +{ + DepthEnable = false; + DepthWriteMask = Zero; + DepthFunc = Less; +}; + +float4 main() : sv_target +{ + SetDepthStencilState(NULL, dss1); + return 0; +}

1 0