def test_detach(self): vert = VertexShader("A") frag = FragmentShader("B") program = Program(vert, frag) program.detach(frag) assert len(program.shaders) == 1 assert program.shaders[0].code == "A"
def test_set_attribute_vec4(self): vert = VertexShader("attribute vec4 color;") frag = FragmentShader("") program = Program(vert, frag) with self.assertRaises(ValueError): program["color"] = np.array(3, dtype=np.float32) program = Program(vert, frag) with self.assertRaises(ValueError): program["color"] = np.array((100, 5), dtype=np.float32) program = Program(vert, frag) program["color"] = ClientVertexBuffer( np.zeros((100, 4), dtype=np.float32)) assert program._attributes["color"].count == 100 program = Program(vert, frag) program["color"] = ClientVertexBuffer( np.zeros((100, 1, 4), dtype=np.float32)) assert program._attributes["color"].count == 100 program = Program(vert, frag) program["color"] = ClientVertexBuffer( np.zeros(100, dtype=(np.float32, 4))) assert program._attributes["color"].count == 100
def test_setting_shaders(self): program = Program("A", "B") assert program.shaders[0] == "A" assert program.shaders[1] == "B" program.set_shaders('C', 'D') assert program.shaders[0] == "C" assert program.shaders[1] == "D"
def test_attach(self): vert = VertexShader("A") frag = FragmentShader("B") program = Program(vert) program.attach(frag) assert len(program.shaders) == 2 assert program.shaders[0].code == "A" assert program.shaders[1].code == "B"
def test_failed_build(self): vert = VertexShader("A") frag = FragmentShader("B") program = Program(vert=vert) self.assertRaises(RuntimeError, program.activate) program = Program(frag=frag) self.assertRaises(RuntimeError, program.activate)
def test_failed_build(self): vert = VertexShader("A") frag = FragmentShader("B") program = Program(vert=vert) program._need_create = False # fool program that it already exists self.assertRaises(ValueError, program.activate) program = Program(frag=frag) program._need_create = False # fool program that it already exists self.assertRaises(ValueError, program.activate)
def test_setting_shaders(self): from vispy.gloo.program import VertexShader, FragmentShader program = Program("A", "B") assert isinstance(program.shaders[0], VertexShader) assert program.shaders[0].code == 'A' assert isinstance(program.shaders[1], FragmentShader) assert program.shaders[1].code == 'B' program.set_shaders('C', 'D') assert program.shaders[0].code == "C" assert program.shaders[1].code == "D"
def test_attributes(self): program = Program("attribute float A; attribute vec4 B;", "foo") assert ('attribute', 'float', 'A') in program.variables assert ('attribute', 'vec4', 'B') in program.variables assert len(program.variables) == 2 from vispy.gloo import VertexBuffer vbo = VertexBuffer() # Set existing uniforms program['A'] = vbo assert program['A'] == vbo assert 'A' in program._user_variables assert program._user_variables['A'] is vbo # Set data - update existing vbp program['A'] = np.zeros((10,), np.float32) assert program._user_variables['A'] is vbo # Set data - create new vbo program['B'] = np.zeros((10, 4), np.float32) assert isinstance(program._user_variables['B'], VertexBuffer) # Set non-exisint uniforms program['C'] = vbo assert program['C'] == vbo assert 'C' not in program._user_variables assert 'C' in program._pending_variables # C should be taken up when code comes along that mentions it program.set_shaders("attribute float A; attribute vec2 C;", "foo") assert program['C'] == vbo assert 'C' in program._user_variables assert 'C' not in program._pending_variables # Set wrong values self.assertRaises(ValueError, program.__setitem__, 'A', 'asddas') # Set wrong values beforehand program['D'] = "" self.assertRaises(ValueError, program.set_shaders, 'attribute vec3 D;', '') # Set to one value per vertex program.set_shaders("attribute float A; attribute vec2 C;", "foo") program['A'] = 1.0 assert program['A'] == 1.0 program['C'] = 1.0, 2.0 assert all(program['C'] == np.array((1.0, 2.0), np.float32)) # self.assertRaises(ValueError, program.__setitem__, 'A', (1.0, 2.0)) self.assertRaises(ValueError, program.__setitem__, 'C', 1.0) self.assertRaises(ValueError, program.bind, 'notavertexbuffer')
def test_uniform(self): vert = VertexShader("uniform float A;") frag = FragmentShader("uniform float A; uniform vec4 B;") program = Program(vert, frag) assert ("A", gl.GL_FLOAT) in program.all_uniforms assert ("B", gl.GL_FLOAT_VEC4) in program.all_uniforms assert len(program.all_uniforms) == 2
def test_setitem(self): vert = VertexShader("") frag = FragmentShader("") program = Program(vert, frag) with self.assertRaises(NameError): program["A"] = 1
def test_uniform(self): vert = VertexShader("uniform float A;") frag = FragmentShader("uniform float A; uniform vec4 B;") program = Program(vert, frag) assert program.uniforms[0].name == 'A' assert program.uniforms[0].gtype == gl.GL_FLOAT assert program.uniforms[1].name == 'B' assert program.uniforms[1].gtype == gl.GL_FLOAT_VEC4
def test_set_attribute_float(self): vert = VertexShader("attribute float f;") frag = FragmentShader("") program = Program(vert, frag) program["f"] = VertexBuffer(np.zeros(100, dtype=np.float32)) assert program._attributes["f"].count == 100 program = Program(vert, frag) program["f"] = ClientVertexBuffer( np.zeros((100, 1, 1), dtype=np.float32)) assert program._attributes["f"].count == 100 program = Program(vert, frag) with self.assertRaises(ValueError): program["f"] = np.zeros((100, 1, 1), dtype=np.float32)
def test_setitem(self): vert = VertexShader("") frag = FragmentShader("") program = Program(vert, frag) def modifier(p): p["A"] = 1 self.assertRaises(NameError, modifier, program)
def test_setitem(self): vert = VertexShader("") frag = FragmentShader("") program = Program(vert, frag) #with self.assertRaises(ValueError): # program["A"] = 1 with use_log_level('error', record=True, print_msg=False): self.assertRaises(KeyError, program.__setitem__, "A", 1)
def test_vbo(self): # Test with count program = Program('attribute float a; attribute vec2 b;', 'foo', 10) assert program._count == 10 assert ('attribute', 'float', 'a') in program.variables assert ('attribute', 'vec2', 'b') in program.variables # Set program['a'] = np.ones((10, ), np.float32) assert np.all(program._buffer['a'] == 1)
def test_vayings(self): # Varyings and constants are detected program = Program("varying float A; const vec4 B;", "foo") assert ('varying', 'float', 'A') in program.variables assert ('const', 'vec4', 'B') in program.variables # But cannot be set self.assertRaises(KeyError, program.__setitem__, 'A', 3.0) self.assertRaises(KeyError, program.__setitem__, 'B', (1.0, 2.0, 3.0)) # And anything else also fails self.assertRaises(KeyError, program.__getitem__, 'fooo')
def test_draw(self): # Init program = Program("attribute float A;", "uniform float foo") program['A'] = np.zeros((10, ), np.float32) # We need to disable flushing to run this test flush = program._glir.flush program._glir.flush = lambda x=None: None try: # Draw arrays program.draw('triangles') glir_cmd = program._glir.clear()[-1] assert glir_cmd[0] == 'DRAW' assert len(glir_cmd[-1]) == 2 # Draw elements indices = gloo.IndexBuffer(np.zeros(10, dtype=np.uint8)) program.draw('triangles', indices) glir_cmd = program._glir.clear()[-1] assert glir_cmd[0] == 'DRAW' assert len(glir_cmd[-1]) == 3 # Invalid mode self.assertRaises(ValueError, program.draw, 'nogeometricshape') # Invalid index self.assertRaises(TypeError, program.draw, 'triangles', 'notindex') # No atributes program = Program("attribute float A;", "uniform float foo") self.assertRaises(RuntimeError, program.draw, 'triangles') # Atributes with different sizes program = Program("attribute float A; attribute float B;", "foo") program['A'] = np.zeros((10, ), np.float32) program['B'] = np.zeros((11, ), np.float32) self.assertRaises(RuntimeError, program.draw, 'triangles') finally: program._glir.flush = flush
def test_init(self): # Test ok init, no shaders program = Program() assert program._user_variables == {} assert program._code_variables == {} assert program._pending_variables == {} assert program.shaders == ('', '') # Test ok init, with shader program = Program('A', 'B') assert program.shaders == ('A', 'B') # False inits self.assertRaises(ValueError, Program, 'A', None) self.assertRaises(ValueError, Program, None, 'B') self.assertRaises(ValueError, Program, 3, 'B') self.assertRaises(ValueError, Program, 3, None) self.assertRaises(ValueError, Program, 'A', 3) self.assertRaises(ValueError, Program, None, 3) self.assertRaises(ValueError, Program, "", "") self.assertRaises(ValueError, Program, "foo", "") self.assertRaises(ValueError, Program, "", "foo")
def test_draw(self): # Init program = Program("attribute float A;", "uniform float foo") program['A'] = np.zeros((10, ), np.float32) dummy_canvas = DummyCanvas() glir = dummy_canvas.context.glir set_current_canvas(dummy_canvas) try: # Draw arrays program.draw('triangles') glir_cmd = glir.clear()[-1] assert glir_cmd[0] == 'DRAW' assert len(glir_cmd[-1]) == 2 # Draw elements indices = gloo.IndexBuffer(np.zeros(10, dtype=np.uint8)) program.draw('triangles', indices) glir_cmd = glir.clear()[-1] assert glir_cmd[0] == 'DRAW' assert len(glir_cmd[-1]) == 3 # Invalid mode self.assertRaises(ValueError, program.draw, 'nogeometricshape') # Invalid index self.assertRaises(TypeError, program.draw, 'triangles', 'notindex') # No atributes program = Program("attribute float A;", "uniform float foo") self.assertRaises(RuntimeError, program.draw, 'triangles') # Atributes with different sizes program = Program("attribute float A; attribute float B;", "foo") program['A'] = np.zeros((10, ), np.float32) program['B'] = np.zeros((11, ), np.float32) self.assertRaises(RuntimeError, program.draw, 'triangles') finally: forget_canvas(dummy_canvas)
def test_failed_build(self): vert = VertexShader("A") frag = FragmentShader("B") program = Program(vert = vert) with self.assertRaises(RuntimeError): program.activate() program = Program(frag = frag) with self.assertRaises(RuntimeError): program.activate()
def test_error(self): vert = ''' void main() { vec2 xy; error on this line vec2 ab; } ''' frag = 'void main() { glFragColor = vec4(1, 1, 1, 1); }' with app.Canvas() as c: program = Program(vert, frag) try: program._glir.flush(c.context.shared.parser) except Exception as err: assert_in('error on this line', str(err)) else: raise Exception("Compile program should have failed.")
def test_attributes(self): program = Program("attribute float A; attribute vec4 B;", "foo") assert ('attribute', 'float', 'A') in program.variables assert ('attribute', 'vec4', 'B') in program.variables assert len(program.variables) == 2 from vispy.gloo import VertexBuffer vbo = VertexBuffer() # Set existing uniforms program['A'] = vbo assert program['A'] == vbo assert 'A' in program._user_variables assert program._user_variables['A'] is vbo # Set data - update existing vbp program['A'] = np.zeros((10, ), np.float32) assert program._user_variables['A'] is vbo # Set data - create new vbo program['B'] = np.zeros((10, 4), np.float32) assert isinstance(program._user_variables['B'], VertexBuffer) # Set non-exisint uniforms program['C'] = vbo assert program['C'] == vbo assert 'C' not in program._user_variables assert 'C' in program._pending_variables # C should be taken up when code comes along that mentions it program.set_shaders("attribute float A; attribute vec2 C;", "foo") assert program['C'] == vbo assert 'C' in program._user_variables assert 'C' not in program._pending_variables # Set wrong values self.assertRaises(ValueError, program.__setitem__, 'A', 'asddas') # Set wrong values beforehand program['D'] = "" self.assertRaises(ValueError, program.set_shaders, 'attribute vec3 D;', '') # Set to one value per vertex program.set_shaders("attribute float A; attribute vec2 C;", "foo") program['A'] = 1.0 assert program['A'] == 1.0 program['C'] = 1.0, 2.0 assert all(program['C'] == np.array((1.0, 2.0), np.float32)) # self.assertRaises(ValueError, program.__setitem__, 'A', (1.0, 2.0)) self.assertRaises(ValueError, program.__setitem__, 'C', 1.0) self.assertRaises(ValueError, program.bind, 'notavertexbuffer')
def test_set_attribute_float(self): vert = VertexShader("attribute float f;") frag = FragmentShader("") program = Program(vert, frag) program["f"] = VertexBuffer(np.zeros(100, dtype=np.float32)) assert program._attributes["f"].count == 100 program = Program(vert, frag) program.set_vars(f=ClientVertexBuffer(np.zeros((100, 1, 1), dtype=np.float32))) assert_raises(NameError, program.set_vars, junk='foo') assert program._attributes["f"].count == 100 program = Program(vert, frag) def modifier(p): p["f"] = np.zeros((100, 1, 1), dtype=np.float32) self.assertRaises(ValueError, modifier, program)
def test_set_vars(self): vert = VertexShader("attribute vec4 color;") frag = FragmentShader("") program = Program(vert, frag) arr = np.array((100, 5), dtype=np.float32) assert_raises(ValueError, program.set_vars, arr) dtype = np.dtype([('position', np.float32, 3), ('texcoord', np.float32, 2), ('color', np.float32, 4)]) data = np.zeros(100, dtype=dtype) arr = VertexBuffer(data) program.set_vars(arr) assert_raises(TypeError, program.set_vars, 'hello') program.set_vars(dict(color=arr, fake=arr))
def test_draw(self): # Init program = Program("attribute float A;", "uniform float foo") program['A'] = np.zeros((10,), np.float32) # We need to disable flushing to run this test flush = program._context.glir.flush program._context.glir.flush = lambda x=None: None try: # Draw arrays program.draw('triangles') glir_cmd = program._context.glir.clear()[-1] assert glir_cmd[0] == 'DRAW' assert len(glir_cmd[-1]) == 2 # Draw elements indices = gloo.IndexBuffer(np.zeros(10, dtype=np.uint8)) program.draw('triangles', indices) glir_cmd = program._context.glir.clear()[-1] assert glir_cmd[0] == 'DRAW' assert len(glir_cmd[-1]) == 3 # Invalid mode self.assertRaises(ValueError, program.draw, 'nogeometricshape') # Invalid index self.assertRaises(TypeError, program.draw, 'triangles', 'notindex') # No atributes program = Program("attribute float A;", "uniform float foo") self.assertRaises(RuntimeError, program.draw, 'triangles') # Atributes with different sizes program = Program("attribute float A; attribute float B;", "foo") program['A'] = np.zeros((10,), np.float32) program['B'] = np.zeros((11,), np.float32) self.assertRaises(RuntimeError, program.draw, 'triangles') finally: program._context.glir.flush = flush
def test_draw(self): # Init program = Program("attribute float A;", "uniform float foo") program['A'] = np.zeros((10,), np.float32) dummy_canvas = DummyCanvas() glir = dummy_canvas.context.glir set_current_canvas(dummy_canvas) try: # Draw arrays program.draw('triangles') glir_cmd = glir.clear()[-1] assert glir_cmd[0] == 'DRAW' assert len(glir_cmd[-1]) == 2 # Draw elements indices = gloo.IndexBuffer(np.zeros(10, dtype=np.uint8)) program.draw('triangles', indices) glir_cmd = glir.clear()[-1] assert glir_cmd[0] == 'DRAW' assert len(glir_cmd[-1]) == 3 # Invalid mode self.assertRaises(ValueError, program.draw, 'nogeometricshape') # Invalid index self.assertRaises(TypeError, program.draw, 'triangles', 'notindex') # No atributes program = Program("attribute float A;", "uniform float foo") self.assertRaises(RuntimeError, program.draw, 'triangles') # Atributes with different sizes program = Program("attribute float A; attribute float B;", "foo") program['A'] = np.zeros((10,), np.float32) program['B'] = np.zeros((11,), np.float32) self.assertRaises(RuntimeError, program.draw, 'triangles') finally: forget_canvas(dummy_canvas)
def _test_application(backend): """Test application running""" app = Application() assert_raises(ValueError, app.use, "foo") app.use(backend) wrong = "Glut" if app.backend_name != "Glut" else "Pyglet" assert_raises(RuntimeError, app.use, wrong) app.process_events() if backend is not None: # "in" b/c "qt" in "PySide (qt)" assert_in(backend, app.backend_name) print(app) # test __repr__ # Canvas pos = [0, 0] size = (100, 100) # Use "with" statement so failures don't leave open window # (and test context manager behavior) title = "default" if backend is None else backend with Canvas(title=title, size=size, app=app, show=True, position=pos) as canvas: assert_is(canvas.app, app) assert_true(canvas.native) assert_equal("swap_buffers", canvas.events.paint.callback_refs[-1]) print(canvas) # __repr__ assert_array_equal(canvas.size, size) assert_equal(canvas.title, title) canvas.title = "you" canvas.position = pos canvas.size = size canvas.connect(on_mouse_move) assert_raises(ValueError, canvas.connect, _on_mouse_move) if sys.platform != "darwin": # XXX knownfail, prob. needs warmup canvas.show(False) canvas.show() app.process_events() assert_raises(ValueError, canvas.connect, on_nonexist) # screenshots gl.glViewport(0, 0, *size) ss = _screenshot() assert_array_equal(ss.shape, size + (3,)) assert_equal(len(canvas._backend._vispy_get_geometry()), 4) assert_array_equal(canvas.size, size) assert_equal(len(canvas.position), 2) # XXX knawnfail, doesn't "take" # GLOO: should have an OpenGL context already, so these should work vert = VertexShader("void main (void) {gl_Position = pos;}") frag = FragmentShader("void main (void) {gl_FragColor = pos;}") program = Program(vert, frag) assert_raises(RuntimeError, program.activate) vert = VertexShader("uniform vec4 pos;" "void main (void) {gl_Position = pos;}") frag = FragmentShader("uniform vec4 pos;" "void main (void) {gl_FragColor = pos;}") program = Program(vert, frag) # uniform = program.uniforms[0] program["pos"] = [1, 2, 3, 4] program.activate() # should print # uniform.upload(program) program.detach(vert) program.detach(frag) assert_raises(RuntimeError, program.detach, vert) assert_raises(RuntimeError, program.detach, frag) vert = VertexShader("attribute vec4 pos;" "void main (void) {gl_Position = pos;}") frag = FragmentShader("void main (void) {}") program = Program(vert, frag) # attribute = program.attributes[0] program["pos"] = [1, 2, 3, 4] program.activate() # attribute.upload(program) # cannot get element count # assert_raises(RuntimeError, program.draw, 'POINTS') # use a real program vert = ( "uniform mat4 u_model;" "attribute vec2 a_position; attribute vec4 a_color;" "varying vec4 v_color;" "void main (void) {v_color = a_color;" "gl_Position = u_model * vec4(a_position, 0.0, 1.0);" "v_color = a_color;}" ) frag = "void main() {gl_FragColor = vec4(0, 0, 0, 1);}" n, p = 250, 50 T = np.random.uniform(0, 2 * np.pi, n) position = np.zeros((n, 2), dtype=np.float32) position[:, 0] = np.cos(T) position[:, 1] = np.sin(T) color = np.ones((n, 4), dtype=np.float32) * (1, 1, 1, 1) data = np.zeros(n * p, [("a_position", np.float32, 2), ("a_color", np.float32, 4)]) data["a_position"] = np.repeat(position, p, axis=0) data["a_color"] = np.repeat(color, p, axis=0) program = Program(vert, frag) program.bind(VertexBuffer(data)) program["u_model"] = np.eye(4, dtype=np.float32) # different codepath if no call to activate() program.draw(gl.GL_POINTS) subset = IndexBuffer(np.arange(10, dtype=np.uint32)) program.draw(gl.GL_POINTS, subset) # bad programs frag_bad = "varying vec4 v_colors" # no semicolon program = Program(vert, frag_bad) assert_raises(RuntimeError, program.activate) frag_bad = None # no fragment code. no main is not always enough program = Program(vert, frag_bad) assert_raises(ValueError, program.activate) # Timer timer = Timer(interval=0.001, connect=on_mouse_move, iterations=2, start=True, app=app) timer.start() timer.interval = 0.002 assert_equal(timer.interval, 0.002) assert_true(timer.running) timer.stop() assert_true(not timer.running) assert_true(timer.native) timer.disconnect() # test that callbacks take reasonable inputs _test_callbacks(canvas) # cleanup canvas.swap_buffers() canvas.update() app.process_events()
def test_delete_no_context(self): program = Program() program.delete()
def _test_application(backend): """Test application running""" app = Application() assert_raises(ValueError, app.use, 'foo') app.use(backend) wrong = 'Glut' if app.backend_name != 'Glut' else 'Pyglet' assert_raises(RuntimeError, app.use, wrong) app.process_events() if backend is not None: # "in" b/c "qt" in "PySide (qt)" assert_true(backend in app.backend_name) print(app) # test __repr__ # Canvas pos = [0, 0, 1, 1] # Use "with" statement so failures don't leave open window # (and test context manager behavior) with Canvas(title='me', app=app, show=True, position=pos) as canvas: assert_true(canvas.app is app) assert_true(canvas.native) print(canvas.size >= (1, 1)) canvas.resize(90, 90) canvas.move(1, 1) assert_equal(canvas.title, 'me') canvas.title = 'you' canvas.position = (0, 0) canvas.size = (100, 100) canvas.connect(on_mouse_move) assert_raises(ValueError, canvas.connect, _on_mouse_move) canvas.show() assert_raises(ValueError, canvas.connect, on_nonexist) # screenshots ss = _screenshot() assert_array_equal(ss.shape[2], 3) # XXX other dimensions not correct? # XXX it would be good to do real checks, but sometimes the # repositionings don't "take" (i.e., lead to random errors) assert_equal(len(canvas._backend._vispy_get_geometry()), 4) assert_equal(len(canvas.size), 2) assert_equal(len(canvas.position), 2) # GLOO: should have an OpenGL context already, so these should work vert = VertexShader("void main (void) {gl_Position = pos;}") frag = FragmentShader("void main (void) {gl_FragColor = pos;}") program = Program(vert, frag) assert_raises(ShaderError, program.activate) vert = VertexShader("uniform vec4 pos;" "void main (void) {gl_Position = pos;}") frag = FragmentShader("uniform vec4 pos;" "void main (void) {gl_FragColor = pos;}") program = Program(vert, frag) uniform = program.uniforms[0] uniform.set_data([1, 2, 3, 4]) program.activate() # should print uniform.upload(program) program.detach(vert, frag) assert_raises(ShaderError, program.detach, vert) assert_raises(ShaderError, program.detach, frag) vert = VertexShader("attribute vec4 pos;" "void main (void) {gl_Position = pos;}") frag = FragmentShader("void main (void) {}") program = Program(vert, frag) attribute = program.attributes[0] attribute.set_data([1, 2, 3, 4]) program.activate() attribute.upload(program) # cannot get element count assert_raises(ProgramError, program.draw, 'POINTS') # use a real program vert = ("uniform mat4 u_model;" "attribute vec2 a_position; attribute vec4 a_color;" "varying vec4 v_color;" "void main (void) {v_color = a_color;" "gl_Position = u_model * vec4(a_position, 0.0, 1.0);" "v_color = a_color;}") frag = "void main() {gl_FragColor = vec4(0, 0, 0, 1);}" n, p = 250, 50 T = np.random.uniform(0, 2 * np.pi, n) position = np.zeros((n, 2), dtype=np.float32) position[:, 0] = np.cos(T) position[:, 1] = np.sin(T) color = np.ones((n, 4), dtype=np.float32) * (1, 1, 1, 1) data = np.zeros(n * p, [('a_position', np.float32, 2), ('a_color', np.float32, 4)]) data['a_position'] = np.repeat(position, p, axis=0) data['a_color'] = np.repeat(color, p, axis=0) program = Program(vert, frag) program.set_vars(VertexBuffer(data)) program['u_model'] = np.eye(4, dtype=np.float32) program.draw('POINTS') # different codepath if no call to activate() subset = ElementBuffer(np.arange(10, dtype=np.uint32)) program.draw('POINTS', subset=subset) # bad programs frag_bad = ("varying vec4 v_colors") # no semicolon program = Program(vert, frag_bad) assert_raises(ShaderError, program.activate) frag_bad = None # no fragment code. no main is not always enough program = Program(vert, frag_bad) assert_raises(ProgramError, program.activate) # Timer timer = Timer(interval=0.001, connect=on_mouse_move, iterations=2, start=True, app=app) timer.start() timer.interval = 0.002 assert_equal(timer.interval, 0.002) assert_true(timer.running) timer.stop() assert_true(not timer.running) assert_true(timer.native) timer.disconnect() # test that callbacks take reasonable inputs _test_callbacks(canvas) # cleanup canvas.swap_buffers() canvas.update() # put this in even though __exit__ will call it to make sure we don't # have problems calling it multiple times canvas.close() app.quit() app.quit() # make sure it doesn't break if a user does something silly
def test_init_from_string(self): program = Program("A", "B") assert len(program.shaders) == 2 assert program.shaders[0].code == "A" assert program.shaders[1].code == "B"
def test_init(self): program = Program() assert program._handle == 0 assert program._need_update == False assert program._valid == False assert program.shaders == []
def test_uniform(self): # Text array unoforms program = Program("uniform float A[10];", "foo") assert ('uniform', 'float', 'A[0]') in program.variables assert len(program.variables) == 10 # Init program program = Program("uniform float A;", "uniform float A; uniform vec4 B;") assert ('uniform', 'float', 'A') in program.variables assert ('uniform', 'vec4', 'B') in program.variables assert len(program.variables) == 2 # Set existing uniforms program['A'] = 3.0 assert isinstance(program['A'], np.ndarray) assert program['A'] == 3.0 assert 'A' in program._user_variables # program['B'] = 1.0, 2.0, 3.0, 4.0 assert isinstance(program['B'], np.ndarray) assert all(program['B'] == np.array((1.0, 2.0, 3.0, 4.0), np.float32)) assert 'B' in program._user_variables # Set non-exisint uniforms program['C'] = 1.0, 2.0 assert program['C'] == (1.0, 2.0) assert 'C' not in program._user_variables assert 'C' in program._pending_variables # Set samplers program.set_shaders("uniform sampler2D T2; uniform sampler3D T3;", "f") program['T2'] = np.zeros((10, 10), np.float32) program['T3'] = np.zeros((10, 10, 10), np.float32) assert isinstance(program['T2'], gloo.Texture2D) assert isinstance(program['T3'], gloo.Texture3D) # Set samplers with textures tex = gloo.Texture2D((10, 10)) program['T2'] = tex assert program['T2'] is tex program['T2'] = np.zeros((10, 10), np.float32) # Update texture assert program['T2'] is tex # C should be taken up when code comes along that mentions it program.set_shaders("uniform float A; uniform vec2 C;", "uniform float A; uniform vec4 B;") assert isinstance(program['C'], np.ndarray) assert all(program['C'] == np.array((1.0, 2.0), np.float32)) assert 'C' in program._user_variables assert 'C' not in program._pending_variables # Set wrong values self.assertRaises(ValueError, program.__setitem__, 'A', (1.0, 2.0)) self.assertRaises(ValueError, program.__setitem__, 'B', (1.0, 2.0)) self.assertRaises(ValueError, program.__setitem__, 'C', 1.0) # Set wrong values beforehand program['D'] = 1.0, 2.0 self.assertRaises(ValueError, program.set_shaders, '', 'uniform vec3 D;')
def test_attributes(self): vert = VertexShader("attribute float A;") frag = FragmentShader("") program = Program(vert, frag) assert program.attributes[0].name == 'A' assert program.attributes[0].gtype == gl.GL_FLOAT
def test_unique_shader(self): vert = VertexShader("A") frag = FragmentShader("B") program = Program([vert, vert], [frag, frag, frag]) assert len(program.shaders) == 2
def test_init_from_shader(self): program = Program(VertexShader("A"), FragmentShader("B")) assert len(program.shaders) == 2 assert program.shaders[0].code == "A" assert program.shaders[1].code == "B"
def test_application(): """Test application running""" app = use_app() print(app) # __repr__ without app app.create() wrong = 'glut' if app.backend_name.lower() != 'glut' else 'pyglet' assert_raises(RuntimeError, use_app, wrong) app.process_events() print(app) # test __repr__ assert_raises(ValueError, Canvas, keys='foo') assert_raises(TypeError, Canvas, keys=dict(escape=1)) assert_raises(ValueError, Canvas, keys=dict(escape='foo')) # not an attr pos = [0, 0] if app.backend_module.capability['position'] else None size = (100, 100) # Use "with" statement so failures don't leave open window # (and test context manager behavior) title = 'default' with Canvas(title=title, size=size, app=app, show=True, position=pos) as canvas: assert_true(canvas.create_native() is None) # should be done already assert_is(canvas.app, app) assert_true(canvas.native) assert_equal('swap_buffers', canvas.events.draw.callback_refs[-1]) canvas.measure_fps(0.001) sleep(0.002) canvas.update() app.process_events() assert_true(canvas.fps > 0) # Other methods print(canvas) # __repr__ assert_equal(canvas.title, title) canvas.title = 'you' with use_log_level('warning', record=True, print_msg=False) as l: if app.backend_module.capability['position']: # todo: disable more tests based on capability canvas.position = pos canvas.size = size if 'ipynb_vnc' in canvas.app.backend_name.lower(): assert_true(len(l) >= 1) else: assert_true(len(l) == 0) canvas.connect(on_mouse_move) assert_raises(ValueError, canvas.connect, _on_mouse_move) if sys.platform != 'darwin': # XXX knownfail, prob. needs warmup canvas.show(False) canvas.show() app.process_events() assert_raises(ValueError, canvas.connect, on_nonexist) # deprecation of "paint" with use_log_level('info', record=True, print_msg=False) as log: olderr = sys.stderr try: with open(os.devnull, 'w') as fid: sys.stderr = fid @canvas.events.paint.connect def fake(event): pass finally: sys.stderr = olderr assert_equal(len(log), 1) assert_in('deprecated', log[0]) # screenshots gl.glViewport(0, 0, *size) ss = _screenshot() assert_array_equal(ss.shape, size + (4,)) assert_equal(len(canvas._backend._vispy_get_geometry()), 4) if (app.backend_name.lower() != 'glut' and # XXX knownfail for Almar sys.platform != 'win32'): # XXX knownfail for windows assert_array_equal(canvas.size, size) assert_equal(len(canvas.position), 2) # XXX knawnfail, doesn't "take" # GLOO: should have an OpenGL context already, so these should work vert = VertexShader("void main (void) {gl_Position = pos;}") frag = FragmentShader("void main (void) {gl_FragColor = pos;}") program = Program(vert, frag) assert_raises(RuntimeError, program.activate) vert = VertexShader("uniform vec4 pos;" "void main (void) {gl_Position = pos;}") frag = FragmentShader("uniform vec4 pos;" "void main (void) {gl_FragColor = pos;}") program = Program(vert, frag) #uniform = program.uniforms[0] program['pos'] = [1, 2, 3, 4] program.activate() # should print #uniform.upload(program) program.detach(vert) program.detach(frag) assert_raises(RuntimeError, program.detach, vert) assert_raises(RuntimeError, program.detach, frag) vert = VertexShader("attribute vec4 pos;" "void main (void) {gl_Position = pos;}") frag = FragmentShader("void main (void) {}") program = Program(vert, frag) #attribute = program.attributes[0] program["pos"] = [1, 2, 3, 4] program.activate() #attribute.upload(program) # cannot get element count #assert_raises(RuntimeError, program.draw, 'POINTS') # use a real program vert = ("uniform mat4 u_model;" "attribute vec2 a_position; attribute vec4 a_color;" "varying vec4 v_color;" "void main (void) {v_color = a_color;" "gl_Position = u_model * vec4(a_position, 0.0, 1.0);" "v_color = a_color;}") frag = "void main() {gl_FragColor = vec4(0, 0, 0, 1);}" n, p = 250, 50 T = np.random.uniform(0, 2 * np.pi, n) position = np.zeros((n, 2), dtype=np.float32) position[:, 0] = np.cos(T) position[:, 1] = np.sin(T) color = np.ones((n, 4), dtype=np.float32) * (1, 1, 1, 1) data = np.zeros(n * p, [('a_position', np.float32, 2), ('a_color', np.float32, 4)]) data['a_position'] = np.repeat(position, p, axis=0) data['a_color'] = np.repeat(color, p, axis=0) program = Program(vert, frag) program.bind(VertexBuffer(data)) program['u_model'] = np.eye(4, dtype=np.float32) # different codepath if no call to activate() program.draw(gl.GL_POINTS) subset = IndexBuffer(np.arange(10, dtype=np.uint32)) program.draw(gl.GL_POINTS, subset) # bad programs frag_bad = ("varying vec4 v_colors") # no semicolon program = Program(vert, frag_bad) assert_raises(RuntimeError, program.activate) frag_bad = None # no fragment code. no main is not always enough program = Program(vert, frag_bad) assert_raises(ValueError, program.activate) # Timer timer = Timer(interval=0.001, connect=on_mouse_move, iterations=2, start=True, app=app) timer.start() timer.interval = 0.002 assert_equal(timer.interval, 0.002) assert_true(timer.running) sleep(.003) assert_true(timer.elapsed >= 0.002) timer.stop() assert_true(not timer.running) assert_true(timer.native) timer.disconnect() # test that callbacks take reasonable inputs _test_callbacks(canvas) # cleanup canvas.swap_buffers() canvas.update() app.process_events() # put this in even though __exit__ will call it to make sure we don't # have problems calling it multiple times canvas.close() # done by context
def test_set_uniform_vec4(self): vert = VertexShader("uniform vec4 color;") frag = FragmentShader("") program = Program(vert, frag) program["color"] = 1, 1, 1, 1
def test_application(): """Test application running""" app = use_app() print(app) # __repr__ without app app.create() wrong = 'glfw' if app.backend_name.lower() != 'glfw' else 'pyqt4' assert_raises(RuntimeError, use_app, wrong) app.process_events() print(app) # test __repr__ assert_raises(ValueError, Canvas, keys='foo') assert_raises(TypeError, Canvas, keys=dict(escape=1)) assert_raises(ValueError, Canvas, keys=dict(escape='foo')) # not an attr pos = [0, 0] if app.backend_module.capability['position'] else None size = (100, 100) # Use "with" statement so failures don't leave open window # (and test context manager behavior) title = 'default' with Canvas(title=title, size=size, app=app, show=True, position=pos) as canvas: context = canvas.context assert_true(canvas.create_native() is None) # should be done already assert_is(canvas.app, app) assert_true(canvas.native) assert_equal('swap_buffers', canvas.events.draw.callback_refs[-1]) canvas.measure_fps(0.001) sleep(0.002) canvas.update() app.process_events() assert_true(canvas.fps > 0) # Other methods print(canvas) # __repr__ assert_equal(canvas.title, title) canvas.title = 'you' with use_log_level('warning', record=True, print_msg=False) as l: if app.backend_module.capability['position']: # todo: disable more tests based on capability canvas.position = pos canvas.size = size if 'ipynb_vnc' in canvas.app.backend_name.lower(): assert_true(len(l) >= 1) else: assert_true(len(l) == 0) canvas.connect(on_mouse_move) assert_raises(ValueError, canvas.connect, _on_mouse_move) if sys.platform != 'darwin': # XXX knownfail, prob. needs warmup canvas.show(False) canvas.show() app.process_events() assert_raises(ValueError, canvas.connect, on_nonexist) # deprecation of "paint" with use_log_level('info', record=True, print_msg=False) as log: olderr = sys.stderr try: fid = StringIO() sys.stderr = fid @canvas.events.paint.connect def fake(event): pass finally: sys.stderr = olderr assert_equal(len(log), 1) assert_in('deprecated', log[0]) # screenshots gl.glViewport(0, 0, *size) ss = _screenshot() assert_array_equal(ss.shape, size + (4,)) assert_equal(len(canvas._backend._vispy_get_geometry()), 4) if sys.platform != 'win32': # XXX knownfail for windows assert_array_equal(canvas.size, size) assert_equal(len(canvas.position), 2) # XXX knawnfail, doesn't "take" # GLOO: should have an OpenGL context already, so these should work vert = "void main (void) {gl_Position = pos;}" frag = "void main (void) {gl_FragColor = pos;}" program = Program(vert, frag) assert_raises(RuntimeError, program.glir.flush, context.shared.parser) vert = "uniform vec4 pos;\nvoid main (void) {gl_Position = pos;}" frag = "uniform vec4 pos;\nvoid main (void) {gl_FragColor = pos;}" program = Program(vert, frag) #uniform = program.uniforms[0] program['pos'] = [1, 2, 3, 4] vert = "attribute vec4 pos;\nvoid main (void) {gl_Position = pos;}" frag = "void main (void) {}" program = Program(vert, frag) #attribute = program.attributes[0] program["pos"] = [1, 2, 3, 4] # use a real program program._glir.clear() vert = ("uniform mat4 u_model;" "attribute vec2 a_position; attribute vec4 a_color;" "varying vec4 v_color;" "void main (void) {v_color = a_color;" "gl_Position = u_model * vec4(a_position, 0.0, 1.0);" "v_color = a_color;}") frag = "void main() {gl_FragColor = vec4(0, 0, 0, 1);}" n, p = 250, 50 T = np.random.uniform(0, 2 * np.pi, n) position = np.zeros((n, 2), dtype=np.float32) position[:, 0] = np.cos(T) position[:, 1] = np.sin(T) color = np.ones((n, 4), dtype=np.float32) * (1, 1, 1, 1) data = np.zeros(n * p, [('a_position', np.float32, 2), ('a_color', np.float32, 4)]) data['a_position'] = np.repeat(position, p, axis=0) data['a_color'] = np.repeat(color, p, axis=0) program = Program(vert, frag) program.bind(VertexBuffer(data)) program['u_model'] = np.eye(4, dtype=np.float32) # different codepath if no call to activate() program.draw(gl.GL_POINTS) subset = IndexBuffer(np.arange(10, dtype=np.uint32)) program.draw(gl.GL_POINTS, subset) # bad programs frag_bad = ("varying vec4 v_colors") # no semicolon program = Program(vert, frag_bad) assert_raises(RuntimeError, program.glir.flush, context.shared.parser) frag_bad = None # no fragment code. no main is not always enough assert_raises(ValueError, Program, vert, frag_bad) # Timer timer = Timer(interval=0.001, connect=on_mouse_move, iterations=2, start=True, app=app) timer.start() timer.interval = 0.002 assert_equal(timer.interval, 0.002) assert_true(timer.running) sleep(.003) assert_true(timer.elapsed >= 0.002) timer.stop() assert_true(not timer.running) assert_true(timer.native) timer.disconnect() # test that callbacks take reasonable inputs _test_callbacks(canvas) # cleanup canvas.swap_buffers() canvas.update() app.process_events() # put this in even though __exit__ will call it to make sure we don't # have problems calling it multiple times canvas.close() # done by context