def test_forbidden_import(self):
@gl.lib('poly')
def local_add(a: int, b: int) -> int:
return a + b
@gl.entry(ak.frag)
def vec_attr(buffer: ak.frag, color: gl.inout_p[gl.vec4]) -> None:
color.x = local_add(1, 2)
with self.assertRaisesRegex(
CompileError,
'Forbidden import PolygonShader from FragShader') as _:
compile_shaders((vec_attr, ), ak.frag, TEST_CONFIG)
def test_basic(self):
def gen() -> ak.LEntryFragFn:
return lambda e, b, c: e(12)
@gl.entry(ak.frag)
def vec_attr(buffer: ak.frag, cl: gl.inout_p[gl.vec4]) -> None:
cl.x = buffer.time * 12
def named_gen(arg_value: int):
@gl.entry(ak.frag)
def vec_attr(buffer: ak.frag, cl: gl.inout_p[gl.vec4]) -> None:
cl.x = buffer.time * 12 + gl.outer(arg_value)
return vec_attr
expected = ''.join([
'void frag_main_3(inout vec4 color){color.x = 900;}',
'void frag_main_2(inout vec4 color){color.x = ((time) * (12)) + (180);frag_main_3(color);}',
'void frag_main_1(inout vec4 color){color.x = (time) * (12);frag_main_2(color);}',
'void frag_main(inout vec4 color){12;frag_main_1(color);}'
])
self.maxDiff = None
self.assertEqual(compile_shaders((
gen(),
vec_attr,
named_gen(180),
lambda e, b, c: e(c.x) << e(900)
), ak.frag, TEST_CONFIG), expected)
def test_nested_lambdas(self):
def gen() -> tp.Callable[[int], ak.LEntryFragFn]:
return lambda h: lambda e, b, c: e(12)
expected = 'void frag_main(inout vec4 color){12;}'
self.assertEqual(compile_shaders((gen()(99),), ak.frag), expected)
def test_easy(self):
def gen() -> ak.LEntryFragFn:
return lambda e, b, c: e(12)
expected = 'void frag_main(inout vec4 color){12;}'
self.assertEqual(compile_shaders((gen(),), ak.frag), expected)
def test_basic_resolution(self):
def gen() -> ak.LEntryFragFn:
return lambda e, b, c: e(gl.sin(12))
expected = 'void frag_main(inout vec4 color){sin(12);}'
self.assertEqual(compile_shaders((gen(),), ak.frag), expected)
def test_easy(self):
speed = 999
def gen() -> ak.LEntryFragFn:
return lambda e, b, c: e(x := 102).tp(int) # noqa: F841
expected = 'void frag_main(inout vec4 color){int x = 102;}'
self.assertEqual(compile_shaders((gen(),), ak.frag), expected)
def gen2() -> ak.LEntryFragFn:
return lambda e, b, c: e((x := gl.outer(speed))).tp(int) # noqa: F841
expected2 = 'void frag_main(inout vec4 color){int x = 999;}'
self.assertEqual(compile_shaders((gen2(),), ak.frag), expected2)
def test_merge(self):
def gen() -> ak.LEntryFragFn:
return lambda e, b, c: e(c.x) << e(c.x + b.resolution.x + gl.sin(12)) | e(12)
expected = 'void frag_main(inout vec4 color){color.x = ((color.x) + (resolution.x)) + (sin(12));12;}'
self.assertEqual(compile_shaders((gen(),), ak.frag), expected)
def test_eq(self):
def gen() -> ak.LEntryFragFn:
return lambda e, b, c: e(c.x) << e(gl.sin(12))
expected = 'void frag_main(inout vec4 color){color.x = sin(12);}'
self.assertEqual(compile_shaders((gen(),), ak.frag), expected)
def test_dist_unary_sub(self):
def gen() -> tp.Callable[[int], ak.LEntryFragFn]:
return lambda h: lambda e, b, c: e(x := 12).tp(int) | e(y := 12).tp(int) | e(-(x + y))
expected = 'void frag_main(inout vec4 color){int x = 12;int y = 12;-((x) + (y));}'
self.assertEqual(compile_shaders((gen()(99),), ak.frag), expected)
def test_merge(self):
speed = 999
def gen() -> ak.LEntryFragFn:
return lambda e, b, c: e(c.x) << e(gl.outer(speed)) | e(y := 12.1).tp(float) | e(y)
expected = 'void frag_main(inout vec4 color){color.x = 999;float y = 12.1;y;}'
self.assertEqual(compile_shaders((gen(),), ak.frag), expected)
def test_global_resolution(self):
speed = 999
def gen1() -> ak.LEntryFragFn:
return lambda e, b, c: e(gl.outer(global_speed) + (gl.outer(speed) * gl.sin(12)))
expected = 'void frag_main(inout vec4 color){(1890) + ((999) * (sin(12)));}'
self.assertEqual(compile_shaders((gen1(),), ak.frag), expected)
def test_import2(self):
def gen() -> ak.LEntryFragFn:
return lambda e, b, c: e(module_global_add(1, 2))
expected1 = ''.join([
'int test_lambda_compiler_module_global_add(int a, int b){return (a) + (b);}',
'void frag_main(inout vec4 color){test_lambda_compiler_module_global_add(1, 2);}'
])
self.assertEqual(compile_shaders((gen(),), ak.frag), expected1)
def test_basic(self):
@gl.entry(ak.frag)
def vec_attr(buffer: ak.frag, cl: gl.inout_p[gl.vec4]) -> None:
cl.x = buffer.time * 12
expected = ''.join([
'void frag_main(inout vec4 color){color.x = (time) * (12);}',
])
self.assertEqual(compile_shaders((vec_attr, ), ak.frag, TEST_CONFIG),
expected)
def test_argument_resolution(self):
speed = 999
def gen1() -> ak.LEntryFragFn:
return (
lambda e, b, c: e((c.y * gl.outer(global_speed)) + (b.time * gl.outer(speed) * gl.sin(12)))
)
expected1 = 'void frag_main(inout vec4 color){((color.y) * (1890)) + (((time) * (999)) * (sin(12)));}'
self.assertEqual(compile_shaders((gen1(),), ak.frag), expected1)
def gen2() -> ak.LEntryPolyFn:
return lambda e, b, p: (
e((p.y * gl.outer(global_speed)) + (b.time * gl.outer(speed) * gl.sin(12)))
)
expected2 = 'void poly_main(inout vec4 pos){((pos.y) * (1890)) + (((time) * (999)) * (sin(12)));}'
self.assertEqual(compile_shaders((gen2(),), ak.poly), expected2)
def test_buffer_direct_assign(self):
def gen() -> ak.LEntryFragFn:
return lambda e, b, c: e(c) << e(c)
expected = ''.join([
'void frag_main(inout vec4 color){color = color;}'
])
self.maxDiff = None
self.assertEqual(compile_shaders((
gen(),
), ak.frag, TEST_CONFIG), expected)
def test_import_resolution(self):
speed = 999
def gen1() -> ak.LEntryFragFn:
return lambda e, b, c: (
e(compiler_fixtures.boost_add(1, gl.outer(global_speed)) + (gl.outer(speed) * gl.sin(12)))
)
expected1 = ''.join([
'int compiler_fixtures_boost(int v){return (v) * (1000);}',
'int compiler_fixtures_boost_add(int a, int b){return (a) + (compiler_fixtures_boost(b));}',
'void frag_main(inout vec4 color){(compiler_fixtures_boost_add(1, 1890)) + ((999) * (sin(12)));}'
])
self.assertEqual(compile_shaders((gen1(),), ak.frag), expected1)
def gen2() -> ak.LEntryFragFn:
return lambda e, b, c: e(module_global_poly(1, 2) + (gl.outer(speed) * gl.sin(12)))
with self.assertRaisesRegex(CompileError, 'Forbidden import PolygonShader from FragShader') as _:
compile_shaders((gen2(),), ak.frag)
def test_basic(self):
def gen(arg_value: int):
@gl.entry(ak.frag)
def vec_attr(buffer: ak.frag, cl: gl.inout_p[gl.vec4]) -> None:
cl.x = buffer.time * 12 + gl.outer(arg_value)
return vec_attr
expected = ''.join([
'void frag_main(inout vec4 color){color.x = ((time) * (12)) + (999);}',
])
self.assertEqual(compile_shaders((gen(999), ), ak.frag, TEST_CONFIG),
expected)
def test_easy(self):
speed = 999
def gen() -> ak.LEntryFragFn:
return lambda e, b, c: e(x := 102).tp(int) # noqa: F841
def gen2() -> ak.LEntryFragFn:
return lambda e, b, c: e(c.x) << e(gl.outer(speed)) | e(y := gl.vec2(1, 2)).tp(gl.vec2) | e(y)
def gen3() -> ak.LEntryFragFn:
return lambda e, b, c: e(c.y) << e(1.0)
expected = ''.join([
'void frag_main_2(inout vec4 color){color.y = 1.0;}',
'void frag_main_1(inout vec4 color){color.x = 999;vec2 y = vec2(1, 2);y;frag_main_2(color);}',
'void frag_main(inout vec4 color){int x = 102;frag_main_1(color);}'
])
self.assertEqual(compile_shaders((gen(), gen2(), gen3()), ak.frag), expected)
def test_import(self):
outer_value = 102
def gen() -> ak.LEntryFragFn:
return lambda e, b, c: e(module_global_add(1, 2) * gl.outer(outer_value))
@gl.entry(ak.frag)
def vec_attr(buffer: ak.frag, cl: gl.inout_p[gl.vec4]) -> None:
cl.x = module_global_add(1, 2)
expected = ''.join([
'int test_compiler_module_global_add(int a, int b){return (a) + (b);}',
'void frag_main_1(inout vec4 color){color.x = test_compiler_module_global_add(1, 2);}',
'void frag_main(inout vec4 color){(test_compiler_module_global_add(1, 2)) * (102);frag_main_1(color);}'
])
self.maxDiff = None
self.assertEqual(compile_shaders((
gen(),
vec_attr
), ak.frag, TEST_CONFIG), expected)
def test_chain(self):
@gl.entry(ak.frag)
def vec_attr(buffer: ak.frag, cl: gl.inout_p[gl.vec4]) -> None:
cl.x = buffer.time * 12
@gl.entry(ak.frag)
def vec_attr2(buffer: ak.frag, color: gl.inout_p[gl.vec4]) -> None:
color.y = buffer.time * 12
@gl.entry(ak.frag)
def vec_attr3(buffer: ak.frag, color: gl.inout_p[gl.vec4]) -> None:
color.z = buffer.time * 12
expected = ''.join([
'void frag_main_2(inout vec4 color){color.z = (time) * (12);}',
'void frag_main_1(inout vec4 color){color.y = (time) * (12);frag_main_2(color);}',
'void frag_main(inout vec4 color){color.x = (time) * (12);frag_main_1(color);}',
])
self.maxDiff = None
self.assertEqual(
compile_shaders((vec_attr, vec_attr2, vec_attr3), ak.frag,
TEST_CONFIG), expected)
def test_uniform_import(self):
ddd = 12
@gl.lib('poly')
def local_add(a: int, b: int) -> int:
return a + b
@gl.entry(ak.frag)
def vec_attr(buffer: ak.frag, color: gl.inout_p[gl.vec4]) -> None:
color.x = buffer.time * module_global_add(
12, 1) * compiler_fixtures.boost_add(20, gl.outer(ddd))
expected = ''.join([
'int test_named_compiler_module_global_add(int a, int b){return (a) + (b);}',
'int compiler_fixtures_boost(int v){return (v) * (1000);}',
'int compiler_fixtures_boost_add(int a, int b){return (a) + (compiler_fixtures_boost(b));}',
'void frag_main(inout vec4 color){color.x = ((time) * (test_named_compiler_module_global_add(12, 1))) * (compiler_fixtures_boost_add(20, 12));}',
])
self.maxDiff = None
self.assertEqual(compile_shaders((vec_attr, ), ak.frag, TEST_CONFIG),
expected)
def test_imports(self):
speed = 999
def gen1() -> ak.LEntryFragFn:
return lambda e, b, c: (
e(compiler_fixtures.boost_add(1, gl.outer(global_speed)) + (gl.outer(speed) * gl.sin(12)))
)
def gen2() -> ak.LEntryFragFn:
return lambda e, b, c: (
e(z := gl.outer(speed) * gl.sin(b.time)).tp(float) |
e(compiler_fixtures.boost_add(1, gl.outer(global_speed)) + z)
)
expected = ''.join([
'int compiler_fixtures_boost(int v){return (v) * (1000);}',
'int compiler_fixtures_boost_add(int a, int b){return (a) + (compiler_fixtures_boost(b));}',
'void frag_main_1(inout vec4 color){float z = (999) * (sin(time));(compiler_fixtures_boost_add(1, 1890)) + (z);}',
'void frag_main(inout vec4 color){(compiler_fixtures_boost_add(1, 1890)) + ((999) * (sin(12)));frag_main_1(color);}'
])
self.maxDiff = None
self.assertEqual(compile_shaders((gen1(), gen2()), ak.frag), expected)