tests: Move HLSL tests to a subdirectory.

Approved-by: Giovanni Mascellani (@giomasce)
Approved-by: Francisco Casas (@fcasas)
Approved-by: Henri Verbeet (@hverbeet)
Approved-by: Alexandre Julliard (@julliard)
Merge-Request: https://gitlab.winehq.org/wine/vkd3d/-/merge_requests/248

tests/hlsl/abs.shader_test

@@ -0,0 +1,13 @@
+[pixel shader]
+float4 main(uniform float2 u) : sv_target
+{
+    return float4(abs(u), abs(u.x - 0.5), abs(-0.4));
+}
+
+[test]
+uniform 0 float4 0.1 0.7 0.0 0.0
+draw quad
+probe all rgba (0.1, 0.7, 0.4, 0.4)
+uniform 0 float4 -0.7 0.1 0.0 0.0
+draw quad
+probe all rgba (0.7, 0.1, 1.2, 0.4)

tests/hlsl/all.shader_test

@@ -0,0 +1,63 @@
+[require]
+shader model >= 4.0
+
+[pixel shader]
+uniform float4 f;
+
+float4 main() : sv_target
+{
+    return all(f);
+}
+
+[test]
+uniform 0 float4 -1.1 1.6 1.3 0.5
+draw quad
+probe all rgba (1.0, 1.0, 1.0, 1.0)
+
+[test]
+uniform 0 float4 0.0 1.6 1.3 0.5
+draw quad
+probe all rgba (0.0, 0.0, 0.0, 0.0)
+
+[test]
+uniform 0 float4 1.0 0.0 1.3 0.5
+draw quad
+probe all rgba (0.0, 0.0, 0.0, 0.0)
+
+[pixel shader]
+uniform float f;
+
+float4 main() : sv_target
+{
+    return all(f);
+}
+
+[test]
+uniform 0 float4 1.0 0.0 0.0 0.0
+draw quad
+probe all rgba (1.0, 1.0, 1.0, 1.0)
+
+[test]
+uniform 0 float4 0.0 0.0 0.0 0.0
+draw quad
+probe all rgba (0.0, 0.0, 0.0, 0.0)
+
+[pixel shader]
+uniform float2x2 f;
+
+float4 main() : sv_target
+{
+    return all(f);
+}
+
+[test]
+uniform 0 float4 1.0 2.0 0.0 0.0
+uniform 4 float4 3.0 4.0 0.0 0.0
+draw quad
+probe all rgba (1.0, 1.0, 1.0, 1.0)
+
+[test]
+uniform 0 float4 1.0 2.0 0.0 0.0
+uniform 4 float4 0.0 4.0 0.0 0.0
+draw quad
+probe all rgba (0.0, 0.0, 0.0, 0.0)

tests/hlsl/any.shader_test

@@ -0,0 +1,96 @@
+[pixel shader]
+uniform float4 f;
+
+float4 main() : sv_target
+{
+    return any(f);
+}
+
+[test]
+uniform 0 float4 1.0 1.0 1.0 1.0
+draw quad
+probe all rgba (1.0, 1.0, 1.0, 1.0)
+uniform 0 float4 1.0 0.0 0.0 0.0
+draw quad
+probe all rgba (1.0, 1.0, 1.0, 1.0)
+uniform 0 float4 0.0 1.0 0.0 0.0
+draw quad
+probe all rgba (1.0, 1.0, 1.0, 1.0)
+uniform 0 float4 0.0 0.0 1.0 0.0
+draw quad
+probe all rgba (1.0, 1.0, 1.0, 1.0)
+uniform 0 float4 0.0 0.0 0.0 1.0
+draw quad
+probe all rgba (1.0, 1.0, 1.0, 1.0)
+uniform 0 float4 0.0 0.0 0.0 0.0
+draw quad
+probe all rgba (0.0, 0.0, 0.0, 0.0)
+uniform 0 float4 -1.0 -1.0 -1.0 -1.0
+draw quad
+probe all rgba (1.0, 1.0, 1.0, 1.0)
+
+[pixel shader]
+uniform float f;
+
+float4 main() : sv_target
+{
+    return any(f);
+}
+
+[test]
+uniform 0 float4 1.0 0.0 0.0 0.0
+draw quad
+probe all rgba (1.0, 1.0, 1.0, 1.0)
+uniform 0 float4 0.0 0.0 0.0 0.0
+draw quad
+probe all rgba (0.0, 0.0, 0.0, 0.0)
+uniform 0 float4 -1.0 0.0 0.0 0.0
+draw quad
+probe all rgba (1.0, 1.0, 1.0, 1.0)
+
+[require]
+shader model >= 4.0
+
+[pixel shader]
+uniform uint4 b;
+
+float4 main() : sv_target
+{
+    return any((bool4)b);
+}
+
+[test]
+uniform 0 uint4 1 1 1 1
+draw quad
+probe all rgba (1.0, 1.0, 1.0, 1.0)
+uniform 0 uint4 1 0 0 0
+draw quad
+probe all rgba (1.0, 1.0, 1.0, 1.0)
+uniform 0 uint4 0 1 0 0
+draw quad
+probe all rgba (1.0, 1.0, 1.0, 1.0)
+uniform 0 uint4 0 0 1 0
+draw quad
+probe all rgba (1.0, 1.0, 1.0, 1.0)
+uniform 0 uint4 0 0 0 1
+draw quad
+probe all rgba (1.0, 1.0, 1.0, 1.0)
+uniform 0 uint4 0 0 0 0
+draw quad
+probe all rgba (0.0, 0.0, 0.0, 0.0)
+
+[pixel shader]
+uniform uint b;
+
+float4 main() : sv_target
+{
+    return any((bool)b);
+}
+
+[test]
+uniform 0 uint4 1 0 0 0
+draw quad
+probe all rgba (1.0, 1.0, 1.0, 1.0)
+uniform 0 uint4 0 0 0 0
+draw quad
+probe all rgba (0.0, 0.0, 0.0, 0.0)

tests/hlsl/arithmetic-float-uniform.shader_test

@@ -0,0 +1,78 @@
+[pixel shader]
+uniform float2 a;
+
+float4 main() : SV_TARGET
+{
+    float x = a.x;
+    float y = a.y;
+    return float4(x + y, x - y, x * y, x / y);
+}
+
+[test]
+uniform 0 float4 5.0 15.0 0.0 0.0
+draw quad
+probe all rgba (20.0, -10.0, 75.0, 0.33333333) 1
+
+[pixel shader]
+uniform float2 a;
+
+float4 main() : SV_TARGET
+{
+    float x = a.x;
+    float y = a.y;
+    return float4(x % y, +x, -x, y / x);
+}
+
+[test]
+uniform 0 float4 5.0 15.0 0.0 0.0
+draw quad
+probe all rgba (5.0, 5.0, -5.0, 3.0) 1
+
+[pixel shader]
+uniform float2 a;
+
+float4 main() : SV_TARGET
+{
+    float x = a.x;
+    float y = a.y;
+    return float4(x % y, -x % y, x % -y, -x % -y);
+}
+
+[test]
+uniform 0 float4 42.0 5.0 0.0 0.0
+draw quad
+probe all rgba (2.0, -2.0, 2.0, -2.0) 16
+
+[pixel shader]
+uniform float2 a;
+
+float4 main() : SV_TARGET
+{
+    float x = a.x;
+    float y = a.y;
+    return float4(x % y, -x % y, x % -y, -x % -y);
+}
+
+[test]
+uniform 0 float4 45.0 5.0 0.0 0.0
+draw quad
+probe all rgba (0.0, 0.0, 0.0, 0.0)
+
+[require]
+% Infinities are not allowed in SM1
+shader model >= 4.0
+
+[pixel shader]
+uniform float2 a;
+
+float4 main() : SV_TARGET
+{
+    float x = a.x;
+    float y = a.y;
+    return x / y;
+}
+
+[test]
+uniform 0 float4 1.0 0.0 0.0 0.0
+draw quad
+probe all rgba (1e99, 1e99, 1e99, 1e99)

tests/hlsl/arithmetic-float.shader_test

@@ -0,0 +1,68 @@
+[pixel shader]
+float4 main() : SV_TARGET
+{
+    float x = 5.0;
+    float y = 15.0;
+
+    return float4(x + y, x - y, x * y, x / y);
+}
+
+[test]
+draw quad
+probe all rgba (20.0, -10.0, 75.0, 0.33333333)
+
+[pixel shader]
+float4 main() : SV_TARGET
+{
+    float x = 5.0;
+    float y = 15.0;
+
+    return float4(x % y, +x, -x, y / x);
+}
+
+[test]
+draw quad
+probe all rgba (5.0, 5.0, -5.0, 3.0)
+
+[pixel shader]
+float4 main() : SV_TARGET
+{
+    float x = 42;
+    float y = 5;
+
+    return float4(x % y, -x % y, x % -y, -x % -y);
+}
+
+[test]
+draw quad
+probe all rgba (2.0, -2.0, 2.0, -2.0) 16
+
+[pixel shader]
+float4 main() : SV_TARGET
+{
+    float x = 45;
+    float y = 5;
+
+    return float4(x % y, -x % y, x % -y, -x % -y);
+}
+
+[test]
+draw quad
+probe all rgba (0.0, 0.0, 0.0, 0.0)
+
+[require]
+% Infinities are not allowed in SM1
+shader model >= 4.0
+
+[pixel shader]
+float4 main() : SV_TARGET
+{
+    float x = 1;
+    float y = 0;
+
+    return x / y;
+}
+
+[test]
+draw quad
+probe all rgba (1e99, 1e99, 1e99, 1e99)

tests/hlsl/arithmetic-int-uniform.shader_test

@@ -0,0 +1,102 @@
+[pixel shader]
+uniform float2 a;
+
+float4 main() : SV_TARGET
+{
+    int x = a.x;
+    int y = a.y;
+    return float4(x + y, x - y, x * y, x / y);
+}
+
+[test]
+uniform 0 float4 5.0 16.0 0.0 0.0
+draw quad
+probe all rgba (21.0, -11.0, 80.0, 0.0)
+
+[pixel shader]
+uniform float2 a;
+
+float4 main() : SV_TARGET
+{
+    int x = a.x;
+    int y = a.y;
+    return float4(x % y, +x, -x, y / x);
+}
+
+[test]
+uniform 0 float4 5.0 16.0 0.0 0.0
+draw quad
+probe all rgba (5.0, 5.0, -5.0, 3.0)
+
+[pixel shader]
+uniform float2 a;
+
+float4 main() : SV_TARGET
+{
+    int x = a.x;
+    int y = a.y;
+    return float4(x / y, -x / y, x / -y, -x / -y);
+}
+
+[test]
+uniform 0 float4 42.0 5.0 0.0 0.0
+draw quad
+probe all rgba (8.0, -8.0, -8.0, 8.0)
+
+[pixel shader]
+uniform float2 a;
+
+float4 main() : SV_TARGET
+{
+    int x = a.x;
+    int y = a.y;
+    return float4(x % y, -x % y, x % -y, -x % -y);
+}
+
+[test]
+uniform 0 float4 42.0 5.0 0.0 0.0
+draw quad
+probe all rgba (2.0, -2.0, 2.0, -2.0)
+
+[pixel shader]
+uniform float2 a;
+
+float4 main() : SV_TARGET
+{
+    int x = a.x;
+    int y = a.y;
+    return float4(x / y, -x / y, x / -y, -x / -y);
+}
+
+[test]
+uniform 0 float4 45.0 5.0 0.0 0.0
+draw quad
+probe all rgba (9.0, -9.0, -9.0, 9.0)
+
+[pixel shader]
+uniform float2 a;
+
+float4 main() : SV_TARGET
+{
+    int x = a.x;
+    int y = a.y;
+    return float4(x % y, -x % y, x % -y, -x % -y);
+}
+
+[test]
+uniform 0 float4 45.0 5.0 0.0 0.0
+draw quad
+probe all rgba (0.0, 0.0, 0.0, 0.0)
+
+[pixel shader]
+uniform float4 a;
+
+float4 main() : SV_TARGET
+{
+    return abs(int4(a));
+}
+
+[test]
+uniform 0 float4 5.0 -7.0 0.0 -10.0
+draw quad
+probe all rgba (5.0, 7.0, 0.0, 10.0)

tests/hlsl/arithmetic-int.shader_test

@@ -0,0 +1,111 @@
+[pixel shader]
+float4 main() : SV_TARGET
+{
+    int x = 5;
+    int y = 15;
+
+    return float4(x + y, x - y, x * y, x / y);
+}
+
+[test]
+draw quad
+probe all rgba (20.0, -10.0, 75.0, 0.0)
+
+[pixel shader]
+float4 main() : SV_TARGET
+{
+    int x = 5;
+    int y = 15;
+
+    return float4(x % y, +x, -x, y / x);
+}
+
+[test]
+draw quad
+probe all rgba (5.0, 5.0, -5.0, 3.0)
+
+[pixel shader]
+float4 main() : SV_TARGET
+{
+    int x = 42;
+    int y = 5;
+
+    return float4(x / y, -x / y, x / -y, -x / -y);
+}
+
+[test]
+draw quad
+probe all rgba (8.0, -8.0, -8.0, 8.0)
+
+[pixel shader]
+float4 main() : SV_TARGET
+{
+    int x = 42;
+    int y = 5;
+
+    return float4(x % y, -x % y, x % -y, -x % -y);
+}
+
+[test]
+draw quad
+probe all rgba (2.0, -2.0, 2.0, -2.0)
+
+[pixel shader]
+float4 main() : SV_TARGET
+{
+    int x = 45;
+    int y = 5;
+
+    return float4(x / y, -x / y, x / -y, -x / -y);
+}
+
+[test]
+draw quad
+probe all rgba (9.0, -9.0, -9.0, 9.0)
+
+[pixel shader]
+float4 main() : SV_TARGET
+{
+    int x = 45;
+    int y = 5;
+
+    return float4(x % y, -x % y, x % -y, -x % -y);
+}
+
+[test]
+draw quad
+probe all rgba (0.0, 0.0, 0.0, 0.0)
+
+[pixel shader fail]
+float4 main() : SV_TARGET
+{
+    int x = 1;
+    int y = 0;
+
+    return x / y;
+}
+
+[pixel shader fail]
+float4 main() : SV_TARGET
+{
+    int x = 1;
+    int y = 0;
+
+    return x % y;
+}
+
+[require]
+shader model >= 4.0
+
+[pixel shader]
+float4 main() : SV_TARGET
+{
+    int x = -2147483648;
+    int y = -1;
+
+    return x / y;
+}
+
+[test]
+draw quad
+probe all rgba (-2147483648.0, -2147483648.0, -2147483648.0, -2147483648.0)

tests/hlsl/arithmetic-uint.shader_test

@@ -0,0 +1,46 @@
+[require]
+shader model >= 4.0
+
+[pixel shader]
+float4 main() : SV_TARGET
+{
+    uint x = 5;
+    uint y = 15;
+
+    return float4(x + y, x - y, x * y, x / y);
+}
+
+[test]
+draw quad
+probe all rgba (20.0, 4294967296.0, 75.0, 0.0)
+
+[pixel shader]
+float4 main() : SV_TARGET
+{
+    uint x = 5;
+    uint y = 15;
+
+    return float4(x % y, +x, -x, y / x);
+}
+
+[test]
+draw quad
+probe all rgba (5.0, 5.0, 4294967296.0, 3.0)
+
+[pixel shader fail]
+float4 main() : SV_TARGET
+{
+    uint x = 1;
+    uint y = 0;
+
+    return x / y;
+}
+
+[pixel shader fail]
+float4 main() : SV_TARGET
+{
+    uint x = 1;
+    uint y = 0;
+
+    return x % y;
+}

tests/hlsl/array-dimension.shader_test

@@ -0,0 +1,17 @@
+% Test what kinds of expressions are valid array dimensions.
+
+[pixel shader todo]
+float4 main() : sv_target
+{
+    const int dim = 4;
+    float a[2 * 2] = {0.1, 0.2, 0.3, 0.4};
+    float b[4.1] = a;
+    float c[dim] = b;
+    float d[true] = {c[0]};
+    float e[65536];
+    return float4(d[0], c[0], c[1], c[3]);
+}
+
+[test]
+todo draw quad
+probe all rgba (0.1, 0.1, 0.2, 0.4)

tests/hlsl/array-index-expr.shader_test

@@ -0,0 +1,99 @@
+[pixel shader todo]
+uniform float4 f[3];
+uniform float2 i;
+
+float4 main() : sv_target
+{
+    return f[i.x + i.y];
+}
+
+[test]
+uniform 0 float4 1.0 2.0 3.0 4.0
+uniform 4 float4 5.0 6.0 7.0 8.0
+uniform 8 float4 9.0 10.0 11.0 12.0
+uniform 12 float4 0 0 0 0
+todo draw quad
+todo probe all rgba (1.0, 2.0, 3.0, 4.0)
+uniform 12 float4 1 0 0 0
+todo draw quad
+todo probe all rgba (5.0, 6.0, 7.0, 8.0)
+uniform 12 float4 0 1 0 0
+todo draw quad
+todo probe all rgba (5.0, 6.0, 7.0, 8.0)
+uniform 12 float4 1 1 0 0
+todo draw quad
+todo probe all rgba (9.0, 10.0, 11.0, 12.0)
+
+
+[pixel shader]
+uniform float i;
+
+float4 main() : SV_TARGET
+{
+    float4 arr = float4(11.0, 12.0, 13.0, 14.0);
+    return arr[i];
+}
+
+[test]
+uniform 0 float 0
+draw quad
+probe all rgba (11.0, 11.0, 11.0, 11.0)
+uniform 0 float 1
+draw quad
+probe all rgba (12.0, 12.0, 12.0, 12.0)
+uniform 0 float 2
+draw quad
+probe all rgba (13.0, 13.0, 13.0, 13.0)
+uniform 0 float 3
+draw quad
+probe all rgba (14.0, 14.0, 14.0, 14.0)
+
+
+[pixel shader]
+uniform float i;
+
+float4 main() : SV_TARGET
+{
+    int4 arr_i = int4(21, 22, 23, 24);
+    bool4 arr_b = bool4(true, false, true, false);
+    return float4(arr_i[i], arr_b[i], arr_i[3 - i], arr_b[3 - i]);
+}
+
+[test]
+uniform 0 float 0
+draw quad
+probe all rgba (21.0, 1.0, 24.0, 0.0)
+uniform 0 float 1
+draw quad
+probe all rgba (22.0, 0.0, 23.0, 1.0)
+uniform 0 float 2
+draw quad
+probe all rgba (23.0, 1.0, 22.0, 0.0)
+uniform 0 float 3
+draw quad
+probe all rgba (24.0, 0.0, 21.0, 1.0)
+
+
+[pixel shader todo]
+uniform float2 i;
+
+float4 main() : sv_target
+{
+    float4 f[3] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
+
+    return f[i.x + i.y];
+}
+
+[test]
+uniform 0 float4 0 0 0 0
+todo draw quad
+todo probe all rgba (1.0, 2.0, 3.0, 4.0)
+uniform 0 float4 1 0 0 0
+todo draw quad
+todo probe all rgba (5.0, 6.0, 7.0, 8.0)
+uniform 0 float4 0 1 0 0
+todo draw quad
+todo probe all rgba (5.0, 6.0, 7.0, 8.0)
+uniform 0 float4 1 1 0 0
+todo draw quad
+todo probe all rgba (9.0, 10.0, 11.0, 12.0)

tests/hlsl/array-parameters.shader_test

@@ -0,0 +1,175 @@
+[pixel shader]
+float fun(float a[2])
+{
+    return 10 * a[0] + a[1];
+}
+
+float4 main() : sv_target
+{
+    float f[2] = {2, 5};
+
+    return fun(f);
+}
+
+[test]
+draw quad
+probe all rgba (25.0, 25.0, 25.0, 25.0)
+
+
+[pixel shader fail]
+float fun(float a[2])
+{
+    return 0;
+}
+
+float4 main() : sv_target
+{
+    int f[2] = {2, 5};
+
+    return fun(f);
+}
+
+
+[pixel shader fail]
+float fun(float a[1])
+{
+    return 0;
+}
+
+float4 main() : sv_target
+{
+    float f = 4;
+
+    return fun(f);
+}
+
+
+[pixel shader fail]
+float fun(int a[2])
+{
+    return 0;
+}
+
+float4 main() : sv_target
+{
+    float f[2] = {1, 2};
+
+    return fun(f);
+}
+
+
+[pixel shader]
+float4 fun(float a[2][4])
+{
+    float4 res;
+
+    res.x = 10 * a[0][0] + a[1][0];
+    res.y = 10 * a[0][1] + a[1][1];
+    res.z = 10 * a[0][2] + a[1][2];
+    res.w = 10 * a[0][3] + a[1][3];
+    return res;
+}
+
+float4 main() : sv_target
+{
+    float f[2][4] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+    return fun(f);
+}
+
+[test]
+draw quad
+probe all rgba (15.0, 26.0, 37.0, 48.0)
+
+
+[pixel shader fail]
+float fun(float a[2])
+{
+    return a[2]; // out of bounds.
+}
+
+float4 main() : sv_target
+{
+    float f[2] = {1, 2};
+
+    return fun(f);
+}
+
+
+[pixel shader fail]
+float fun(float a[2])
+{
+    return 0;
+}
+
+float4 main() : sv_target
+{
+    float f[3] = {1, 2, 3};
+
+    return fun(f);
+}
+
+
+% Implicit size arrays are not allowed.
+[pixel shader fail]
+float fun(float a[])
+{
+    return 0;
+}
+
+float4 main() : sv_target
+{
+    float f[2] = {1, 2};
+
+    return fun(f);
+}
+
+[pixel shader fail]
+float4 fun(float a[4])
+{
+    return 0;
+}
+
+float4 main() : sv_target
+{
+    float4 v = {1, 2, 3, 4};
+
+    return fun(v);
+}
+
+
+% Arrays with the same number of components are allowed.
+[pixel shader]
+float fun(float a[2][3])
+{
+    return 100*a[0][0] + 10*a[0][2] + a[1][2];
+}
+
+float4 main() : sv_target
+{
+    float f[3][2] = {1, 2, 3, 4, 5, 6};
+
+    return fun(f);
+}
+
+[test]
+draw quad
+probe all rgba (136.0, 136.0, 136.0, 136.0)
+
+
+[pixel shader]
+float fun(float a[2][3])
+{
+    return 100*a[0][0] + 10*a[1][0] + a[1][2];
+}
+
+float4 main() : sv_target
+{
+    float f[6] = {7, 8, 9, 0, 1, 2};
+
+    return fun(f);
+}
+
+[test]
+draw quad
+probe all rgba (702.0, 702.0, 702.0, 702.0)

tests/hlsl/array-size-expr.shader_test

@@ -0,0 +1,53 @@
+[pixel shader]
+static const float4 array_st[(2 + 1) * 2] = {
+    11, 12, 13, 14,
+    21, 22, 23, 24,
+    31, 32, 33, 34,
+    41, 42, 43, 44,
+    51, 52, 53, 54,
+    61, 62, 63, 64,
+};
+
+float4 main() : SV_TARGET
+{
+    return array_st[1];
+}
+
+[test]
+draw quad
+probe all rgba (21, 22, 23, 24)
+
+
+[pixel shader]
+static const float4 array_st[2*2][1+1] = {
+    11, 12, 13, 14,
+    21, 22, 23, 24,
+    31, 32, 33, 34,
+    41, 42, 43, 44,
+    51, 52, 53, 54,
+    61, 62, 63, 64,
+    71, 72, 73, 74,
+    81, 82, 83, 84,
+};
+
+float4 main() : SV_TARGET
+{
+    return array_st[2][1];
+}
+
+[test]
+draw quad
+probe all rgba (61, 62, 63, 64)
+
+[pixel shader]
+static const int size = 8;
+static const float array[size] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+float4 main() : sv_target
+{
+    return float4(array[1], array[2], array[5], array[0]);
+}
+
+[test]
+draw quad
+probe all rgba (2, 3, 6, 1)

tests/hlsl/asfloat.shader_test

@@ -0,0 +1,48 @@
+[require]
+shader model >= 4.0
+
+[pixel shader]
+float4 main(uniform float f, uniform int i, uniform uint u, uniform half h) : sv_target
+{
+    float4 ret;
+
+    ret.x = asfloat(f);
+    ret.y = asfloat(i);
+    ret.z = asfloat(u);
+    ret.w = asfloat(h);
+    return ret;
+}
+
+[test]
+uniform 0 float4 123.0 -2.0 456 0.01
+draw quad
+probe (320,240) rgba (123.0, -2.0, 456.0, 0.01)
+
+[pixel shader]
+float4 main(uniform float2x2 m, uniform float4 v) : sv_target
+{
+    return float4(asfloat(m)[0][1], asfloat(v).y, 0, 0);
+}
+
+[test]
+uniform 0 float4 11 12 0 0
+uniform 4 float4 13 14 0 0
+uniform 8 float4 20 21 22 23
+draw quad
+probe (320,240) rgba (13.0, 21.0, 0.0, 0.0)
+
+[pixel shader fail]
+float4 main() : sv_target
+{
+    bool b = true;
+
+    return asfloat(b);
+}
+
+[pixel shader fail]
+float4 main() : sv_target
+{
+    double d = 1.0;
+
+    return asfloat(d);
+}

tests/hlsl/asuint.shader_test

@@ -0,0 +1,55 @@
+[require]
+shader model >= 4.0
+
+[pixel shader]
+
+float4 main(uniform float f, uniform int i, uniform uint u, uniform half h) : sv_target
+{
+    uint4 ret;
+
+    ret.x = asuint(f);
+    ret.y = asuint(i);
+    ret.z = asuint(u);
+    ret.w = asuint(h);
+    return ret;
+}
+
+[test]
+uniform 0 uint4 123 0xc0000000 456 0x7fd69345
+draw quad
+probe (320,240) rgba (123.0, 3221225472.0, 456.0, 2144768896.0)
+
+
+[pixel shader]
+
+float4 main(uniform float2x2 m, uniform float4 v) : sv_target
+{
+    return float4(asuint(m)[0][1], asuint(v).y, 0, 0);
+}
+
+[test]
+uniform 0 uint4 11 12 0 0
+uniform 4 uint4 13 14 0 0
+uniform 8 uint4 20 21 22 23
+draw quad
+probe (320,240) rgba (13.0, 21.0, 0.0, 0.0)
+
+
+[pixel shader fail]
+
+float4 main() : sv_target
+{
+    bool b = true;
+
+    return asuint(b);
+}
+
+
+[pixel shader fail]
+
+float4 main() : sv_target
+{
+    double d = 1.0;
+
+    return asuint(d);
+}

tests/hlsl/attributes.shader_test

@@ -0,0 +1,120 @@
+% Test HLSL attribute syntax. The compiler ignores unrecognized attributes, so
+% we need to get the parsing syntax right. Most of the following tests which
+% succeed print warnings.
+
+[pixel shader]
+
+    [numthreads]
+float4 main() : sv_target { return 0; }
+
+[pixel shader]
+
+    [ numthreads ]
+float4 main() : sv_target { return 0; }
+
+[pixel shader]
+
+    [numthreads(1)]
+float4 main() : sv_target { return 0; }
+
+[pixel shader todo]
+
+    [numthreads("")]
+float4 main() : sv_target { return 0; }
+
+[pixel shader todo]
+
+    [numthreads("one")]
+float4 main() : sv_target { return 0; }
+
+[pixel shader todo]
+
+uniform float4 f;
+
+    [numthreads(1, "one", 3 + 9, -9.8e4, -float2(1, 2), f)]
+float4 main() : sv_target { return 0; }
+
+[pixel shader fail]
+
+    [numthreads()]
+float4 main() : sv_target { return 0; }
+
+[pixel shader fail]
+
+    [numthreads(1,)]
+float4 main() : sv_target { return 0; }
+
+[pixel shader fail]
+
+    [numthreads(f)]
+float4 main() : sv_target { return 0; }
+
+[pixel shader fail]
+
+    /* Test an invalid constructor. */
+    [numthreads(float2(1))]
+float4 main() : sv_target { return 0; }
+
+[pixel shader]
+
+    [not_a_real_attribute_name]
+float4 main() : sv_target { return 0; }
+
+[pixel shader]
+
+uniform float4 f;
+
+    [f]
+float4 main() : sv_target { return 0; }
+
+[pixel shader fail]
+% This is valid IDL syntax, but not HLSL.
+    [one, two]
+float4 main() : sv_target { return 0; }
+
+[pixel shader]
+
+    [one][two]
+float4 main() : sv_target { return 0; }
+
+[pixel shader fail todo]
+
+    [one][one]
+float4 main() : sv_target { return 0; }
+
+[pixel shader fail todo]
+
+    [one][one(1)]
+float4 main() : sv_target { return 0; }
+
+[pixel shader]
+
+    [one][One]
+float4 main() : sv_target { return 0; }
+
+[pixel shader]
+
+    [numthreads]
+float4 main();
+
+    [numthreads]
+float4 main() : sv_target { return 0; }
+
+[pixel shader]
+
+/* Expressions with side effects are forbidden in attributes—see
+ * hlsl-numthreads.shader_test for an example—but not if the attribute is
+ * ignored. */
+static int i = 1;
+
+    [one(i++)]
+    [two(++i)]
+    [three(i = 4)]
+float4 main() : sv_target { return 0; }
+
+[pixel shader fail]
+
+    [one]
+float4 f;
+
+float4 main() : sv_target { return 0; }

tests/hlsl/bitwise.shader_test

@@ -0,0 +1,132 @@
+[require]
+shader model >= 4.0
+
+[pixel shader]
+float4 main() : SV_TARGET
+{
+    int x = 5;
+    int y = 15;
+
+    return float4(x >> y, y >> x, x << y, y << x);
+}
+
+[test]
+draw quad
+probe all rgba (0.0, 0.0, 163840.0, 480.0)
+
+[pixel shader]
+float4 main() : SV_TARGET
+{
+    int x = 5;
+    int y = 15;
+
+    return float4(x & y, x | y, x ^ y, ~x);
+}
+
+[test]
+draw quad
+probe all rgba (5.0, 15.0, 10.0, -6.0)
+
+[pixel shader]
+float4 main() : SV_TARGET
+{
+    int zero = 0;
+    int one = 1;
+
+    return float4(zero & zero, zero & one, one & zero, one & one);
+}
+
+[test]
+draw quad
+probe all rgba (0.0, 0.0, 0.0, 1.0)
+
+[pixel shader]
+float4 main() : SV_TARGET
+{
+    int zero = 0;
+    int one = 1;
+
+    return float4(zero | zero, zero | one, one | zero, one | one);
+}
+
+[test]
+draw quad
+probe all rgba (0.0, 1.0, 1.0, 1.0)
+
+[pixel shader]
+float4 main() : SV_TARGET
+{
+    int zero = 0;
+    int one = 1;
+
+    return float4(zero ^ zero, zero ^ one, one ^ zero, one ^ one);
+}
+
+[test]
+draw quad
+probe all rgba (0.0, 1.0, 1.0, 0.0)
+
+[pixel shader]
+float4 main() : SV_TARGET
+{
+    uint x = 5;
+    uint y = 15;
+
+    return float4(x >> y, y >> x, x << y, y << x);
+}
+
+[test]
+draw quad
+probe all rgba (0.0, 0.0, 163840.0, 480.0)
+
+[pixel shader]
+float4 main() : SV_TARGET
+{
+    uint x = 5;
+    uint y = 15;
+
+    return float4(x & y, x | y, x ^ y, ~x);
+}
+
+[test]
+draw quad
+probe all rgba (5.0, 15.0, 10.0, 4294967296.0)
+
+[pixel shader]
+float4 main() : SV_TARGET
+{
+    uint zero = 0;
+    uint one = 1;
+
+    return float4(zero & zero, zero & one, one & zero, one & one);
+}
+
+[test]
+draw quad
+probe all rgba (0.0, 0.0, 0.0, 1.0)
+
+[pixel shader]
+float4 main() : SV_TARGET
+{
+    uint zero = 0;
+    uint one = 1;
+
+    return float4(zero | zero, zero | one, one | zero, one | one);
+}
+
+[test]
+draw quad
+probe all rgba (0.0, 1.0, 1.0, 1.0)
+
+[pixel shader]
+float4 main() : SV_TARGET
+{
+    uint zero = 0;
+    uint one = 1;
+
+    return float4(zero ^ zero, zero ^ one, one ^ zero, one ^ one);
+}
+
+[test]
+draw quad
+probe all rgba (0.0, 1.0, 1.0, 0.0)

tests/hlsl/bool-cast.shader_test

@@ -0,0 +1,48 @@
+[pixel shader]
+float4 main() : SV_TARGET
+{
+    return float4(
+        (float)(bool)0.0,
+        (float)(bool)0,
+        (float)(bool)2.0,
+        (float)(bool)2
+    );
+}
+
+[test]
+draw quad
+probe all rgba (0.0, 0.0, 1.0, 1.0)
+
+
+[require]
+shader model >= 4.0
+
+
+[pixel shader]
+uniform float4 x;
+uniform int4 y;
+
+float4 main() : SV_TARGET
+{
+    return (float4)(bool4)x + 10.0 * (float4)(int4)(bool4)y;
+}
+
+[test]
+uniform 0 float4 0.0 0.0 2.0 4.0
+uniform 4 int4 0 1 0 10
+draw quad
+probe all rgba (0.0, 10.0, 1.0, 11.0)
+
+
+[pixel shader]
+uniform bool4 b;
+
+float4 main() : sv_target
+{
+    return (float4)b + (float4)(int4)b;
+}
+
+[test]
+uniform 0 uint4 0x00000001 0x00000002 0x80000000 0x00000000
+draw quad
+probe all rgba (2.0, 2.0, 2.0, 0.0)

tests/hlsl/bool-semantics.shader_test

@@ -0,0 +1,53 @@
+[require]
+shader model >= 4.0
+
+[input layout]
+0 r32g32b32a32 uint apple
+0 r32g32 int sv_position
+
+[vertex buffer 0]
+format r32 uint
+0 1 0x80000000 0xffffffff   -2 -2
+0 1 0x80000000 0xffffffff   -2  2
+0 1 0x80000000 0xffffffff    2 -2
+0 1 0x80000000 0xffffffff    2  2
+
+[vertex shader]
+
+struct input
+{
+    bool4 apple : apple;
+    int4 pos : sv_position;
+};
+
+struct output
+{
+    bool4 apple : apple;
+    int4 fapple : apple1;
+    float4 pos : sv_position;
+};
+
+void main(in struct input i, out struct output o, uint id : SV_VertexID)
+{
+    o.apple = i.apple;
+    o.fapple = i.apple;
+    o.pos = i.pos;
+}
+
+[pixel shader]
+
+struct input
+{
+    bool4 apple : apple;
+    int4 fapple : apple1;
+    float4 pos : sv_position;
+};
+
+float4 main(struct input i) : sv_target
+{
+    return i.apple + i.fapple;
+}
+
+[test]
+draw triangle strip 4
+probe all rgba (0.0, 2.0, 2.0, 2.0)

tests/hlsl/cast-broadcast.shader_test

@@ -0,0 +1,98 @@
+[pixel shader]
+struct apple
+{
+    float3 aa;
+    float4 bb;
+};
+
+struct banana
+{
+    struct apple aa;
+    int2 bb;
+    int4 cc[8];
+};
+
+float4 main() : SV_TARGET
+{
+    struct banana p = (struct banana)42;
+    return p.aa.bb + p.cc[5];
+}
+
+[test]
+draw quad
+probe all rgba (84.0, 84.0, 84.0, 84.0)
+
+
+[pixel shader fail]
+struct apple
+{
+    float3 aa;
+    float4 bb;
+};
+
+float4 main() : SV_TARGET
+{
+    struct apple f = 31;
+    return f.bb;
+}
+
+
+[pixel shader fail]
+struct apple
+{
+    float3 aa;
+    float4 bb;
+};
+
+float4 fun(struct apple f)
+{
+    return f.bb;
+}
+
+float4 main() : SV_TARGET
+{
+    return fun(31);
+}
+
+
+[pixel shader fail]
+float4 fun(float f[7])
+{
+    return f[1];
+}
+
+float4 main() : SV_TARGET
+{
+    return fun(32);
+}
+
+
+[pixel shader fail]
+struct apple
+{
+    float4 foo;
+    Texture2D tex;
+};
+
+float4 PSMain() : SV_TARGET
+{
+    struct apple a1;
+    a1 = (struct apple)1;
+    return a1.foo;
+}
+
+
+[pixel shader]
+float4 fun(float3 f)
+{
+    return f.xyxy;
+}
+
+float4 main() : SV_TARGET
+{
+    return fun(33);
+}
+
+[test]
+draw quad
+probe all rgba (33.0, 33.0, 33.0, 33.0)