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_empty_build(self):
shader = VertexShader()
with self.assertRaises(ShaderException):
shader.build()
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_delete_no_context(self):
shader = VertexShader()
shader.delete()
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_setcode(self):
shader = VertexShader()
shader._dirty = False
shader.code = ""
assert shader.dirty == True
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) ]
def test_empty_build(self):
shader = VertexShader()
with self.assertRaises(RuntimeError):
shader.activate()
