-- v13: vkd3d-shader/spirv: Avoid invalid bool-to-bool conversion in spirv_compiler_emit_movc(). vkd3d-shader/dxil: Implement the DXIL VSELECT instruction. tests/shader-runner: Add tests for 64-bit casts. vkd3d-shader/spirv: Return an error if an invalid handler is encountered.
From: Conor McCarthy cmccarthy@codeweavers.com
Passing less than 4.0 breaks the use of [require] with 'shader model < 4.0'. --- tests/shader_runner_d3d11.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/tests/shader_runner_d3d11.c b/tests/shader_runner_d3d11.c index bd9d363ce..abe455203 100644 --- a/tests/shader_runner_d3d11.c +++ b/tests/shader_runner_d3d11.c @@ -747,7 +747,7 @@ void run_shader_tests_d3d11(void) init_adapter_info(); if (init_test_context(&runner)) { - run_shader_tests(&runner.r, &d3d11_runner_ops, NULL, SHADER_MODEL_2_0, SHADER_MODEL_5_1); + run_shader_tests(&runner.r, &d3d11_runner_ops, NULL, SHADER_MODEL_4_0, SHADER_MODEL_5_1); destroy_test_context(&runner); } }
From: Conor McCarthy cmccarthy@codeweavers.com
--- Makefile.am | 1 + tests/hlsl/float-comparison.shader_test | 67 +++++++++++++++++++++++++ 2 files changed, 68 insertions(+) create mode 100644 tests/hlsl/float-comparison.shader_test
diff --git a/Makefile.am b/Makefile.am index 002746829..a5c5fe62f 100644 --- a/Makefile.am +++ b/Makefile.am @@ -87,6 +87,7 @@ vkd3d_shader_tests = \ tests/hlsl/entry-point-semantics.shader_test \ tests/hlsl/exp.shader_test \ tests/hlsl/expr-indexing.shader_test \ + tests/hlsl/float-comparison.shader_test \ tests/hlsl/floor.shader_test \ tests/hlsl/fmod.shader_test \ tests/hlsl/for.shader_test \ diff --git a/tests/hlsl/float-comparison.shader_test b/tests/hlsl/float-comparison.shader_test new file mode 100644 index 000000000..6f3ec3769 --- /dev/null +++ b/tests/hlsl/float-comparison.shader_test @@ -0,0 +1,67 @@ +[pixel shader] +uniform float4 f; + +float4 main() : sv_target +{ + float4 result; + float n = f.x/f.w; + + /* '!(condition)' in SM6 forces use of the unordered instruction variant. */ + + result.x = (f.y > f.x) ? 1.0 : 0.0; + result.x += (f.y < f.x) ? 10.0 : 0.0; + result.x += (f.y >= f.x) ? 100.0 : 0.0; + result.x += (f.y <= f.x) ? 1000.0 : 0.0; + result.x += !(f.y <= f.x) ? 10000.0 : 0.0; + result.x += !(f.y >= f.x) ? 100000.0 : 0.0; + result.x += !(f.y < f.x) ? 1000000.0 : 0.0; + result.x += !(f.y > f.x) ? 10000000.0 : 0.0; + result.y = (n > f.x) ? 1.0 : 0.0; + result.y += (n < f.x) ? 10.0 : 0.0; + result.y += (n >= f.x) ? 100.0 : 0.0; + result.y += (n <= f.x) ? 1000.0 : 0.0; + result.y += !(n <= f.x) ? 10000.0 : 0.0; + result.y += !(n >= f.x) ? 100000.0 : 0.0; + result.y += !(n < f.x) ? 1000000.0 : 0.0; + result.y += !(n > f.x) ? 10000000.0 : 0.0; + result.z = (f.z == f.y) ? 1.0 : 0.0; + result.z += (f.z != f.y) ? 10.0 : 0.0; + result.z += !(f.z == f.y) ? 100.0 : 0.0; + result.z += !(f.z != f.y) ? 1000.0 : 0.0; + result.z += (n == f.y) ? 10000.0 : 0.0; + result.z += (n != f.y) ? 100000.0 : 0.0; + result.z += !(n == f.y) ? 1000000.0 : 0.0; + result.z += !(n != f.y) ? 10000000.0 : 0.0; + /* It doesn't seem possible to generate DXIL instructions for 'is ordered' or 'is unordered'. + * Expressions 'isnan(n)' and '(isnan(n) || isnan(f.x))' compile into intrinsics. */ + result.w = 0; + return result; +} + +% SM1-3 apparently treats '0/0' as zero. +[require] +shader model < 4.0 + +[test] +uniform 0 float4 0.0 1.5 1.5 0.0 +draw quad +todo probe all rgba (1010101.0, 11001100.0, 1101001.0, 0.0) + +% SM4-5 optimises away the 'not' by inverting the condition, even though this is invalid for NaN. +[require] +shader model >= 4.0 +shader model < 6.0 + +[test] +uniform 0 float4 0.0 1.5 1.5 0.0 +draw quad +todo probe all rgba (1010101.0, 0.0, 1101001.0, 0.0) + +% SM6 emits the correct ordered/unordered instructions, so comparisons are false for NaN, and are made true with 'not'. +[require] +shader model >= 6.0 + +[test] +uniform 0 float4 0.0 1.5 1.5 0.0 +todo(sm>=6) draw quad +probe all rgba (1010101.0, 11110000.0, 1101001.0, 0.0)
From: Conor McCarthy cmccarthy@codeweavers.com
Prevents return of an invalid SPIR-V module. --- libs/vkd3d-shader/spirv.c | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-)
diff --git a/libs/vkd3d-shader/spirv.c b/libs/vkd3d-shader/spirv.c index d2621ffa1..198970041 100644 --- a/libs/vkd3d-shader/spirv.c +++ b/libs/vkd3d-shader/spirv.c @@ -6657,7 +6657,7 @@ static void spirv_compiler_emit_bool_cast(struct spirv_compiler *compiler, spirv_compiler_emit_store_dst(compiler, dst, val_id); }
-static void spirv_compiler_emit_alu_instruction(struct spirv_compiler *compiler, +static enum vkd3d_result spirv_compiler_emit_alu_instruction(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction) { struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; @@ -6681,7 +6681,7 @@ static void spirv_compiler_emit_alu_instruction(struct spirv_compiler *compiler, /* VSIR supports cast from bool to signed/unsigned integer types and floating point types, * where bool is treated as a 1-bit integer and a signed 'true' value converts to -1. */ spirv_compiler_emit_bool_cast(compiler, instruction); - return; + return VKD3D_OK; } } else @@ -6694,7 +6694,7 @@ static void spirv_compiler_emit_alu_instruction(struct spirv_compiler *compiler, ERR("Unexpected instruction %#x.\n", instruction->handler_idx); spirv_compiler_error(compiler, VKD3D_SHADER_ERROR_SPV_INVALID_HANDLER, "Encountered invalid/unhandled instruction handler %#x.", instruction->handler_idx); - return; + return VKD3D_ERROR_INVALID_SHADER; }
assert(instruction->dst_count == 1); @@ -6726,6 +6726,7 @@ static void spirv_compiler_emit_alu_instruction(struct spirv_compiler *compiler, vkd3d_spirv_build_op_decorate(builder, val_id, SpvDecorationNoContraction, NULL, 0);
spirv_compiler_emit_store_dst(compiler, dst, val_id); + return VKD3D_OK; }
static enum GLSLstd450 spirv_compiler_map_ext_glsl_instruction( @@ -9506,7 +9507,7 @@ static int spirv_compiler_handle_instruction(struct spirv_compiler *compiler, case VKD3DSIH_UTOF: case VKD3DSIH_UTOU: case VKD3DSIH_XOR: - spirv_compiler_emit_alu_instruction(compiler, instruction); + ret = spirv_compiler_emit_alu_instruction(compiler, instruction); break; case VKD3DSIH_DFMA: case VKD3DSIH_DMAX: @@ -9727,6 +9728,9 @@ static int spirv_compiler_handle_instruction(struct spirv_compiler *compiler, break; default: FIXME("Unhandled instruction %#x.\n", instruction->handler_idx); + spirv_compiler_error(compiler, VKD3D_SHADER_ERROR_SPV_INVALID_HANDLER, + "Encountered invalid/unhandled instruction handler %#x.", instruction->handler_idx); + break; }
return ret;
From: Conor McCarthy cmccarthy@codeweavers.com
--- Makefile.am | 1 + tests/d3d12.c | 5 --- tests/hlsl/cast-64-bit.shader_test | 57 ++++++++++++++++++++++++++ tests/shader_runner.c | 64 ++++++++++++++++++++++++++++++ tests/utils.h | 15 +++++++ 5 files changed, 137 insertions(+), 5 deletions(-) create mode 100644 tests/hlsl/cast-64-bit.shader_test
diff --git a/Makefile.am b/Makefile.am index a5c5fe62f..2666194a6 100644 --- a/Makefile.am +++ b/Makefile.am @@ -61,6 +61,7 @@ vkd3d_shader_tests = \ tests/hlsl/bitwise.shader_test \ tests/hlsl/bool-cast.shader_test \ tests/hlsl/bool-semantics.shader_test \ + tests/hlsl/cast-64-bit.shader_test \ tests/hlsl/cast-broadcast.shader_test \ tests/hlsl/cast-componentwise-compatible.shader_test \ tests/hlsl/cast-componentwise-equal.shader_test \ diff --git a/tests/d3d12.c b/tests/d3d12.c index 8f100a5e7..f9b5c5e98 100644 --- a/tests/d3d12.c +++ b/tests/d3d12.c @@ -42,11 +42,6 @@ static ID3D10Blob *compile_shader(const char *source, size_t len, const char *pr return bytecode; }
-struct dvec2 -{ - double x, y; -}; - static bool compare_uint8(uint8_t a, uint8_t b, unsigned int max_diff) { return abs(a - b) <= max_diff; diff --git a/tests/hlsl/cast-64-bit.shader_test b/tests/hlsl/cast-64-bit.shader_test new file mode 100644 index 000000000..813cce108 --- /dev/null +++ b/tests/hlsl/cast-64-bit.shader_test @@ -0,0 +1,57 @@ +[require] +shader model >= 5.0 + +[pixel shader todo] +uniform double2 d; +uniform float2 f; + +float4 main() : sv_target +{ + double2 n = d / f; + return float4(d.x, d.y, n.x, n.y); +} + +[test] +uniform 0 double2 -4.5 8.5 +uniform 4 float4 -2.25 4.25 0.0 0.0 +todo(sm<6) draw quad +probe all rgba (-4.5, 8.5, 2.0, 2.0) + + +[require] +shader model >= 6.0 + +[pixel shader] +uniform uint64_t2 l; +uniform uint2 u; + +float4 main() : sv_target +{ + uint64_t2 n = l / u; + uint4 result = uint4(l.x, l.y, n.x, n.y); + return result; +} + +[test] +uniform 0 uint64_t2 0x500000001 0x100000002 +uniform 4 uint4 10 4 0 0 +todo draw quad +todo probe all rgba (1.0, 2.0, 2147483648.0, 1073741824.0) + + +[pixel shader] +uniform int64_t2 l; +uniform int2 i; + +float4 main() : sv_target +{ + int64_t2 n = l / i; + int4 result = int4(l.x, l.y, n.x, n.y); + return result; +} + +[test] +uniform 0 int64_t2 -21474836481 0x100000002 +uniform 4 int4 -20 8 0 0 +todo draw quad +todo probe all rgba (-1.0, 2.0, 1073741824.0, 536870912.0) diff --git a/tests/shader_runner.c b/tests/shader_runner.c index dadfe3338..7f7dbffb7 100644 --- a/tests/shader_runner.c +++ b/tests/shader_runner.c @@ -491,6 +491,48 @@ static void read_uint4(const char **line, struct uvec4 *v) read_uint(line, &v->w); }
+static void read_int64(const char **line, int64_t *i) +{ + char *rest; + int64_t val; + + errno = 0; + val = strtoll(*line, &rest, 0); + + if (errno != 0 || (*rest != '\0' && !isspace((unsigned char)*rest))) + fatal_error("Malformed int64 constant '%s'.\n", *line); + + *i = val; + *line = rest; +} + +static void read_uint64(const char **line, uint64_t *u) +{ + char *rest; + uint64_t val; + + errno = 0; + val = strtoull(*line, &rest, 0); + + if (errno != 0 || (*rest != '\0' && !isspace((unsigned char)*rest))) + fatal_error("Malformed uint64 constant '%s'.\n", *line); + + *u = val; + *line = rest; +} + +static void read_int64_t2(const char **line, struct i64vec2 *v) +{ + read_int64(line, &v->x); + read_int64(line, &v->y); +} + +static void read_uint64_t2(const char **line, struct u64vec2 *v) +{ + read_uint64(line, &v->x); + read_uint64(line, &v->y); +} + static void parse_test_directive(struct shader_runner *runner, const char *line) { char *rest; @@ -726,6 +768,14 @@ static void parse_test_directive(struct shader_runner *runner, const char *line) fatal_error("Malformed float constant '%s'.\n", line); set_uniforms(runner, offset, 1, &f); } + else if (match_string(line, "double2", &line)) + { + struct dvec2 v; + + if (sscanf(line, "%lf %lf", &v.x, &v.y) < 2) + fatal_error("Malformed double2 constant '%s'.\n", line); + set_uniforms(runner, offset, 4, &v); + } else if (match_string(line, "int4", &line)) { struct ivec4 v; @@ -754,6 +804,20 @@ static void parse_test_directive(struct shader_runner *runner, const char *line) read_uint(&line, &u); set_uniforms(runner, offset, 1, &u); } + else if (match_string(line, "int64_t2", &line)) + { + struct i64vec2 v; + + read_int64_t2(&line, &v); + set_uniforms(runner, offset, 4, &v); + } + else if (match_string(line, "uint64_t2", &line)) + { + struct u64vec2 v; + + read_uint64_t2(&line, &v); + set_uniforms(runner, offset, 4, &v); + } else { fatal_error("Unknown uniform type '%s'.\n", line); diff --git a/tests/utils.h b/tests/utils.h index 670941905..e8bbacc37 100644 --- a/tests/utils.h +++ b/tests/utils.h @@ -35,6 +35,11 @@ struct vec4 float x, y, z, w; };
+struct dvec2 +{ + double x, y; +}; + struct ivec4 { int x, y, z, w; @@ -45,6 +50,16 @@ struct uvec4 unsigned int x, y, z, w; };
+struct i64vec2 +{ + int64_t x, y; +}; + +struct u64vec2 +{ + uint64_t x, y; +}; + struct resource_readback { uint64_t width;
From: Conor McCarthy cmccarthy@codeweavers.com
Shaders parsed from DXIL contain a bool condition register, so calling spirv_compiler_emit_int_to_bool() results in an invalid bool/uint comparison. --- libs/vkd3d-shader/spirv.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-)
diff --git a/libs/vkd3d-shader/spirv.c b/libs/vkd3d-shader/spirv.c index 198970041..a6ea685a9 100644 --- a/libs/vkd3d-shader/spirv.c +++ b/libs/vkd3d-shader/spirv.c @@ -6893,8 +6893,9 @@ static void spirv_compiler_emit_movc(struct spirv_compiler *compiler, component_count = vkd3d_write_mask_component_count(dst->write_mask); type_id = spirv_compiler_get_type_id_for_dst(compiler, dst);
- condition_id = spirv_compiler_emit_int_to_bool(compiler, - VKD3D_SHADER_CONDITIONAL_OP_NZ, component_count, condition_id); + if (src[0].reg.data_type != VKD3D_DATA_BOOL) + condition_id = spirv_compiler_emit_int_to_bool(compiler, + VKD3D_SHADER_CONDITIONAL_OP_NZ, component_count, condition_id); val_id = vkd3d_spirv_build_op_select(builder, type_id, condition_id, src1_id, src2_id);
spirv_compiler_emit_store_dst(compiler, dst, val_id);
From: Conor McCarthy cmccarthy@codeweavers.com
--- libs/vkd3d-shader/dxil.c | 63 +++++++++++++++++++++++++ tests/hlsl/conditional.shader_test | 6 +-- tests/hlsl/float-comparison.shader_test | 2 +- tests/hlsl/for.shader_test | 2 +- tests/hlsl/return.shader_test | 12 ++--- tests/hlsl/step.shader_test | 2 +- tests/hlsl/switch.shader_test | 12 ++--- tests/hlsl/ternary.shader_test | 19 +++++++- 8 files changed, 98 insertions(+), 20 deletions(-)
diff --git a/libs/vkd3d-shader/dxil.c b/libs/vkd3d-shader/dxil.c index 2174ba52c..4d289ab85 100644 --- a/libs/vkd3d-shader/dxil.c +++ b/libs/vkd3d-shader/dxil.c @@ -2156,6 +2156,18 @@ static size_t sm6_parser_get_value_index(struct sm6_parser *sm6, uint64_t idx) return i; }
+static bool sm6_value_validate_is_register(const struct sm6_value *value, struct sm6_parser *sm6) +{ + if (!sm6_value_is_register(value)) + { + WARN("Operand of type %u is not a register.\n", value->value_type); + vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND, + "A register operand passed to a DXIL instruction is not a register."); + return false; + } + return true; +} + static bool sm6_value_validate_is_handle(const struct sm6_value *value, struct sm6_parser *sm6) { if (!sm6_value_is_handle(value)) @@ -2168,6 +2180,19 @@ static bool sm6_value_validate_is_handle(const struct sm6_value *value, struct s return true; }
+static bool sm6_value_validate_is_bool(const struct sm6_value *value, struct sm6_parser *sm6) +{ + const struct sm6_type *type = value->type; + if (!sm6_type_is_bool(type)) + { + WARN("Operand of type class %u is not bool.\n", type->class); + vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_OPERAND, + "A bool operand of type class %u passed to a DXIL instruction is not a bool.", type->class); + return false; + } + return true; +} + static const struct sm6_value *sm6_parser_get_value_safe(struct sm6_parser *sm6, unsigned int idx) { if (idx < sm6->value_count) @@ -3653,6 +3678,41 @@ static void sm6_parser_emit_ret(struct sm6_parser *sm6, const struct dxil_record ins->handler_idx = VKD3DSIH_NOP; }
+static void sm6_parser_emit_vselect(struct sm6_parser *sm6, const struct dxil_record *record, + struct vkd3d_shader_instruction *ins, struct sm6_value *dst) +{ + struct vkd3d_shader_src_param *src_params; + const struct sm6_value *src[3]; + unsigned int i = 0; + + if (!(src[1] = sm6_parser_get_value_by_ref(sm6, record, NULL, &i)) + || !(src[2] = sm6_parser_get_value_by_ref(sm6, record, src[1]->type, &i)) + || !(src[0] = sm6_parser_get_value_by_ref(sm6, record, NULL, &i))) + { + return; + } + dxil_record_validate_operand_max_count(record, i, sm6); + + for (i = 0; i < 3; ++i) + { + if (!sm6_value_validate_is_register(src[i], sm6)) + return; + } + + dst->type = src[1]->type; + + if (!sm6_value_validate_is_bool(src[0], sm6)) + return; + + vsir_instruction_init(ins, &sm6->p.location, VKD3DSIH_MOVC); + + src_params = instruction_src_params_alloc(ins, 3, sm6); + for (i = 0; i < 3; ++i) + src_param_init_from_value(&src_params[i], src[i]); + + instruction_dst_param_init_ssa_scalar(ins, sm6); +} + static bool sm6_metadata_value_is_node(const struct sm6_metadata_value *m) { return m && m->type == VKD3D_METADATA_NODE; @@ -3813,6 +3873,9 @@ static enum vkd3d_result sm6_parser_function_init(struct sm6_parser *sm6, const is_terminator = true; ret_found = true; break; + case FUNC_CODE_INST_VSELECT: + sm6_parser_emit_vselect(sm6, record, ins, dst); + break; default: FIXME("Unhandled dxil instruction %u.\n", record->code); return VKD3D_ERROR_INVALID_SHADER; diff --git a/tests/hlsl/conditional.shader_test b/tests/hlsl/conditional.shader_test index 4175813bd..0a927a8fa 100644 --- a/tests/hlsl/conditional.shader_test +++ b/tests/hlsl/conditional.shader_test @@ -11,10 +11,10 @@ float4 main() : sv_target
[test] uniform 0 float4 0.0 0.0 0.0 0.0 -todo(sm>=6) draw quad +draw quad probe all rgba (0.9, 0.8, 0.7, 0.6) uniform 0 float4 0.1 0.0 0.0 0.0 -todo(sm>=6) draw quad +draw quad probe all rgba (0.1, 0.2, 0.3, 0.4)
[pixel shader] @@ -43,7 +43,7 @@ float4 main() : sv_target
[test] uniform 0 float4 0.0 0.0 0.0 0.0 -todo(sm>=6) draw quad +draw quad probe all rgba (0.9, 0.8, 0.7, 0.6)
[pixel shader fail(sm<6)] diff --git a/tests/hlsl/float-comparison.shader_test b/tests/hlsl/float-comparison.shader_test index 6f3ec3769..ee4b5eb7c 100644 --- a/tests/hlsl/float-comparison.shader_test +++ b/tests/hlsl/float-comparison.shader_test @@ -63,5 +63,5 @@ shader model >= 6.0
[test] uniform 0 float4 0.0 1.5 1.5 0.0 -todo(sm>=6) draw quad +draw quad probe all rgba (1010101.0, 11110000.0, 1101001.0, 0.0) diff --git a/tests/hlsl/for.shader_test b/tests/hlsl/for.shader_test index e5faa28fd..1392118b3 100644 --- a/tests/hlsl/for.shader_test +++ b/tests/hlsl/for.shader_test @@ -22,7 +22,7 @@ float4 main(float tex : texcoord) : sv_target }
[test] -todo(sm>=6) draw quad +draw quad probe ( 0, 0, 159, 480) rgba (10.0, 35.0, 0.0, 0.0) probe (161, 0, 479, 480) rgba (10.0, 38.0, 0.0, 0.0) probe (481, 0, 640, 480) rgba ( 5.0, 10.0, 0.0, 0.0) diff --git a/tests/hlsl/return.shader_test b/tests/hlsl/return.shader_test index 29621b006..fbea07926 100644 --- a/tests/hlsl/return.shader_test +++ b/tests/hlsl/return.shader_test @@ -38,10 +38,10 @@ float4 main() : sv_target
[test] uniform 0 float 0.2 -todo(sm>=6) draw quad +draw quad probe all rgba (0.1, 0.2, 0.3, 0.4) uniform 0 float 0.8 -todo(sm>=6) draw quad +draw quad probe all rgba (0.5, 0.6, 0.7, 0.8)
[pixel shader] @@ -65,10 +65,10 @@ void main(out float4 ret : sv_target)
[test] uniform 0 float 0.2 -todo(sm>=6) draw quad +draw quad probe all rgba (0.3, 0.4, 0.5, 0.6) uniform 0 float 0.8 -todo(sm>=6) draw quad +draw quad probe all rgba (0.1, 0.2, 0.3, 0.4)
[pixel shader] @@ -211,10 +211,10 @@ void main(out float4 ret : sv_target)
[test] uniform 0 float 0.2 -todo(sm>=6) draw quad +draw quad probe all rgba (0.2, 0.2, 0.2, 0.2) uniform 0 float 0.8 -todo(sm>=6) draw quad +draw quad probe all rgba (0.5, 0.5, 0.5, 0.5)
[pixel shader] diff --git a/tests/hlsl/step.shader_test b/tests/hlsl/step.shader_test index b857f00b2..e201e15f9 100644 --- a/tests/hlsl/step.shader_test +++ b/tests/hlsl/step.shader_test @@ -9,7 +9,7 @@ float4 main() : sv_target [test] uniform 0 float4 5.0 -2.6 3.0 2.0 uniform 4 float4 1.0 -4.3 3.0 4.0 -todo(sm>=6) draw quad +draw quad probe all rgba (0.0, 0.0, 1.0, 1.0)
diff --git a/tests/hlsl/switch.shader_test b/tests/hlsl/switch.shader_test index 243b0b117..b7edadccf 100644 --- a/tests/hlsl/switch.shader_test +++ b/tests/hlsl/switch.shader_test @@ -19,13 +19,13 @@ float4 main() : sv_target
[test] uniform 0 uint4 3 0 0 0 -todo(sm>=6) draw quad +draw quad probe all rgba (5.0, 5.0, 5.0, 5.0) uniform 0 uint4 1 0 0 0 -todo(sm>=6) draw quad +draw quad probe all rgba (4.0, 4.0, 4.0, 4.0) uniform 0 uint4 0 0 0 0 -todo(sm>=6) draw quad +draw quad probe all rgba (3.0, 3.0, 3.0, 3.0)
% falling through is only supported for empty case statements @@ -49,13 +49,13 @@ float4 main() : sv_target
[test] uniform 0 uint4 2 0 0 0 -todo(sm>=6) draw quad +draw quad probe all rgba (1.0, 2.0, 3.0, 4.0) uniform 0 uint4 1 0 0 0 -todo(sm>=6) draw quad +draw quad probe all rgba (1.1, 2.0, 3.0, 4.0) uniform 0 uint4 0 0 0 0 -todo(sm>=6) draw quad +draw quad probe all rgba (1.1, 2.0, 3.0, 4.0)
% case value evaluation diff --git a/tests/hlsl/ternary.shader_test b/tests/hlsl/ternary.shader_test index 587b3d556..7b4c71f7b 100644 --- a/tests/hlsl/ternary.shader_test +++ b/tests/hlsl/ternary.shader_test @@ -29,7 +29,7 @@ float4 main() : sv_target
[test] uniform 0 float4 1.1 3.0 4.0 5.0 -todo(sm>=6) draw quad +draw quad probe all rgba (1.1, 2.0, 0.0, 0.0)
[pixel shader] @@ -42,11 +42,26 @@ float4 main() : sv_target return float4(f1, f2, f3, 0.0); }
+[require] +shader model < 6.0 + [test] uniform 0 float4 1.0 0.0 0.0 0.0 -todo(sm>=6) draw quad +draw quad probe all rgba (0.5, 0.6, 0.7, 0.0)
+[require] +shader model >= 6.0 + +[test] +uniform 0 float4 1.0 0.0 0.0 0.0 +draw quad +probe all rgba (0.5, 0.2, 0.7, 0.0) + +[require] +% reset requirements + + [pixel shader fail(sm>=6)] float4 x, y, z;
This merge request was approved by Henri Verbeet.
-
Conor McCarthy -
Conor McCarthy (＠cmccarthy)
-
Henri Verbeet (＠hverbeet)