| # encoding=utf-8 |
| # Copyright © 2019 Google |
| |
| # Permission is hereby granted, free of charge, to any person obtaining a copy |
| # of this software and associated documentation files (the "Software"), to deal |
| # in the Software without restriction, including without limitation the rights |
| # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
| # copies of the Software, and to permit persons to whom the Software is |
| # furnished to do so, subject to the following conditions: |
| |
| # The above copyright notice and this permission notice shall be included in |
| # all copies or substantial portions of the Software. |
| |
| # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
| # SOFTWARE. |
| |
| import sys |
| import subprocess |
| import tempfile |
| import re |
| from collections import namedtuple |
| |
| |
| Test = namedtuple("Test", "name source match_re") |
| |
| # NOTE: This test is deprecated, please add any new tests to test_gl_lower_mediump.cpp. |
| |
| TESTS = [ |
| Test("f32 array-of-array with const index", |
| """ |
| #version 310 es |
| precision mediump float; |
| |
| uniform float in_aoa[2][2]; |
| |
| layout(location = 0) out float out_color; |
| |
| void main() |
| { |
| out_color = in_aoa[0][0] / in_aoa[1][1]; |
| } |
| """, |
| r'\(expression +float16_t +/'), |
| Test("i32 array-of-array with const index", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| uniform int in_aoa[2][2]; |
| |
| layout(location = 0) out highp int out_color; |
| |
| void main() |
| { |
| out_color = in_aoa[0][0] / in_aoa[1][1]; |
| } |
| """, |
| r'\(expression +int16_t +/'), |
| Test("u32 array-of-array with const index", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| uniform uint in_aoa[2][2]; |
| |
| layout(location = 0) out highp uint out_color; |
| |
| void main() |
| { |
| out_color = in_aoa[0][0] / in_aoa[1][1]; |
| } |
| """, |
| r'\(expression +uint16_t +/'), |
| Test("f32 array-of-array with uniform index", |
| """ |
| #version 310 es |
| precision mediump float; |
| |
| uniform float in_aoa[2][2]; |
| uniform int i0, i1; |
| |
| layout(location = 0) out float out_color; |
| |
| void main() |
| { |
| out_color = in_aoa[i0][i0] / in_aoa[i1][i1]; |
| } |
| """, |
| r'\(expression +float16_t +/'), |
| Test("i32 array-of-array with uniform index", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| uniform int in_aoa[2][2]; |
| uniform int i0, i1; |
| |
| layout(location = 0) out highp int out_color; |
| |
| void main() |
| { |
| out_color = in_aoa[i0][i0] / in_aoa[i1][i1]; |
| } |
| """, |
| r'\(expression +int16_t +/'), |
| Test("u32 array-of-array with uniform index", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| uniform uint in_aoa[2][2]; |
| uniform int i0, i1; |
| |
| layout(location = 0) out highp uint out_color; |
| |
| void main() |
| { |
| out_color = in_aoa[i0][i0] / in_aoa[i1][i1]; |
| } |
| """, |
| r'\(expression +uint16_t +/'), |
| Test("f32 function", |
| """ |
| precision mediump float; |
| |
| uniform float a, b; |
| |
| mediump float |
| get_a() |
| { |
| return a; |
| } |
| |
| float |
| get_b() |
| { |
| return b; |
| } |
| |
| void main() |
| { |
| gl_FragColor = vec4(get_a() / get_b()); |
| } |
| """, |
| r'\(expression +float16_t +/'), |
| Test("i32 function", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| uniform int a, b; |
| |
| mediump int |
| get_a() |
| { |
| return a; |
| } |
| |
| int |
| get_b() |
| { |
| return b; |
| } |
| |
| out highp int color; |
| |
| void main() |
| { |
| color = get_a() / get_b(); |
| } |
| """, |
| r'\(expression +int16_t +/'), |
| Test("u32 function", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| uniform uint a, b; |
| |
| mediump uint |
| get_a() |
| { |
| return a; |
| } |
| |
| uint |
| get_b() |
| { |
| return b; |
| } |
| |
| out highp uint color; |
| |
| void main() |
| { |
| color = get_a() / get_b(); |
| } |
| """, |
| r'\(expression +uint16_t +/'), |
| Test("f32 function mediump args", |
| """ |
| precision mediump float; |
| |
| uniform float a, b; |
| |
| mediump float |
| do_div(float x, float y) |
| { |
| return x / y; |
| } |
| |
| void main() |
| { |
| gl_FragColor = vec4(do_div(a, b)); |
| } |
| """, |
| r'\(expression +float16_t +/'), |
| Test("i32 function mediump args", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| uniform int a, b; |
| |
| mediump int |
| do_div(int x, int y) |
| { |
| return x / y; |
| } |
| |
| out highp int color; |
| |
| void main() |
| { |
| color = do_div(a, b); |
| } |
| """, |
| r'\(expression +int16_t +/'), |
| Test("u32 function mediump args", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| uniform uint a, b; |
| |
| mediump uint |
| do_div(uint x, uint y) |
| { |
| return x / y; |
| } |
| |
| out highp uint color; |
| |
| void main() |
| { |
| color = do_div(a, b); |
| } |
| """, |
| r'\(expression +uint16_t +/'), |
| Test("f32 function highp args", |
| """ |
| precision mediump float; |
| |
| uniform float a, b; |
| |
| mediump float |
| do_div(highp float x, highp float y) |
| { |
| return x / y; |
| } |
| |
| void main() |
| { |
| gl_FragColor = vec4(do_div(a, b)); |
| } |
| """, |
| r'\(expression +float +/'), |
| Test("i32 function highp args", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| uniform int a, b; |
| |
| mediump int |
| do_div(highp int x, highp int y) |
| { |
| return x / y; |
| } |
| |
| out highp int color; |
| |
| void main() |
| { |
| color = do_div(a, b); |
| } |
| """, |
| r'\(expression +int +/'), |
| Test("u32 function highp args", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| uniform uint a, b; |
| |
| mediump uint |
| do_div(highp uint x, highp uint y) |
| { |
| return x / y; |
| } |
| |
| out highp uint color; |
| |
| void main() |
| { |
| color = do_div(a, b); |
| } |
| """, |
| r'\(expression +uint +/'), |
| |
| Test("f32 if", |
| """ |
| precision mediump float; |
| |
| uniform float a, b; |
| |
| void |
| main() |
| { |
| if (a / b < 0.31) |
| gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0); |
| else |
| gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); |
| } |
| """, |
| r'\(expression +float16_t +/'), |
| Test("i32 if", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| uniform int a, b; |
| |
| out vec4 color; |
| |
| void |
| main() |
| { |
| if (a / b < 10) |
| color = vec4(0.0, 1.0, 0.0, 1.0); |
| else |
| color = vec4(1.0, 0.0, 0.0, 1.0); |
| } |
| """, |
| r'\(expression +int16_t +/'), |
| Test("u32 if", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| uniform uint a, b; |
| |
| out vec4 color; |
| |
| void |
| main() |
| { |
| if (a / b < 10u) |
| color = vec4(0.0, 1.0, 0.0, 1.0); |
| else |
| color = vec4(1.0, 0.0, 0.0, 1.0); |
| } |
| """, |
| r'\(expression +uint16_t +/'), |
| Test("matrix", |
| """ |
| precision mediump float; |
| |
| uniform vec2 a; |
| uniform mat2 b; |
| |
| void main() |
| { |
| gl_FragColor = vec4(b * a, 0.0, 0.0); |
| } |
| """, |
| r'\(expression f16vec2 \+ \(expression f16vec2 \* \(array_ref \(var_ref b\) \(constant int \(0\)\) \) \(swiz x \(var_ref a\) \)\) \(expression f16vec2 \* \(array_ref \(var_ref b\) \(constant int \(1\)\) \) \(swiz y \(var_ref a\) \)\) \) \)'), |
| Test("f32 simple struct deref", |
| """ |
| precision mediump float; |
| |
| struct simple { |
| float a, b; |
| }; |
| |
| uniform simple in_simple; |
| |
| void main() |
| { |
| gl_FragColor = vec4(in_simple.a / in_simple.b); |
| } |
| """, |
| r'\(expression +float16_t +/'), |
| Test("i32 simple struct deref", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| struct simple { |
| int a, b; |
| }; |
| |
| uniform simple in_simple; |
| |
| out highp int color; |
| |
| void main() |
| { |
| color = in_simple.a / in_simple.b; |
| } |
| """, |
| r'\(expression +int16_t +/'), |
| Test("u32 simple struct deref", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| struct simple { |
| uint a, b; |
| }; |
| |
| uniform simple in_simple; |
| |
| out highp uint color; |
| |
| void main() |
| { |
| color = in_simple.a / in_simple.b; |
| } |
| """, |
| r'\(expression +uint16_t +/'), |
| Test("f32 embedded struct deref", |
| """ |
| precision mediump float; |
| |
| struct simple { |
| float a, b; |
| }; |
| |
| struct embedded { |
| simple a, b; |
| }; |
| |
| uniform embedded in_embedded; |
| |
| void main() |
| { |
| gl_FragColor = vec4(in_embedded.a.a / in_embedded.b.b); |
| } |
| """, |
| r'\(expression +float16_t +/'), |
| Test("i32 embedded struct deref", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| struct simple { |
| int a, b; |
| }; |
| |
| struct embedded { |
| simple a, b; |
| }; |
| |
| uniform embedded in_embedded; |
| |
| out highp int color; |
| |
| void main() |
| { |
| color = in_embedded.a.a / in_embedded.b.b; |
| } |
| """, |
| r'\(expression +int16_t +/'), |
| Test("u32 embedded struct deref", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| struct simple { |
| uint a, b; |
| }; |
| |
| struct embedded { |
| simple a, b; |
| }; |
| |
| uniform embedded in_embedded; |
| |
| out highp uint color; |
| |
| void main() |
| { |
| color = in_embedded.a.a / in_embedded.b.b; |
| } |
| """, |
| r'\(expression +uint16_t +/'), |
| Test("f32 arrayed struct deref", |
| """ |
| precision mediump float; |
| |
| struct simple { |
| float a, b; |
| }; |
| |
| struct arrayed { |
| simple a[2]; |
| }; |
| |
| uniform arrayed in_arrayed; |
| |
| void main() |
| { |
| gl_FragColor = vec4(in_arrayed.a[0].a / in_arrayed.a[1].b); |
| } |
| """, |
| r'\(expression +float16_t +/'), |
| Test("i32 arrayed struct deref", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| struct simple { |
| int a, b; |
| }; |
| |
| struct arrayed { |
| simple a[2]; |
| }; |
| |
| uniform arrayed in_arrayed; |
| |
| out highp int color; |
| |
| void main() |
| { |
| color = in_arrayed.a[0].a / in_arrayed.a[1].b; |
| } |
| """, |
| r'\(expression +int16_t +/'), |
| Test("u32 arrayed struct deref", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| struct simple { |
| uint a, b; |
| }; |
| |
| struct arrayed { |
| simple a[2]; |
| }; |
| |
| uniform arrayed in_arrayed; |
| |
| out highp uint color; |
| |
| void main() |
| { |
| color = in_arrayed.a[0].a / in_arrayed.a[1].b; |
| } |
| """, |
| r'\(expression +uint16_t +/'), |
| Test("f32 mixed precision not lowered", |
| """ |
| uniform mediump float a; |
| uniform highp float b; |
| |
| void main() |
| { |
| gl_FragColor = vec4(a / b); |
| } |
| """, |
| r'\(expression +float +/'), |
| Test("i32 mixed precision not lowered", |
| """ |
| #version 310 es |
| uniform mediump int a; |
| uniform highp int b; |
| |
| out mediump int color; |
| |
| void main() |
| { |
| color = a / b; |
| } |
| """, |
| r'\(expression +int +/'), |
| Test("u32 mixed precision not lowered", |
| """ |
| #version 310 es |
| uniform mediump uint a; |
| uniform highp uint b; |
| |
| out mediump uint color; |
| |
| void main() |
| { |
| color = a / b; |
| } |
| """, |
| r'\(expression +uint +/'), |
| Test("f32 sampler array", |
| """ |
| #version 320 es |
| precision mediump float; |
| precision mediump int; |
| |
| uniform sampler2D tex[2]; |
| // highp shouldn't affect the return value of texture2D |
| uniform highp vec2 coord; |
| uniform float divisor; |
| uniform int index; |
| |
| out highp vec4 color; |
| |
| void main() |
| { |
| color = texture2D(tex[index], coord) / divisor; |
| } |
| """, |
| r'\(expression +f16vec4 +/.*\(tex +f16vec4 +'), |
| Test("f32 texture sample", |
| """ |
| precision mediump float; |
| |
| uniform sampler2D tex; |
| // highp shouldn't affect the return value of texture2D |
| uniform highp vec2 coord; |
| uniform float divisor; |
| |
| void main() |
| { |
| gl_FragColor = texture2D(tex, coord) / divisor; |
| } |
| """, |
| r'\(expression +f16vec4 +/.*\(tex +f16vec4 +'), |
| Test("i32 texture sample", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| uniform mediump isampler2D tex; |
| // highp shouldn't affect the return value of texture |
| uniform highp vec2 coord; |
| uniform int divisor; |
| |
| out highp ivec4 color; |
| |
| void main() |
| { |
| color = texture(tex, coord) / divisor; |
| } |
| """, |
| r'\(expression +i16vec4 +/.*\(tex +i16vec4 +'), |
| Test("u32 texture sample", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| uniform mediump usampler2D tex; |
| // highp shouldn't affect the return value of texture |
| uniform highp vec2 coord; |
| uniform uint divisor; |
| |
| out highp uvec4 color; |
| |
| void main() |
| { |
| color = texture(tex, coord) / divisor; |
| } |
| """, |
| r'\(expression +u16vec4 +/.*\(tex +u16vec4 +'), |
| Test("f32 image array", |
| """ |
| #version 320 es |
| precision mediump float; |
| |
| layout(rgba16f) readonly uniform mediump image2D img[2]; |
| // highp shouldn't affect the return value of imageLoad |
| uniform highp ivec2 coord; |
| uniform float divisor; |
| |
| out highp vec4 color; |
| |
| void main() |
| { |
| color = imageLoad(img[1], coord) / divisor; |
| } |
| """, |
| r'\(expression +f16vec4 +/'), |
| Test("f32 image load", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| layout(rgba16f) readonly uniform mediump image2D img; |
| // highp shouldn't affect the return value of imageLoad |
| uniform highp ivec2 coord; |
| uniform float divisor; |
| |
| out highp vec4 color; |
| |
| void main() |
| { |
| color = imageLoad(img, coord) / divisor; |
| } |
| """, |
| r'\(expression +f16vec4 +/'), |
| Test("i32 image load", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| layout(rgba16i) readonly uniform mediump iimage2D img; |
| // highp shouldn't affect the return value of imageLoad |
| uniform highp ivec2 coord; |
| uniform int divisor; |
| |
| out highp ivec4 color; |
| |
| void main() |
| { |
| color = imageLoad(img, coord) / divisor; |
| } |
| """, |
| r'\(expression +i16vec4 +/'), |
| Test("u32 image load", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| layout(rgba16ui) readonly uniform mediump uimage2D img; |
| // highp shouldn't affect the return value of imageLoad |
| uniform highp ivec2 coord; |
| uniform uint divisor; |
| |
| out highp uvec4 color; |
| |
| void main() |
| { |
| color = imageLoad(img, coord) / divisor; |
| } |
| """, |
| r'\(expression +u16vec4 +/'), |
| Test("f32 expression in lvalue", |
| """ |
| uniform mediump float a, b; |
| |
| void main() |
| { |
| gl_FragColor = vec4(1.0); |
| gl_FragColor[int(a / b)] = 0.5; |
| } |
| """, |
| r'\(expression +float16_t +/'), |
| Test("i32 expression in lvalue", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| uniform mediump int a, b; |
| |
| out vec4 color; |
| |
| void main() |
| { |
| color = vec4(1.0); |
| color[a / b] = 0.5; |
| } |
| """, |
| r'\(expression +int16_t +/'), |
| Test("f32 builtin with const arg", |
| """ |
| uniform mediump float a; |
| |
| void main() |
| { |
| gl_FragColor = vec4(min(a, 3.0)); |
| } |
| """, |
| r'\(expression +float16_t min'), |
| Test("i32 builtin with const arg", |
| """ |
| #version 310 es |
| uniform mediump int a; |
| |
| out highp int color; |
| |
| void main() |
| { |
| color = min(a, 3); |
| } |
| """, |
| r'\(expression +int16_t min'), |
| Test("u32 builtin with const arg", |
| """ |
| #version 310 es |
| uniform mediump uint a; |
| |
| out highp uint color; |
| |
| void main() |
| { |
| color = min(a, 3u); |
| } |
| """, |
| r'\(expression +uint16_t min'), |
| Test("dFdx", |
| """ |
| #version 300 es |
| precision mediump float; |
| |
| in vec4 var; |
| out vec4 color; |
| |
| void main() |
| { |
| color = dFdx(var); |
| } |
| """, |
| r'\(expression +f16vec4 +dFdx +\(expression +f16vec4'), |
| Test("dFdy", |
| """ |
| #version 300 es |
| precision mediump float; |
| |
| in vec4 var; |
| out vec4 color; |
| |
| void main() |
| { |
| color = dFdy(var); |
| } |
| """, |
| r'\(expression +f16vec4 +dFdy +\(expression +f16vec4'), |
| Test("textureSize", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| uniform mediump sampler2D tex; |
| out ivec2 color; |
| |
| void main() |
| { |
| color = textureSize(tex, 0) * ivec2(2); |
| } |
| """, |
| r'expression ivec2 \* \(txs ivec2 \(var_ref tex'), |
| Test("floatBitsToInt", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| uniform float val; |
| out int color; |
| |
| void main() |
| { |
| color = floatBitsToInt(val + 1.0) + 1; |
| } |
| """, |
| r'expression int bitcast_f2i \(expression float'), |
| Test("floatBitsToUint", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| uniform float val; |
| out uint color; |
| |
| void main() |
| { |
| color = floatBitsToUint(val + 1.0) + 1u; |
| } |
| """, |
| r'expression uint bitcast_f2u \(expression float'), |
| Test("intBitsToFloat", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| uniform int val; |
| out float color; |
| |
| void main() |
| { |
| color = intBitsToFloat(val + 1) + 1.0; |
| } |
| """, |
| r'expression float bitcast_i2f \(expression int'), |
| Test("uintBitsToFloat", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| uniform uint val; |
| out float color; |
| |
| void main() |
| { |
| color = uintBitsToFloat(val + 1u) + 1.0; |
| } |
| """, |
| r'expression float bitcast_u2f \(expression uint'), |
| Test("bitfieldReverse", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| uniform int val; |
| out int color; |
| |
| void main() |
| { |
| color = bitfieldReverse(val + 1) + 1; |
| } |
| """, |
| r'expression int bitfield_reverse \(expression int'), |
| Test("frexp", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| uniform float val; |
| out float color; |
| out int color2; |
| |
| void main() |
| { |
| int y; |
| float x = frexp(val + 1.0, y); |
| color = x + 1.0; |
| color2 = y + 1; |
| } |
| """, |
| r'expression int16_t i2imp \(expression int frexp_exp \(expression float f162f'), |
| Test("ldexp", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| uniform float val; |
| uniform int exp; |
| out float color; |
| |
| void main() |
| { |
| color = ldexp(val + 1.0, exp + 1) + 1.0; |
| } |
| """, |
| r'expression float ldexp \(expression float'), |
| Test("uaddCarry", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| uniform uint x, y; |
| out uint color; |
| |
| void main() |
| { |
| lowp uint carry; |
| color = uaddCarry(x * 2u, y * 2u, carry) * 2u; |
| color *= carry; |
| } |
| """, |
| r'expression uint \+ \(expression uint u2u \(expression uint16_t \* \(expression uint16_t u2ump \(var_ref x\) \) \(constant uint16_t \(2\)\) \) \) \(expression uint u2u \(expression uint16_t \* \(expression uint16_t u2ump \(var_ref y'), |
| Test("usubBorrow", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| uniform uint x, y; |
| out uint color; |
| |
| void main() |
| { |
| lowp uint borrow; |
| color = usubBorrow(x * 2u, y * 2u, borrow) * 2u; |
| color *= borrow; |
| } |
| """, |
| r'expression uint \- \(expression uint u2u \(expression uint16_t \* \(expression uint16_t u2ump \(var_ref x\) \) \(constant uint16_t \(2\)\) \) \) \(expression uint u2u \(expression uint16_t \* \(expression uint16_t u2ump \(var_ref y'), |
| Test("imulExtended", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| uniform int x, y; |
| out int color; |
| |
| void main() |
| { |
| int msb, lsb; |
| imulExtended(x + 2, y + 2, msb, lsb); |
| color = msb + lsb; |
| } |
| """, |
| r'expression int64_t \* \(expression int'), |
| Test("umulExtended", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| uniform uint x, y; |
| out uint color; |
| |
| void main() |
| { |
| uint msb, lsb; |
| umulExtended(x + 2u, y + 2u, msb, lsb); |
| color = msb + lsb; |
| } |
| """, |
| r'expression uint64_t \* \(expression uint'), |
| Test("unpackUnorm2x16", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| uniform uint val; |
| out vec2 color; |
| |
| void main() |
| { |
| color = unpackUnorm2x16(val + 1u) + vec2(1.0); |
| } |
| """, |
| r'expression vec2 unpackUnorm2x16 \(expression uint'), |
| Test("unpackSnorm2x16", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| uniform uint val; |
| out vec2 color; |
| |
| void main() |
| { |
| color = unpackSnorm2x16(val + 1u) + vec2(1.0); |
| } |
| """, |
| r'expression vec2 unpackSnorm2x16 \(expression uint'), |
| Test("packUnorm2x16", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| uniform vec2 val; |
| out uint color; |
| |
| void main() |
| { |
| color = packUnorm2x16(val + vec2(1.0)) + 1u; |
| } |
| """, |
| r'expression uint packUnorm2x16 \(expression vec2'), |
| Test("packSnorm2x16", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| uniform vec2 val; |
| out uint color; |
| |
| void main() |
| { |
| color = packSnorm2x16(val + vec2(1.0)) + 1u; |
| } |
| """, |
| r'expression uint packSnorm2x16 \(expression vec2'), |
| Test("packHalf2x16", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| uniform vec2 val; |
| out uint color; |
| |
| void main() |
| { |
| color = packHalf2x16(val + vec2(1.0)) + 1u; |
| } |
| """, |
| r'expression uint packHalf2x16 \(expression vec2'), |
| Test("packUnorm4x8", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| uniform vec4 val; |
| out uint color; |
| |
| void main() |
| { |
| color = packUnorm4x8(val + vec4(1.0)) + 1u; |
| } |
| """, |
| r'expression uint packUnorm4x8 \(expression vec4'), |
| Test("packSnorm4x8", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| uniform vec4 val; |
| out uint color; |
| |
| void main() |
| { |
| color = packSnorm4x8(val + vec4(1.0)) + 1u; |
| } |
| """, |
| r'expression uint packSnorm4x8 \(expression vec4'), |
| Test("interpolateAtCentroid", |
| """ |
| #version 320 es |
| precision mediump float; |
| precision mediump int; |
| |
| in float val; |
| out float color; |
| |
| void main() |
| { |
| color = interpolateAtCentroid(val) + 1.0; |
| } |
| """, |
| r'expression float16_t interpolate_at_centroid \(expression float16_t'), |
| Test("interpolateAtOffset", |
| """ |
| #version 320 es |
| precision mediump float; |
| precision mediump int; |
| |
| uniform highp vec2 offset; |
| in float val; |
| out float color; |
| |
| void main() |
| { |
| color = interpolateAtOffset(val, offset) + 1.0; |
| } |
| """, |
| r'expression float16_t interpolate_at_offset \(expression float16_t'), |
| Test("interpolateAtSample", |
| """ |
| #version 320 es |
| precision mediump float; |
| precision mediump int; |
| |
| uniform highp int sample_index; |
| in float val; |
| out float color; |
| |
| void main() |
| { |
| color = interpolateAtSample(val, sample_index) + 1.0; |
| } |
| """, |
| r'expression float16_t interpolate_at_sample \(expression float16_t'), |
| Test("bitfieldExtract", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| uniform highp int offset, bits; |
| uniform int val; |
| out int color; |
| |
| void main() |
| { |
| color = bitfieldExtract(val, offset, bits) + 1; |
| } |
| """, |
| r'expression int16_t bitfield_extract \(expression int16_t'), |
| Test("bitfieldInsert", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| uniform highp int offset, bits; |
| uniform int val, val2; |
| out int color; |
| |
| void main() |
| { |
| color = bitfieldInsert(val, val2, offset, bits) + 1; |
| } |
| """, |
| r'expression int16_t bitfield_insert \(expression int16_t'), |
| Test("bitCount", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| uniform highp int val; |
| out int color; |
| |
| void main() |
| { |
| color = bitCount(val) + 1; |
| } |
| """, |
| r'expression int16_t \+ \(expression int16_t i2imp \(expression int bit_count \(var_ref val'), |
| Test("findLSB", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| uniform highp int val; |
| out int color; |
| |
| void main() |
| { |
| color = findLSB(val) + 1; |
| } |
| """, |
| r'expression int16_t \+ \(expression int16_t i2imp \(expression int find_lsb \(var_ref val'), |
| Test("findMSB", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| uniform highp int val; |
| out int color; |
| |
| void main() |
| { |
| color = findMSB(val) + 1; |
| } |
| """, |
| r'expression int16_t \+ \(expression int16_t i2imp \(expression int find_msb \(var_ref val'), |
| Test("unpackHalf2x16", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| uniform highp uint val; |
| out vec2 color; |
| |
| void main() |
| { |
| color = unpackHalf2x16(val) + vec2(1.0); |
| } |
| """, |
| r'expression f16vec2 \+ \(expression f16vec2 f2fmp \(expression vec2 unpackHalf2x16 \(var_ref val'), |
| Test("unpackUnorm4x8", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| uniform highp uint val; |
| out vec4 color; |
| |
| void main() |
| { |
| color = unpackUnorm4x8(val) + vec4(1.0); |
| } |
| """, |
| r'expression f16vec4 \+ \(expression f16vec4 f2fmp \(expression vec4 unpackUnorm4x8 \(var_ref val'), |
| Test("unpackSnorm4x8", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| uniform highp uint val; |
| out vec4 color; |
| |
| void main() |
| { |
| color = unpackSnorm4x8(val) + vec4(1.0); |
| } |
| """, |
| r'expression f16vec4 \+ \(expression f16vec4 f2fmp \(expression vec4 unpackSnorm4x8 \(var_ref val'), |
| Test("f32 csel", |
| """ |
| #version 300 es |
| precision mediump float; |
| |
| in vec4 var; |
| out vec4 color; |
| |
| void main() |
| { |
| color = (var.x > var.y) ? var : vec4(10.0); |
| } |
| """, |
| r'\(expression f16vec4 f2fmp \(constant vec4 \(10'), |
| Test("i32 csel", |
| """ |
| #version 310 es |
| precision mediump int; |
| |
| in flat ivec4 var; |
| out ivec4 color; |
| |
| void main() |
| { |
| color = (var.x > var.y) ? var : ivec4(10); |
| } |
| """, |
| r'\(expression i16vec4 i2imp \(constant ivec4 \(10'), |
| Test("u32 csel", |
| """ |
| #version 310 es |
| precision mediump int; |
| |
| in flat uvec4 var; |
| out uvec4 color; |
| |
| void main() |
| { |
| color = (var.x > var.y) ? var : uvec4(10); |
| } |
| """, |
| r'\(expression u16vec4 u2ump \(constant uvec4 \(10'), |
| Test("f32 loop counter", |
| """ |
| #version 300 es |
| precision mediump float; |
| |
| uniform float n, incr; |
| out float color; |
| |
| void main() |
| { |
| color = 0.0; |
| for (float x = 0.0; x < n; x += incr) |
| color += x; |
| } |
| """, |
| r'\(assign \(x\) \(var_ref x\) \(expression float16_t \+ \(var_ref x\) \(var_ref incr'), |
| Test("i32 loop counter", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| uniform int n, incr; |
| out int color; |
| |
| void main() |
| { |
| color = 0; |
| for (int x = 0; x < n; x += incr) |
| color += x; |
| } |
| """, |
| r'\(assign \(x\) \(var_ref x\) \(expression int16_t \+ \(var_ref x\) \(expression int16_t i2imp \(var_ref incr'), |
| Test("u32 loop counter", |
| """ |
| #version 310 es |
| precision mediump float; |
| precision mediump int; |
| |
| uniform uint n, incr; |
| out uint color; |
| |
| void main() |
| { |
| color = 0u; |
| for (uint x = 0u; x < n; x += incr) |
| color += x; |
| } |
| """, |
| r'\(assign \(x\) \(var_ref x\) \(expression uint16_t \+ \(var_ref x\) \(expression uint16_t u2ump \(var_ref incr'), |
| Test("f32 temp array", |
| """ |
| #version 300 es |
| precision mediump float; |
| |
| uniform float x,y; |
| out float color; |
| |
| void main() |
| { |
| float a[2] = float[2](x, y); |
| if (x > 0.0) |
| a[1] = 3.0; |
| color = a[0] + a[1]; |
| } |
| """, |
| r'\(expression float16_t f2fmp \(constant float \(3'), |
| Test("i32 temp array", |
| """ |
| #version 310 es |
| precision mediump int; |
| |
| uniform int x,y; |
| out int color; |
| |
| void main() |
| { |
| int a[2] = int[2](x, y); |
| if (x > 0) |
| a[1] = 3; |
| color = a[0] + a[1]; |
| } |
| """, |
| r'\(expression int16_t i2imp \(constant int \(3'), |
| Test("u32 temp array", |
| """ |
| #version 310 es |
| precision mediump int; |
| |
| uniform uint x,y; |
| out uint color; |
| |
| void main() |
| { |
| uint a[2] = uint[2](x, y); |
| if (x > 0u) |
| a[1] = 3u; |
| color = a[0] + a[1]; |
| } |
| """, |
| r'\(expression uint16_t u2ump \(constant uint \(3'), |
| Test("f32 temp array of array", |
| """ |
| #version 310 es |
| precision mediump float; |
| |
| uniform float x,y; |
| out float color; |
| |
| void main() |
| { |
| float a[2][2] = float[2][2](float[2](x, y), float[2](x, y)); |
| if (x > 0.0) |
| a[1][1] = 3.0; |
| color = a[0][0] + a[1][1]; |
| } |
| """, |
| r'\(expression float16_t f2fmp \(constant float \(3'), |
| Test("i32 temp array of array", |
| """ |
| #version 310 es |
| precision mediump int; |
| |
| uniform int x,y; |
| out int color; |
| |
| void main() |
| { |
| int a[2][2] = int[2][2](int[2](x, y), int[2](x, y)); |
| if (x > 0) |
| a[1][1] = 3; |
| color = a[0][0] + a[1][1]; |
| } |
| """, |
| r'\(expression int16_t i2imp \(constant int \(3'), |
| Test("u32 temp array of array", |
| """ |
| #version 310 es |
| precision mediump int; |
| |
| uniform uint x,y; |
| out uint color; |
| |
| void main() |
| { |
| uint a[2][2] = uint[2][2](uint[2](x, y), uint[2](x, y)); |
| if (x > 0u) |
| a[1][1] = 3u; |
| color = a[0][0] + a[1][1]; |
| } |
| """, |
| r'\(expression uint16_t u2ump \(constant uint \(3'), |
| Test("f32 temp array of array assigned from highp", |
| """ |
| #version 310 es |
| precision mediump float; |
| |
| uniform float x,y; |
| out float color; |
| |
| void main() |
| { |
| highp float b[2][2] = float[2][2](float[2](x, y), float[2](x, y)); |
| float a[2][2]; |
| a = b; |
| if (x > 0.0) |
| a[1][1] = 3.0; |
| color = a[0][0] + a[1][1]; |
| } |
| """, |
| r'\(expression float16_t f2fmp \(constant float \(3'), |
| Test("i32 temp array of array assigned from highp", |
| """ |
| #version 310 es |
| precision mediump int; |
| |
| uniform int x,y; |
| out int color; |
| |
| void main() |
| { |
| highp int b[2][2] = int[2][2](int[2](x, y), int[2](x, y)); |
| int a[2][2]; |
| a = b; |
| if (x > 0) |
| a[1][1] = 3; |
| color = a[0][0] + a[1][1]; |
| } |
| """, |
| r'\(expression int16_t i2imp \(constant int \(3'), |
| Test("u32 temp array of array assigned from highp", |
| """ |
| #version 310 es |
| precision mediump int; |
| |
| uniform uint x,y; |
| out uint color; |
| |
| void main() |
| { |
| highp uint b[2][2] = uint[2][2](uint[2](x, y), uint[2](x, y)); |
| uint a[2][2]; |
| a = b; |
| if (x > 0u) |
| a[1][1] = 3u; |
| color = a[0][0] + a[1][1]; |
| } |
| """, |
| r'\(expression uint16_t u2ump \(constant uint \(3'), |
| Test("f32 temp array of array assigned to highp", |
| """ |
| #version 310 es |
| precision mediump float; |
| |
| uniform float x,y; |
| out float color; |
| |
| void main() |
| { |
| float a[2][2] = float[2][2](float[2](x, y), float[2](x, y)); |
| highp float b[2][2]; |
| b = a; |
| a = b; |
| if (x > 0.0) |
| a[1][1] = 3.0; |
| color = a[0][0] + a[1][1]; |
| } |
| """, |
| r'\(expression float16_t f2fmp \(constant float \(3'), |
| Test("i32 temp array of array assigned to highp", |
| """ |
| #version 310 es |
| precision mediump int; |
| |
| uniform int x,y; |
| out int color; |
| |
| void main() |
| { |
| int a[2][2] = int[2][2](int[2](x, y), int[2](x, y)); |
| highp int b[2][2]; |
| b = a; |
| a = b; |
| if (x > 0) |
| a[1][1] = 3; |
| color = a[0][0] + a[1][1]; |
| } |
| """, |
| r'\(expression int16_t i2imp \(constant int \(3'), |
| Test("u32 temp array of array assigned to highp", |
| """ |
| #version 310 es |
| precision mediump int; |
| |
| uniform uint x,y; |
| out uint color; |
| |
| void main() |
| { |
| uint a[2][2] = uint[2][2](uint[2](x, y), uint[2](x, y)); |
| highp uint b[2][2]; |
| b = a; |
| a = b; |
| if (x > 0u) |
| a[1][1] = 3u; |
| color = a[0][0] + a[1][1]; |
| } |
| """, |
| r'\(expression uint16_t u2ump \(constant uint \(3'), |
| Test("f32 temp array of array returned by function", |
| """ |
| #version 310 es |
| precision mediump float; |
| |
| uniform float x,y; |
| out float color; |
| |
| float[2][2] f(void) |
| { |
| return float[2][2](float[2](x, y), float[2](x, y)); |
| } |
| |
| void main() |
| { |
| float a[2][2] = f(); |
| if (x > 0.0) |
| a[1][1] = 3.0; |
| color = a[0][0] + a[1][1]; |
| } |
| """, |
| r'\(expression float16_t f2fmp \(constant float \(3'), |
| Test("i32 temp array of array returned by function", |
| """ |
| #version 310 es |
| precision mediump int; |
| |
| uniform int x,y; |
| out int color; |
| |
| int[2][2] f(void) |
| { |
| return int[2][2](int[2](x, y), int[2](x, y)); |
| } |
| |
| void main() |
| { |
| int a[2][2] = f(); |
| if (x > 0) |
| a[1][1] = 3; |
| color = a[0][0] + a[1][1]; |
| } |
| """, |
| r'\(expression int16_t i2imp \(constant int \(3'), |
| Test("u32 temp array of array returned by function", |
| """ |
| #version 310 es |
| precision mediump int; |
| |
| uniform uint x,y; |
| out uint color; |
| |
| uint[2][2] f(void) |
| { |
| return uint[2][2](uint[2](x, y), uint[2](x, y)); |
| } |
| |
| void main() |
| { |
| uint a[2][2] = f(); |
| if (x > 0u) |
| a[1][1] = 3u; |
| color = a[0][0] + a[1][1]; |
| } |
| """, |
| r'\(expression uint16_t u2ump \(constant uint \(3'), |
| Test("f32 temp array of array as function out", |
| """ |
| #version 310 es |
| precision mediump float; |
| |
| uniform float x,y; |
| out float color; |
| |
| void f(out float[2][2] v) |
| { |
| v = float[2][2](float[2](x, y), float[2](x, y)); |
| } |
| |
| void main() |
| { |
| float a[2][2]; |
| f(a); |
| if (x > 0.0) |
| a[1][1] = 3.0; |
| color = a[0][0] + a[1][1]; |
| } |
| """, |
| r'\(expression float16_t f2fmp \(constant float \(3'), |
| Test("i32 temp array of array as function out", |
| """ |
| #version 310 es |
| precision mediump int; |
| |
| uniform int x,y; |
| out int color; |
| |
| void f(out int[2][2] v) |
| { |
| v = int[2][2](int[2](x, y), int[2](x, y)); |
| } |
| |
| void main() |
| { |
| int a[2][2]; |
| f(a); |
| if (x > 0) |
| a[1][1] = 3; |
| color = a[0][0] + a[1][1]; |
| } |
| """, |
| r'\(expression int16_t i2imp \(constant int \(3'), |
| Test("u32 temp array of array as function out", |
| """ |
| #version 310 es |
| precision mediump int; |
| |
| uniform uint x,y; |
| out uint color; |
| |
| void f(out uint[2][2] v) |
| { |
| v = uint[2][2](uint[2](x, y), uint[2](x, y)); |
| } |
| |
| void main() |
| { |
| uint a[2][2]; |
| f(a); |
| if (x > 0u) |
| a[1][1] = 3u; |
| color = a[0][0] + a[1][1]; |
| } |
| """, |
| r'\(expression uint16_t u2ump \(constant uint \(3'), |
| Test("f32 temp array of array as function in", |
| """ |
| #version 310 es |
| precision mediump float; |
| |
| uniform float x,y; |
| out float color; |
| |
| float[2][2] f(in float[2][2] v) |
| { |
| float t[2][2] = v; |
| return t; |
| } |
| |
| void main() |
| { |
| float a[2][2]; |
| a = f(a); |
| if (x > 0.0) |
| a[1][1] = 3.0; |
| color = a[0][0] + a[1][1]; |
| } |
| """, |
| r'\(expression float16_t f2fmp \(constant float \(3'), |
| Test("i32 temp array of array as function in", |
| """ |
| #version 310 es |
| precision mediump int; |
| |
| uniform int x,y; |
| out int color; |
| |
| int[2][2] f(in int[2][2] v) |
| { |
| int t[2][2] = v; |
| return t; |
| } |
| |
| void main() |
| { |
| int a[2][2]; |
| a = f(a); |
| if (x > 0) |
| a[1][1] = 3; |
| color = a[0][0] + a[1][1]; |
| } |
| """, |
| r'\(expression int16_t i2imp \(constant int \(3'), |
| Test("u32 temp array of array as function in", |
| """ |
| #version 310 es |
| precision mediump int; |
| |
| uniform uint x,y; |
| out uint color; |
| |
| uint[2][2] f(in uint[2][2] v) |
| { |
| uint t[2][2] = v; |
| return t; |
| } |
| |
| void main() |
| { |
| uint a[2][2]; |
| a = f(a); |
| if (x > 0u) |
| a[1][1] = 3u; |
| color = a[0][0] + a[1][1]; |
| } |
| """, |
| r'\(expression uint16_t u2ump \(constant uint \(3'), |
| Test("f32 temp array of array as function inout", |
| """ |
| #version 310 es |
| precision mediump float; |
| |
| uniform float x,y; |
| out float color; |
| |
| void f(inout float[2][2] v) |
| { |
| float t[2][2] = v; |
| v = t; |
| } |
| |
| void main() |
| { |
| float a[2][2]; |
| f(a); |
| if (x > 0.0) |
| a[1][1] = 3.0; |
| color = a[0][0] + a[1][1]; |
| } |
| """, |
| r'\(expression float16_t f2fmp \(constant float \(3'), |
| Test("i32 temp array of array as function inout", |
| """ |
| #version 310 es |
| precision mediump int; |
| |
| uniform int x,y; |
| out int color; |
| |
| void f(inout int[2][2] v) |
| { |
| int t[2][2] = v; |
| v = t; |
| } |
| |
| void main() |
| { |
| int a[2][2]; |
| f(a); |
| if (x > 0) |
| a[1][1] = 3; |
| color = a[0][0] + a[1][1]; |
| } |
| """, |
| r'\(expression int16_t i2imp \(constant int \(3'), |
| Test("u32 temp array of array as function inout", |
| """ |
| #version 310 es |
| precision mediump int; |
| |
| uniform uint x,y; |
| out uint color; |
| |
| void f(inout uint[2][2] v) |
| { |
| uint t[2][2] = v; |
| v = t; |
| } |
| |
| void main() |
| { |
| uint a[2][2]; |
| f(a); |
| if (x > 0u) |
| a[1][1] = 3u; |
| color = a[0][0] + a[1][1]; |
| } |
| """, |
| r'\(expression uint16_t u2ump \(constant uint \(3'), |
| Test("f32 temp struct (not lowered in the presence of control flow - TODO)", |
| """ |
| #version 300 es |
| precision mediump float; |
| |
| uniform float x,y; |
| out float color; |
| |
| void main() |
| { |
| struct { float x,y; } s; |
| s.x = x; |
| s.y = y; |
| if (x > 0.0) |
| s.y = 3.0; |
| color = s.x + s.y; |
| } |
| """, |
| r'\(constant float \(3'), # should be float16_t |
| Test("i32 temp struct (not lowered in the presence of control flow - TODO)", |
| """ |
| #version 300 es |
| precision mediump int; |
| |
| uniform int x,y; |
| out int color; |
| |
| void main() |
| { |
| struct { int x,y; } s; |
| s.x = x; |
| s.y = y; |
| if (x > 0) |
| s.y = 3; |
| color = s.x + s.y; |
| } |
| """, |
| r'\(constant int \(3'), # should be int16_t |
| Test("u32 temp struct (not lowered in the presence of control flow - TODO)", |
| """ |
| #version 300 es |
| precision mediump int; |
| |
| uniform uint x,y; |
| out uint color; |
| |
| void main() |
| { |
| struct { uint x,y; } s; |
| s.x = x; |
| s.y = y; |
| if (x > 0u) |
| s.y = 3u; |
| color = s.x + s.y; |
| } |
| """, |
| r'\(constant uint \(3'), # should be uint16_t |
| |
| Test("vec4 constructor from float", |
| """ |
| uniform highp float a; |
| uniform mediump float b; |
| |
| void main() |
| { |
| gl_FragColor = vec4(a) * b; |
| } |
| """, |
| r'\(expression vec4 \* \(swiz xxxx \(var_ref a\) \)\(expression float f162f \(var_ref b\) \) \)'), |
| |
| Test("respect copies", |
| """ |
| uniform mediump float a, b; |
| |
| void main() |
| { |
| highp float x = a; |
| gl_FragColor.x = x * b; |
| } |
| """, |
| r'expression float \* \(expression float f162f \(var_ref a\) \) \(expression float f162f \(var_ref b\) \) '), # should be uint16_t |
| |
| Test("conversion constructor precision", |
| """ |
| #version 300 es |
| uniform mediump uint a; |
| out highp float result; |
| |
| void main() |
| { |
| /* Constructors don't have a precision qualifier themselves, but |
| * constructors are an operation, and so they do the usual "get |
| * precision from my operands, or default to the precision of the |
| * lvalue" rule. So, the u2f is done at mediump due to a's precision. |
| */ |
| result = float(a); |
| } |
| """, |
| r'expression float16_t u2f \(expression uint16_t u2ump \(var_ref a\) \)'), # should be uint16_t |
| |
| ] |
| |
| |
| def compile_shader(standalone_compiler, source): |
| with tempfile.NamedTemporaryFile(mode='wt', suffix='.frag') as source_file: |
| print(source, file=source_file) |
| source_file.flush() |
| return subprocess.check_output([standalone_compiler, |
| '--version', '300', |
| '--lower-precision', |
| '--dump-lir', |
| source_file.name], |
| universal_newlines=True) |
| |
| |
| def run_test(standalone_compiler, test): |
| ir = compile_shader(standalone_compiler, test.source) |
| |
| if re.search(test.match_re, ir) is None: |
| print(ir) |
| return False |
| |
| return True |
| |
| |
| def main(): |
| standalone_compiler = sys.argv[1] |
| passed = 0 |
| |
| for test in TESTS: |
| print('Testing {} ... '.format(test.name), end='') |
| |
| result = run_test(standalone_compiler, test) |
| |
| if result: |
| print('PASS') |
| passed += 1 |
| else: |
| print('FAIL') |
| |
| print('{}/{} tests returned correct results'.format(passed, len(TESTS))) |
| sys.exit(0 if passed == len(TESTS) else 1) |
| |
| |
| if __name__ == '__main__': |
| main() |
