mirror of
https://gitlab.winehq.org/wine/vkd3d.git
synced 2025-09-12 18:50:22 -07:00
51f13391e6
The structurizer is implemented along the lines of what is usually called the "structured program theorem": the control flow is completely virtualized by mean of an additional TEMP register which stores the block index which is currently running. The whole program is then converted to a huge switch construction enclosed in a loop, executing at each iteration the appropriate block and updating the register depending on block jump instruction. The algorithm's generality is also its major weakness: it accepts any input program, even if its CFG is not reducible, but the output program lacks any useful convergence information. It satisfies the letter of the SPIR-V requirements, but it is expected that it will be very inefficient to run on a GPU (unless a downstream compiler is able to devirtualize the control flow and do a proper convergence analysis pass). The algorithm is however very simple, and good enough to at least pass tests, enabling further development. A better alternative is expected to be upstreamed incrementally. Side note: the structured program theorem is often called the Böhm-Jacopini theorem; Böhm and Jacopini did indeed prove a variation of it, but their algorithm is different from what is commontly attributed to them and implemented here, so I opted for not using their name.
110 lines
2.0 KiB
Plaintext
110 lines
2.0 KiB
Plaintext
[pixel shader todo(sm<4)]
|
|
uniform float4 u;
|
|
|
|
float4 main() : sv_target
|
|
{
|
|
if (u.x > 0.0)
|
|
return float4(0.1, 0.2, 0.3, 0.4);
|
|
else
|
|
return float4(0.9, 0.8, 0.7, 0.6);
|
|
}
|
|
|
|
[test]
|
|
uniform 0 float4 0.0 0.0 0.0 0.0
|
|
todo(sm<4) 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<4) draw quad
|
|
probe all rgba (0.1, 0.2, 0.3, 0.4)
|
|
|
|
[pixel shader todo(sm<4)]
|
|
uniform float4 u;
|
|
|
|
float4 main() : sv_target
|
|
{
|
|
[attr1]
|
|
if (u.x > 0.0)
|
|
return float4(0.1, 0.2, 0.3, 0.4);
|
|
else
|
|
return float4(0.9, 0.8, 0.7, 0.6);
|
|
}
|
|
|
|
[pixel shader todo(sm<4)]
|
|
uniform float4 u;
|
|
|
|
float4 main() : sv_target
|
|
{
|
|
[flatten]
|
|
if (u.x > 0.0)
|
|
return float4(0.1, 0.2, 0.3, 0.4);
|
|
else
|
|
return float4(0.9, 0.8, 0.7, 0.6);
|
|
}
|
|
|
|
[test]
|
|
uniform 0 float4 0.0 0.0 0.0 0.0
|
|
todo(sm<4) draw quad
|
|
probe all rgba (0.9, 0.8, 0.7, 0.6)
|
|
|
|
[pixel shader fail(sm<6)]
|
|
float4 u;
|
|
|
|
float main() : sv_target
|
|
{
|
|
[branch] [branch]
|
|
if (u.x > 0.0)
|
|
return float4(0.1, 0.2, 0.3, 0.4);
|
|
else
|
|
return float4(0.9, 0.8, 0.7, 0.6);
|
|
}
|
|
|
|
[pixel shader fail todo]
|
|
float4 u;
|
|
|
|
float main() : sv_target
|
|
{
|
|
[branch] [flatten]
|
|
if (u.x > 0.0)
|
|
return float4(0.1, 0.2, 0.3, 0.4);
|
|
else
|
|
return float4(0.9, 0.8, 0.7, 0.6);
|
|
}
|
|
|
|
% Using older profiles fails to compile with forced control flow instruction
|
|
[require]
|
|
shader model >= 3.0
|
|
|
|
[pixel shader todo(sm<4)]
|
|
uniform float4 u;
|
|
|
|
float4 main() : sv_target
|
|
{
|
|
[branch]
|
|
if (u.x > 0.0)
|
|
return float4(0.1, 0.2, 0.3, 0.4);
|
|
else
|
|
return float4(0.9, 0.8, 0.7, 0.6);
|
|
}
|
|
|
|
[test]
|
|
uniform 0 float4 0.0 0.0 0.0 0.0
|
|
todo(sm<4) draw quad
|
|
probe all rgba (0.9, 0.8, 0.7, 0.6)
|
|
|
|
[pixel shader]
|
|
float4 main() : sv_target
|
|
{
|
|
bool c = false;
|
|
float a = -1.0f;
|
|
if (c)
|
|
return float4(1.0, 2.0, 3.0, 4.0);
|
|
else if (a > 0)
|
|
return float4(5.0, 6.0, 7.0, 8.0);
|
|
else
|
|
return float4(9.0, 10.0, 11.0, 12.0);
|
|
}
|
|
|
|
[test]
|
|
draw quad
|
|
probe all rgba (9.0, 10.0, 11.0, 12.0)
|