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_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_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_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_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_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_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)
#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_setitem(self):
vert = VertexShader("")
frag = FragmentShader("")
program = Program(vert, frag)
def modifier(p):
p["A"] = 1
self.assertRaises(NameError, modifier, program)
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_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_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_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_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_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_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_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_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
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_set_uniform_vec4(self):
vert = VertexShader("uniform vec4 color;")
frag = FragmentShader("")
program = Program(vert, frag)
program["color"] = 1, 1, 1, 1
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_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_delete_no_context(self):
program = Program()
program.delete()
def test_init(self):
program = Program()
assert program._handle == 0
assert program._need_update == False
assert program._valid == False
assert program.shaders == []
