def testGetInfoLogForZeroLogSize(self): shader = VertexShader(['src']) shader.getInfoLogLength = lambda: 0 log = shader.getInfoLog() self.assertEquals(log, '')
def testGetInfoLogLength(self): shader = VertexShader(['src']) shader._get = Mock(return_value=123) actual = shader.getInfoLogLength() self.assertEquals(shader._get.call_args, ((gl.GL_INFO_LOG_LENGTH,), {})) self.assertEquals(actual, 123)
def testCompileCompilesShader(self, mockGl): shader = VertexShader(['src']) shader.getCompileStatus = lambda: True shader.getInfoLog = lambda: 'compilemessage' shader.compile() self.assertEquals(mockGl.glCompileShader.call_args[0], (shader.id,))
def testGetInfoLog(self, mockGl): expected = 'logmessage' mockGl.glGetShaderInfoLog.side_effect = mockGetInfoLog(expected) shader = VertexShader(['src']) shader.getInfoLogLength = lambda: len(expected) log = shader.getInfoLog() self.assertEquals(log, expected)
def testCompileRaisesOnFail(self): shader = VertexShader(['badsrc']) shader.getCompileStatus = lambda: False shader.getInfoLog = lambda: 'errormessage' try: shader.compile() self.fail('should raise') except CompileError, e: self.assertTrue('errormessage' in str(e))
def testGet(self, mockGl): mockGl.glGetShaderiv.side_effect = mockGet(123) shader = VertexShader(['src']) shader.id = object() actual = shader._get(456) self.assertEquals(mockGl.glGetShaderiv.call_args[0][:2], (shader.id, 456)) self.assertEquals(actual, 123)
def testCompileCreatesShaders(self, mockGl): mockGl.glCreateShader.return_value = 123 shader = VertexShader(['src']) shader.getCompileStatus = lambda: True shader.getInfoLog = DoNothing shader.compile() self.assertTrue(mockGl.glCreateShader.called) self.assertEquals(mockGl.glCreateShader.call_args[0], (shader.type,)) self.assertEquals(shader.id, 123)
def testCompileSetsShaderSource(self, mockGl): sources = ['one', 'two', 'three'] shader = VertexShader(sources) shader.getCompileStatus = lambda: True shader.compile() args = mockGl.glShaderSource.call_args[0] self.assertEquals(args[:2], (shader.id, 3)) dirarg = args[2]._objects['0'] actualSources = [dirarg[key] for key in sorted(dirarg.keys())] self.assertEquals(actualSources, sources) self.assertTrue(args[3] is None)
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(ValueError): program["A"] = 1
def test_init(self): shader = VertexShader() assert shader._handle == 0 assert shader.dirty == True assert shader.status == False assert shader.code == None assert shader.source == None
def __init__(self, verts=[], frags=[], count=0): """Initialize the program and register shaders to be linked. Parameters ---------- verts : list of vertex shaders Vertex shaders to be used by this program frags : list of fragment shaders Fragment shaders to be used by this program count : int Number of vertices this program will use Note ---- If several vertex shaders are specified, only one can contain the main function. If several fragment shaders are specified, only one can contain the main function. """ GLObject.__init__(self) self._count = count self._buffer = None # Get all vertex shaders self._verts = [] if type(verts) in [str, VertexShader]: verts = [verts] for shader in verts: if type(shader) is str: self._verts.append(VertexShader(shader)) elif shader not in self._verts: self._verts.append(shader) # Get all fragment shaders self._frags = [] if type(frags) in [str, FragmentShader]: frags = [frags] for shader in frags: if type(shader) is str: self._frags.append(FragmentShader(shader)) elif shader not in self._frags: self._frags.append(shader) # Build uniforms and attributes self._build_uniforms() self._build_attributes() # Build associated structured vertex buffer if count is given if self._count > 0: dtype = [] for attribute in self._attributes.values(): dtype.append(attribute.dtype) self._buffer = VertexBuffer(np.zeros(self._count, dtype=dtype)) self.bind(self._buffer)
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(verts = vert) with self.assertRaises(ValueError): program.activate() program = Program(frags = frag) with self.assertRaises(ValueError): program.activate()
def __init__(self, verts=[], frags=[]): """Initialize the program and register shaders to be linked. Parameters ---------- verts : list of vertex shaders frags : list of fragment shaders Note ---- If several vertex shaders are specified, only one can contain the main function. If several fragment shaders are specified, only one can contain the main function. """ GLObject.__init__(self) # Get all vertex shaders self._verts = [] if type(verts) in [str, VertexShader]: verts = [verts] for shader in verts: if type(shader) is str: self._verts.append(VertexShader(shader)) elif shader not in self._verts: self._verts.append(shader) # Get all fragment shaders self._frags = [] if type(frags) in [str, FragmentShader]: frags = [frags] for shader in frags: if type(shader) is str: self._frags.append(FragmentShader(shader)) elif shader not in self._frags: self._frags.append(shader) # Build uniforms and attributes self.build_uniforms() self.build_attributes()
def test_delete_no_context(self): shader = VertexShader() shader.delete()
def test_empty_build(self): shader = VertexShader() with self.assertRaises(ShaderException): shader.build()
def test_setcode(self): shader = VertexShader() shader._dirty = False shader.code = "" assert shader.dirty == True
def test_uniform_float(self): shader = VertexShader("uniform float color;") assert shader.uniforms == [("color", gl.GL_FLOAT)]
def test_attribute_float(self): shader = VertexShader("attribute float color;") assert shader.attributes == [("color", gl.GL_FLOAT)]
def test_empty_build(self): shader = VertexShader() with self.assertRaises(RuntimeError): shader.activate()
def test_uniform_array(self): shader = VertexShader("uniform float color[2];") assert shader.uniforms == [("color[0]", gl.GL_FLOAT), ("color[1]", gl.GL_FLOAT)]
def test_init(self): shader = VertexShader() assert shader._handle == -1 assert shader.code == None assert shader.source == None
def test_sourcecode(self): code = "/* Code */" shader = VertexShader(code) assert shader.code == code assert shader.source == "<string>"
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"
from shader import Program, VertexShader, FragmentShader from other.old_stuff.mathematics import create_transformation_matrix, create_perspective_matrix, sin, cos, pi from other.old_stuff.uniforms import TexturedMaterial, PointLight, SpotLight, SunLight, uniform_struct, \ uniform_struct_array # All calls to OpenGL functions must happen after we've created the context! window = Window(width=1024, height=1024) glEnable(GL_DEPTH_TEST) glEnable(GL_CULL_FACE) glCullFace(GL_BACK) glClearColor(0.1, 0.1, 0.12, 1.0) object_shader = Program( vertex_shader=VertexShader(path='shaders/lightning_shader.vs'), fragment_shader=FragmentShader( path='shaders/debug_lightning_shader_multiple_lights.fs'), uniforms=[ 'transform', 'view', 'projection', 'time', *uniform_struct('material', TexturedMaterial), *uniform_struct('spotlight', SpotLight), *uniform_struct_array('light', 4, PointLight), *uniform_struct('sunlight', SunLight) ], attributes=['position', 'normal', 'texture_coordinate']) lamp_shader = Program( vertex_shader=VertexShader(path='shaders/lamp_shader.vs'), fragment_shader=FragmentShader(path='shaders/lamp_shader.fs'), uniforms=['transform', 'view', 'projection', 'color'], attributes=['position'])
def test_init(self): shader = VertexShader() assert shader.type == gl.GL_VERTEX_SHADER
def test_uniform_vec4(self): shader = VertexShader("uniform vec4 color;") assert shader.uniforms == [("color", gl.GL_FLOAT_VEC4)]
def test_attributes(self): vert = VertexShader("attribute float A;") frag = FragmentShader("") program = Program(vert,frag) assert program.all_attributes == [ ("A", gl.GL_FLOAT) ]
def test_attribute_vec4(self): shader = VertexShader("attribute vec4 color;") assert shader.attributes == [("color", gl.GL_FLOAT_VEC4)]
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_uniform(self): vert = VertexShader("uniform float A;") frag = FragmentShader("uniform float A; uniform vec4 B;") program = Program(vert,frag) assert program.all_uniforms == [ ("A", gl.GL_FLOAT), ("B", gl.GL_FLOAT_VEC4) ]