mirror of
https://gitlab.winehq.org/wine/vkd3d.git
synced 2024-11-21 16:46:41 -08:00
9f515a9daa
This is achieved by means of creating a variable storing zero, loading every array element, comparing if the non-constant index matches the index of that element at runtime, and in that case store the corresponding element in the variable. This seems to be the same strategy that the native compiler uses.
339 lines
6.6 KiB
Plaintext
339 lines
6.6 KiB
Plaintext
[pixel shader]
|
|
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(glsl) draw quad
|
|
probe (0, 0) rgba (1.0, 2.0, 3.0, 4.0)
|
|
uniform 12 float4 1 0 0 0
|
|
todo(glsl) draw quad
|
|
probe (0, 0) rgba (5.0, 6.0, 7.0, 8.0)
|
|
uniform 12 float4 0 1 0 0
|
|
todo(glsl) draw quad
|
|
probe (0, 0) rgba (5.0, 6.0, 7.0, 8.0)
|
|
uniform 12 float4 1 1 0 0
|
|
todo(glsl) draw quad
|
|
probe (0, 0) 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
|
|
todo(glsl) draw quad
|
|
probe (0, 0) rgba (11.0, 11.0, 11.0, 11.0)
|
|
uniform 0 float 1
|
|
todo(glsl) draw quad
|
|
probe (0, 0) rgba (12.0, 12.0, 12.0, 12.0)
|
|
uniform 0 float 2
|
|
todo(glsl) draw quad
|
|
probe (0, 0) rgba (13.0, 13.0, 13.0, 13.0)
|
|
uniform 0 float 3
|
|
todo(glsl) draw quad
|
|
probe (0, 0) rgba (14.0, 14.0, 14.0, 14.0)
|
|
|
|
|
|
[pixel shader]
|
|
float i;
|
|
|
|
float4 main() : sv_target
|
|
{
|
|
float a[4] = {1, 2, 3, 4};
|
|
|
|
return a[i];
|
|
}
|
|
|
|
[test]
|
|
uniform 0 float 2.3
|
|
todo(glsl) draw quad
|
|
probe (0, 0) rgba (3, 3, 3, 3)
|
|
|
|
|
|
[pixel shader todo(sm<4)]
|
|
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
|
|
todo(sm<4 | glsl) draw quad
|
|
probe (0, 0) rgba (21.0, 1.0, 24.0, 0.0)
|
|
uniform 0 float 1
|
|
todo(sm<4 | glsl) draw quad
|
|
probe (0, 0) rgba (22.0, 0.0, 23.0, 1.0)
|
|
uniform 0 float 2
|
|
todo(sm<4 | glsl) draw quad
|
|
probe (0, 0) rgba (23.0, 1.0, 22.0, 0.0)
|
|
uniform 0 float 3
|
|
todo(sm<4 | glsl) draw quad
|
|
probe (0, 0) rgba (24.0, 0.0, 21.0, 1.0)
|
|
|
|
|
|
[pixel shader]
|
|
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(glsl) draw quad
|
|
probe (0, 0) rgba (1.0, 2.0, 3.0, 4.0)
|
|
uniform 0 float4 1 0 0 0
|
|
todo(glsl) draw quad
|
|
probe (0, 0) rgba (5.0, 6.0, 7.0, 8.0)
|
|
uniform 0 float4 0 1 0 0
|
|
todo(glsl) draw quad
|
|
probe (0, 0) rgba (5.0, 6.0, 7.0, 8.0)
|
|
uniform 0 float4 1 1 0 0
|
|
todo(glsl) draw quad
|
|
probe (0, 0) rgba (9.0, 10.0, 11.0, 12.0)
|
|
|
|
|
|
[pixel shader]
|
|
float4 a;
|
|
|
|
float4 main() : sv_target
|
|
{
|
|
float4 arr[] = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120};
|
|
|
|
float4 tmp = float4(1, 2, 3, 4);
|
|
tmp.yz = arr[a.z].wx;
|
|
|
|
return tmp;
|
|
}
|
|
|
|
[test]
|
|
uniform 0 float4 0 0 2.4 0
|
|
todo(glsl) draw quad
|
|
probe (0, 0) rgba (1.0, 120.0, 90.0, 4.0)
|
|
|
|
|
|
[pixel shader]
|
|
float i, j;
|
|
|
|
float4 main() : sv_target
|
|
{
|
|
float arr[6][2] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
|
|
|
|
return arr[i][j];
|
|
}
|
|
|
|
[test]
|
|
if(sm<4) uniform 0 float 3
|
|
if(sm<4) uniform 4 float 1
|
|
if(sm>=4) uniform 0 float4 3 1 0 0
|
|
todo(glsl) draw quad
|
|
probe (0, 0) rgba (7, 7, 7, 7)
|
|
if(sm<4) uniform 0 float 5
|
|
if(sm<4) uniform 4 float 0
|
|
if(sm>=4) uniform 0 float4 5 0 0 0
|
|
todo(glsl) draw quad
|
|
probe (0, 0) rgba (10, 10, 10, 10)
|
|
|
|
|
|
[pixel shader]
|
|
float i, j;
|
|
float k;
|
|
|
|
float4 main() : sv_target
|
|
{
|
|
float4 arr[4][3] = {
|
|
0, 1, 2, 3,
|
|
10, 11, 12, 13,
|
|
20, 21, 22, 23,
|
|
30, 31, 32, 33,
|
|
40, 41, 42, 43,
|
|
50, 51, 52, 53,
|
|
60, 61, 62, 63,
|
|
70, 71, 72, 73,
|
|
80, 81, 82, 83,
|
|
90, 91, 92, 93,
|
|
100, 101, 102, 103,
|
|
110, 111, 112, 113,
|
|
};
|
|
|
|
return arr[i + k][j + k];
|
|
}
|
|
|
|
[test]
|
|
if(sm<4) uniform 0 float 2
|
|
if(sm<4) uniform 4 float 1
|
|
if(sm<4) uniform 8 float -1
|
|
if(sm>=4) uniform 0 float4 2 1 -1 0
|
|
todo(glsl) draw quad
|
|
probe (0, 0) rgba (30, 31, 32, 33)
|
|
if(sm<4) uniform 0 float 1
|
|
if(sm<4) uniform 4 float 0
|
|
if(sm<4) uniform 8 float 1
|
|
if(sm>=4) uniform 0 float4 1 0 1 0
|
|
todo(glsl) draw quad
|
|
probe (0, 0) rgba (70, 71, 72, 73)
|
|
|
|
|
|
[pixel shader]
|
|
float i, j;
|
|
|
|
float4 main() : sv_target
|
|
{
|
|
struct
|
|
{
|
|
float a;
|
|
float b[3];
|
|
} apples[4] = {42, 0, 1, 2, 42, 3, 4, 5, 42, 6, 7, 8, 42, 9, 10, 11};
|
|
|
|
return apples[i - 10].b[j - 10];
|
|
}
|
|
|
|
[test]
|
|
if(sm<4) uniform 0 float 11
|
|
if(sm<4) uniform 4 float 12
|
|
if(sm>=4) uniform 0 float4 11 12 0 0
|
|
todo(glsl) draw quad
|
|
probe (0, 0) rgba (5, 5, 5, 5)
|
|
if(sm<4) uniform 0 float 13
|
|
if(sm<4) uniform 4 float 10
|
|
if(sm>=4) uniform 0 float4 13 10 0 0
|
|
todo(glsl) draw quad
|
|
probe (0, 0) rgba (9, 9, 9, 9)
|
|
|
|
|
|
% SM1 doesn't support relative addressing if it is used in a l-value.
|
|
[require]
|
|
shader model >= 4.0
|
|
|
|
[pixel shader]
|
|
int i, j;
|
|
|
|
float4 main() : sv_target
|
|
{
|
|
float mut1[4] = {1, 2, 3, 4};
|
|
float mut2[4] = {5, 6, 7, 8};
|
|
|
|
mut1[i] = 100;
|
|
mut2[j] = mut1[j];
|
|
|
|
return float4(mut2[0], mut2[1], mut2[2], mut2[3]);
|
|
}
|
|
|
|
[test]
|
|
uniform 0 int 0
|
|
uniform 1 int 0
|
|
todo(glsl) draw quad
|
|
probe (0, 0) rgba (100, 6, 7, 8)
|
|
uniform 0 int 2
|
|
uniform 1 int 2
|
|
todo(glsl) draw quad
|
|
probe (0, 0) rgba (5, 6, 100, 8)
|
|
uniform 0 int 1
|
|
uniform 1 int 3
|
|
todo(glsl) draw quad
|
|
probe (0, 0) rgba (5, 6, 7, 4)
|
|
|
|
|
|
[pixel shader]
|
|
float a, b, c, d;
|
|
float e, f, g, h;
|
|
int i, j;
|
|
|
|
float4 main() : sv_target
|
|
{
|
|
|
|
float arr1[8] = {a, a, b, b, c, c, d, d};
|
|
float arr2[8] = {e, e, f, f, g, g, h, h};
|
|
|
|
arr1[i] = arr2[i];
|
|
arr2[j] = arr1[j];
|
|
|
|
return 1000 * float4(arr1[0], arr1[4], arr2[0], arr2[4])
|
|
+ 100 * float4(arr1[1], arr1[5], arr2[1], arr2[5])
|
|
+ 10 * float4(arr1[2], arr1[6], arr2[2], arr2[6])
|
|
+ 1 * float4(arr1[3], arr1[7], arr2[3], arr2[7]);
|
|
}
|
|
|
|
[test]
|
|
uniform 0 float4 1 2 3 4
|
|
uniform 4 float4 5 6 7 8
|
|
uniform 8 int 3
|
|
uniform 9 int 4
|
|
todo(glsl) draw quad
|
|
probe (0, 0) rgba (1126, 3344, 5566, 3788)
|
|
|
|
|
|
[pixel shader]
|
|
uint i, j;
|
|
|
|
float4 main() : sv_target
|
|
{
|
|
float mut1[4] = {1, 2, 3, 4};
|
|
|
|
/* dxc emits a pointer bitcast, which results in a VSIR MOV with mismatched data types. */
|
|
mut1[i] = asfloat(j);
|
|
|
|
return float4(mut1[0], mut1[1], mut1[2], mut1[3]);
|
|
}
|
|
|
|
[test]
|
|
uniform 0 uint 1
|
|
uniform 1 uint 0x40a00000
|
|
todo(glsl) draw quad
|
|
probe (0, 0) rgba (1, 5, 3, 4)
|
|
|
|
|
|
[require]
|
|
% reset requirements
|
|
|
|
|
|
[pixel shader]
|
|
uniform float4 f[4];
|
|
uniform uint4 u;
|
|
uniform uint4 v;
|
|
|
|
float4 main() : sv_target
|
|
{
|
|
float temp[4];
|
|
temp[0] = f[u.x].x;
|
|
temp[1] = f[u.y].x;
|
|
temp[2] = f[u.z].x;
|
|
temp[3] = f[u.w].x;
|
|
return float4(temp[v.x], temp[v.y], temp[v.z], temp[v.w]);
|
|
}
|
|
|
|
% FXC is incapable of compiling this correctly, but results differ for SM1-3 vs SM4-5.
|
|
[test]
|
|
uniform 0 float 1.0
|
|
uniform 4 float 2.0
|
|
uniform 8 float 3.0
|
|
uniform 12 float 4.0
|
|
uniform 16 uint4 3 1 0 2
|
|
uniform 20 uint4 0 3 1 2
|
|
todo(glsl) draw quad
|
|
if(sm<4) probe (0,0) rgba (1.0, 1.0, 1.0, 1.0)
|
|
if(sm>=4 & sm<6) todo probe (0,0) rgba (4.0, 4.0, 4.0, 4.0)
|
|
if(sm>=6) probe (0,0) rgba (4.0, 3.0, 2.0, 1.0)
|