def on_initialize(self, event):
gl.glClearColor(1,1,1,1)
gl.glEnable(gl.GL_DEPTH_TEST)
# Create shader program
self._prog_handle = gl.glCreateProgram()
# Create vertex shader
shader = gl.glCreateShader(gl.GL_VERTEX_SHADER)
gl.glShaderSource(shader, VERT_CODE)
gl.glCompileShader(shader)
status = gl.glGetShaderiv(shader, gl.GL_COMPILE_STATUS)
if not status:
# We could show more useful info here, but that takes a few lines
raise RuntimeError('Vertex shader did not compile.')
else:
gl.glAttachShader(self._prog_handle, shader)
# Create fragment shader
shader = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
gl.glShaderSource(shader, FRAG_CODE)
gl.glCompileShader(shader)
status = gl.glGetShaderiv(shader, gl.GL_COMPILE_STATUS)
if not status:
# We could show more useful info here, but that takes a few lines
raise RuntimeError('Fragment shader did not compile.')
else:
gl.glAttachShader(self._prog_handle, shader)
# Link
gl.glLinkProgram(self._prog_handle)
status = gl.glGetProgramiv(self._prog_handle, gl.GL_LINK_STATUS)
if not status:
# We could show more useful info here, but that takes a few lines
raise RuntimeError('Program did not link.')
# Create texture
im = dataio.crate()
self._tex_handle = gl.glGenTextures(1)
gl.glPixelStorei(gl.GL_UNPACK_ALIGNMENT, 1)
gl.glBindTexture(gl.GL_TEXTURE_2D, self._tex_handle)
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGB,
im.shape[1], im.shape[0], 0, gl.GL_RGB, gl.GL_UNSIGNED_BYTE, im)
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR)
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR)
if use_buffers:
# Create vertex buffer
self._positions_handle = gl.glGenBuffers(1)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self._positions_handle)
gl.glBufferData(gl.GL_ARRAY_BUFFER, positions.nbytes, positions, gl.GL_DYNAMIC_DRAW)
#
self._texcoords_handle = gl.glGenBuffers(1)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self._texcoords_handle)
gl.glBufferData(gl.GL_ARRAY_BUFFER, texcoords.nbytes, texcoords, gl.GL_DYNAMIC_DRAW)
# Create buffer for faces
self._faces_handle = gl.glGenBuffers(1)
gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, self._faces_handle)
gl.glBufferData(gl.GL_ELEMENT_ARRAY_BUFFER, faces.nbytes, faces, gl.GL_DYNAMIC_DRAW)
def on_initialize(self, event):
self.program = gl.glCreateProgram()
vertex = gl.glCreateShader(gl.GL_VERTEX_SHADER)
fragment = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
gl.glShaderSource(vertex, vertex_code)
gl.glShaderSource(fragment, fragment_code)
gl.glCompileShader(vertex)
gl.glCompileShader(fragment)
gl.glAttachShader(self.program, vertex)
gl.glAttachShader(self.program, fragment)
gl.glLinkProgram(self.program)
gl.glDetachShader(self.program, vertex)
gl.glDetachShader(self.program, fragment)
gl.glUseProgram(self.program)
n = 10000000
self.data = np.zeros((n, 4), dtype=np.float32)
self.data[:, :2] = .15 * prng.randn(n, 2)
self.data[:, 3] = 1.
vbuffer = gl.glCreateBuffer()
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vbuffer)
gl.glBufferData(gl.GL_ARRAY_BUFFER, self.data, gl.GL_DYNAMIC_DRAW)
stride = self.data.strides[0]
offset = 0
loc = gl.glGetAttribLocation(self.program, "a_position")
gl.glEnableVertexAttribArray(loc)
gl.glVertexAttribPointer(loc, 4, gl.GL_FLOAT, False, stride, offset)
gl.glClearColor(0, 0, 0, 1)
gl.glEnable(34370)
gl.glEnable(34913)
# Auto-close after 10 seconds
self.timer = app.Timer(10, self.on_timer, start=True)
def on_initialize(self, event):
gl.glClearColor(0, 0, 0, 1)
# Enable blending
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE)
# Create shader program
self._prog_handle = gl.glCreateProgram()
# Create vertex shader
shader = gl.glCreateShader(gl.GL_VERTEX_SHADER)
gl.glShaderSource_compat(shader, VERT_CODE)
gl.glCompileShader(shader)
status = gl.glGetShaderiv(shader, gl.GL_COMPILE_STATUS)
if not status:
# We could show more useful info here, but that takes a few lines
raise RuntimeError('Vertex shader did not compile.')
else:
gl.glAttachShader(self._prog_handle, shader)
# Create fragment shader
shader = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
need_enabled = gl.glShaderSource_compat(shader, FRAG_CODE)
gl.glCompileShader(shader)
status = gl.glGetShaderiv(shader, gl.GL_COMPILE_STATUS)
if not status:
# We could show more useful info here, but that takes a few lines
raise RuntimeError('Fragment shader did not compile.')
else:
gl.glAttachShader(self._prog_handle, shader)
# Enable point sprites
for enum in need_enabled:
gl.glEnable(enum)
# Link
gl.glLinkProgram(self._prog_handle)
status = gl.glGetProgramiv(self._prog_handle, gl.GL_LINK_STATUS)
if not status:
# We could show more useful info here, but that takes a few lines
raise RuntimeError('Program did not link.')
# Create texture
self._tex_handle = gl.glGenTextures(1)
gl.glPixelStorei(gl.GL_UNPACK_ALIGNMENT, 1)
gl.glBindTexture(gl.GL_TEXTURE_2D, self._tex_handle)
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_LUMINANCE, im1.shape[1],
im1.shape[0], 0, gl.GL_LUMINANCE, gl.GL_FLOAT,
im1.astype(np.float32))
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER,
gl.GL_LINEAR)
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER,
gl.GL_LINEAR)
# Create vertex buffer
self._vbo_handle = gl.glGenBuffers(1)
def on_initialize(self, event):
# Build & activate program
self.program = gl.glCreateProgram()
vertex = gl.glCreateShader(gl.GL_VERTEX_SHADER)
fragment = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
gl.glShaderSource(vertex, vertex_code)
gl.glShaderSource(fragment, fragment_code)
gl.glCompileShader(vertex)
gl.glCompileShader(fragment)
gl.glAttachShader(self.program, vertex)
gl.glAttachShader(self.program, fragment)
gl.glLinkProgram(self.program)
gl.glDetachShader(self.program, vertex)
gl.glDetachShader(self.program, fragment)
gl.glUseProgram(self.program)
# Build vertex buffer
n = 10000
self.data = np.zeros(n,
dtype=[('lifetime', np.float32),
('start', np.float32, 3),
('end', np.float32, 3)])
vbuffer = gl.glCreateBuffer()
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vbuffer)
gl.glBufferData(gl.GL_ARRAY_BUFFER, self.data, gl.GL_DYNAMIC_DRAW)
# Bind buffer attributes
stride = self.data.strides[0]
offset = 0
loc = gl.glGetAttribLocation(self.program, "lifetime")
gl.glEnableVertexAttribArray(loc)
gl.glVertexAttribPointer(loc, 1, gl.GL_FLOAT, False, stride, offset)
offset = self.data.dtype["lifetime"].itemsize
loc = gl.glGetAttribLocation(self.program, "start")
gl.glEnableVertexAttribArray(loc)
gl.glVertexAttribPointer(loc, 3, gl.GL_FLOAT, False, stride, offset)
offset = self.data.dtype["start"].itemsize
loc = gl.glGetAttribLocation(self.program, "end")
gl.glEnableVertexAttribArray(loc)
gl.glVertexAttribPointer(loc, 3, gl.GL_FLOAT, False, stride, offset)
# OpenGL initalization
self.elapsed_time = 0
gl.glClearColor(0, 0, 0, 1)
gl.glDisable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE)
gl.glEnable(34370) # gl.GL_VERTEX_PROGRAM_POINT_SIZE
gl.glEnable(34913) # gl.GL_POINT_SPRITE
gl.glViewport(0, 0, *self.physical_size)
self.new_explosion()
self.timer = app.Timer('auto', self.on_timer, start=True)
def on_initialize(self, event):
gl.glClearColor(0,0,0,1);
# Enable blending
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE)
# Create shader program
self._prog_handle = gl.glCreateProgram()
# Create vertex shader
shader = gl.glCreateShader(gl.GL_VERTEX_SHADER)
gl.glShaderSource_compat(shader, VERT_CODE)
gl.glCompileShader(shader)
status = gl.glGetShaderiv(shader, gl.GL_COMPILE_STATUS)
if not status:
# We could show more useful info here, but that takes a few lines
raise RuntimeError('Vertex shader did not compile.')
else:
gl.glAttachShader(self._prog_handle, shader)
# Create fragment shader
shader = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
need_enabled = gl.glShaderSource_compat(shader, FRAG_CODE)
gl.glCompileShader(shader)
status = gl.glGetShaderiv(shader, gl.GL_COMPILE_STATUS)
if not status:
# We could show more useful info here, but that takes a few lines
raise RuntimeError('Fragment shader did not compile.')
else:
gl.glAttachShader(self._prog_handle, shader)
# Enable point sprites
for enum in need_enabled:
gl.glEnable(enum)
# Link
gl.glLinkProgram(self._prog_handle)
status = gl.glGetProgramiv(self._prog_handle, gl.GL_LINK_STATUS)
if not status:
# We could show more useful info here, but that takes a few lines
raise RuntimeError('Program did not link.')
# Create texture
self._tex_handle = gl.glGenTextures(1)
gl.glPixelStorei(gl.GL_UNPACK_ALIGNMENT, 1)
gl.glBindTexture(gl.GL_TEXTURE_2D, self._tex_handle)
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_LUMINANCE,
im1.shape[1], im1.shape[0], 0, gl.GL_LUMINANCE, gl.GL_FLOAT,
im1.astype(np.float32))
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR)
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR)
# Create vertex buffer
self._vbo_handle = gl.glGenBuffers(1)
def on_initialize(self, event):
# Build & activate program
self.program = gl.glCreateProgram()
vertex = gl.glCreateShader(gl.GL_VERTEX_SHADER)
fragment = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
gl.glShaderSource(vertex, vertex_code)
gl.glShaderSource(fragment, fragment_code)
gl.glCompileShader(vertex)
gl.glCompileShader(fragment)
gl.glAttachShader(self.program, vertex)
gl.glAttachShader(self.program, fragment)
gl.glLinkProgram(self.program)
gl.glDetachShader(self.program, vertex)
gl.glDetachShader(self.program, fragment)
gl.glUseProgram(self.program)
# Build vertex buffer
n = 10000
self.data = np.zeros(n, dtype=[('lifetime', np.float32, 1),
('start', np.float32, 3),
('end', np.float32, 3)])
vbuffer = gl.glCreateBuffer()
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vbuffer)
gl.glBufferData(gl.GL_ARRAY_BUFFER, self.data, gl.GL_DYNAMIC_DRAW)
# Bind buffer attributes
stride = self.data.strides[0]
offset = 0
loc = gl.glGetAttribLocation(self.program, "lifetime")
gl.glEnableVertexAttribArray(loc)
gl.glVertexAttribPointer(loc, 1, gl.GL_FLOAT, False, stride, offset)
offset = self.data.dtype["lifetime"].itemsize
loc = gl.glGetAttribLocation(self.program, "start")
gl.glEnableVertexAttribArray(loc)
gl.glVertexAttribPointer(loc, 3, gl.GL_FLOAT, False, stride, offset)
offset = self.data.dtype["start"].itemsize
loc = gl.glGetAttribLocation(self.program, "end")
gl.glEnableVertexAttribArray(loc)
gl.glVertexAttribPointer(loc, 3, gl.GL_FLOAT, False, stride, offset)
# OpenGL initalization
self.elapsed_time = 0
gl.glClearColor(0, 0, 0, 1)
gl.glDisable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE)
gl.glEnable(34370) # gl.GL_VERTEX_PROGRAM_POINT_SIZE
gl.glEnable(34913) # gl.GL_POINT_SPRITE
gl.glViewport(0, 0, *self.physical_size)
self.new_explosion()
self.timer = app.Timer('auto', self.on_timer, start=True)
def draw(self):
if self._glsl:
fragment = fragment_template % self._glsl
self._glsl = None
# Check to see if the shader will compile successfully before we
# set it. We do this here because the ShaderWatcher runs in a
# different thread and so can't access the GL context.
frag_handle = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
gl.glShaderSource(frag_handle, fragment)
gl.glCompileShader(frag_handle)
status = gl.glGetShaderParameter(frag_handle, gl.GL_COMPILE_STATUS)
if not status:
errors = gl.glGetShaderInfoLog(frag_handle)
errors = self.process_errors(errors)
print("Shader failed to compile:", file=sys.stderr)
print(errors, file=sys.stderr)
# Switch to error shader
self._glsl = error_shader
self.update()
else:
self.program.set_shaders(vertex, fragment)
gl.glDeleteShader(frag_handle)
if self._interactive:
self.program.draw()
if self._ffmpeg_pipe is not None:
img = _screenshot()
self.write_video_frame(img)
self._render_frame_index += 1
if self._render_frame_count is not None and self._render_frame_index >= self._render_frame_count:
app.quit()
return
self.advance_time()
else:
with self._fbo:
rs = list(self._render_size)
if self._tile_coord[0] + rs[0] > self._output_size[0]:
rs[0] = self._output_size[0] - self._tile_coord[0]
if self._tile_coord[1] + rs[1] > self._output_size[1]:
rs[1] = self._output_size[1] - self._tile_coord[1]
gloo.set_viewport(0, 0, *rs)
self.program['iOffset'] = self._tile_coord
self.program.draw()
img = _screenshot()
row = self._output_size[1] - self._tile_coord[1] - rs[1]
col = self._tile_coord[0]
self._img[row:row + rs[1], col:col + rs[0], :] = img
def _test_object_creation_and_deletion():
# Stuff that is originally glGenX
# Note that if we test glIsTexture(x), we cannot assume x to be a
# nonexisting texture; we might have created a texture in another
# test and failed to clean it up.
# Create/delete texture
#assert_equal(gl.glIsTexture(12), False)
handle = gl.glCreateTexture()
gl.glBindTexture(gl.GL_TEXTURE_2D, handle)
assert_equal(gl.glIsTexture(handle), True)
gl.glDeleteTexture(handle)
assert_equal(gl.glIsTexture(handle), False)
# Create/delete buffer
#assert_equal(gl.glIsBuffer(12), False)
handle = gl.glCreateBuffer()
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, handle)
assert_equal(gl.glIsBuffer(handle), True)
gl.glDeleteBuffer(handle)
assert_equal(gl.glIsBuffer(handle), False)
# Create/delete framebuffer
#assert_equal(gl.glIsFramebuffer(12), False)
handle = gl.glCreateFramebuffer()
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, handle)
assert_equal(gl.glIsFramebuffer(handle), True)
gl.glDeleteFramebuffer(handle)
assert_equal(gl.glIsFramebuffer(handle), False)
# Create/delete renderbuffer
#assert_equal(gl.glIsRenderbuffer(12), False)
handle = gl.glCreateRenderbuffer()
gl.glBindRenderbuffer(gl.GL_RENDERBUFFER, handle)
assert_equal(gl.glIsRenderbuffer(handle), True)
gl.glDeleteRenderbuffer(handle)
assert_equal(gl.glIsRenderbuffer(handle), False)
# Stuff that is originally called glCreate
# Create/delete program
#assert_equal(gl.glIsProgram(12), False)
handle = gl.glCreateProgram()
assert_equal(gl.glIsProgram(handle), True)
gl.glDeleteProgram(handle)
assert_equal(gl.glIsProgram(handle), False)
# Create/delete shader
#assert_equal(gl.glIsShader(12), False)
handle = gl.glCreateShader(gl.GL_VERTEX_SHADER)
assert_equal(gl.glIsShader(handle), True)
gl.glDeleteShader(handle)
assert_equal(gl.glIsShader(handle), False)
gl.check_error()
def draw(self):
if self._glsl:
fragment = fragment_template % self._glsl
self._glsl = None
# Check to see if the shader will compile successfully before we
# set it. We do this here because the ShaderWatcher runs in a
# different thread and so can't access the GL context.
frag_handle = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
gl.glShaderSource(frag_handle, fragment)
gl.glCompileShader(frag_handle)
status = gl.glGetShaderParameter(frag_handle, gl.GL_COMPILE_STATUS)
if not status:
errors = gl.glGetShaderInfoLog(frag_handle)
errors = self.process_errors(errors)
print("Shader failed to compile:", file=sys.stderr)
print(errors, file=sys.stderr)
# Switch to error shader
self._glsl = error_shader
self.update()
else:
self.program.set_shaders(vertex, fragment)
gl.glDeleteShader(frag_handle)
if self._interactive:
self.program.draw()
if self._ffmpeg_pipe is not None:
img = _screenshot()
self.write_video_frame(img)
self._render_frame_index += 1
if self._render_frame_count is not None and self._render_frame_index >= self._render_frame_count:
app.quit()
return
self.advance_time()
else:
with self._fbo:
rs = list(self._render_size)
if self._tile_coord[0] + rs[0] > self._output_size[0]:
rs[0] = self._output_size[0] - self._tile_coord[0]
if self._tile_coord[1] + rs[1] > self._output_size[1]:
rs[1] = self._output_size[1] - self._tile_coord[1]
gloo.set_viewport(0, 0, *rs)
self.program['iOffset'] = self._tile_coord
self.program.draw()
img = _screenshot()
row = self._output_size[1] - self._tile_coord[1] - rs[1]
col = self._tile_coord[0]
self._img[row:row + rs[1], col:col + rs[0], :] = img
def _test_object_creation_and_deletion():
# Stuff that is originally glGenX
# Note that if we test glIsTexture(x), we cannot assume x to be a
# nonexisting texture; we might have created a texture in another
# test and failed to clean it up.
# Create/delete texture
#assert_equal(gl.glIsTexture(12), False)
handle = gl.glCreateTexture()
gl.glBindTexture(gl.GL_TEXTURE_2D, handle)
assert_equal(gl.glIsTexture(handle), True)
gl.glDeleteTexture(handle)
assert_equal(gl.glIsTexture(handle), False)
# Create/delete buffer
#assert_equal(gl.glIsBuffer(12), False)
handle = gl.glCreateBuffer()
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, handle)
assert_equal(gl.glIsBuffer(handle), True)
gl.glDeleteBuffer(handle)
assert_equal(gl.glIsBuffer(handle), False)
# Create/delete framebuffer
#assert_equal(gl.glIsFramebuffer(12), False)
handle = gl.glCreateFramebuffer()
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, handle)
assert_equal(gl.glIsFramebuffer(handle), True)
gl.glDeleteFramebuffer(handle)
assert_equal(gl.glIsFramebuffer(handle), False)
# Create/delete renderbuffer
#assert_equal(gl.glIsRenderbuffer(12), False)
handle = gl.glCreateRenderbuffer()
gl.glBindRenderbuffer(gl.GL_RENDERBUFFER, handle)
assert_equal(gl.glIsRenderbuffer(handle), True)
gl.glDeleteRenderbuffer(handle)
assert_equal(gl.glIsRenderbuffer(handle), False)
# Stuff that is originally called glCreate
# Create/delete program
#assert_equal(gl.glIsProgram(12), False)
handle = gl.glCreateProgram()
assert_equal(gl.glIsProgram(handle), True)
gl.glDeleteProgram(handle)
assert_equal(gl.glIsProgram(handle), False)
# Create/delete shader
#assert_equal(gl.glIsShader(12), False)
handle = gl.glCreateShader(gl.GL_VERTEX_SHADER)
assert_equal(gl.glIsShader(handle), True)
gl.glDeleteShader(handle)
assert_equal(gl.glIsShader(handle), False)
gl.check_error()
def on_initialize(self, event):
gl.glClearColor(1, 1, 1, 1)
gl.glEnable(gl.GL_DEPTH_TEST)
# Create shader program
self._prog_handle = gl.glCreateProgram()
# Create vertex shader
shader = gl.glCreateShader(gl.GL_VERTEX_SHADER)
gl.glShaderSource(shader, VERT_CODE)
gl.glCompileShader(shader)
status = gl.glGetShaderiv(shader, gl.GL_COMPILE_STATUS)
if not status:
# We could show more useful info here, but that takes a few lines
raise RuntimeError('Vertex shader did not compile.')
else:
gl.glAttachShader(self._prog_handle, shader)
# Create fragment shader
shader = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
gl.glShaderSource(shader, FRAG_CODE)
gl.glCompileShader(shader)
status = gl.glGetShaderiv(shader, gl.GL_COMPILE_STATUS)
if not status:
# We could show more useful info here, but that takes a few lines
raise RuntimeError('Fragment shader did not compile.')
else:
gl.glAttachShader(self._prog_handle, shader)
# Link
gl.glLinkProgram(self._prog_handle)
status = gl.glGetProgramiv(self._prog_handle, gl.GL_LINK_STATUS)
if not status:
# We could show more useful info here, but that takes a few lines
raise RuntimeError('Program did not link.')
# Create texture
im = dataio.crate()
self._tex_handle = gl.glGenTextures(1)
gl.glPixelStorei(gl.GL_UNPACK_ALIGNMENT, 1)
gl.glBindTexture(gl.GL_TEXTURE_2D, self._tex_handle)
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGB, im.shape[1],
im.shape[0], 0, gl.GL_RGB, gl.GL_UNSIGNED_BYTE, im)
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER,
gl.GL_LINEAR)
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER,
gl.GL_LINEAR)
if use_buffers:
# Create vertex buffer
self._positions_handle = gl.glGenBuffers(1)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self._positions_handle)
gl.glBufferData(gl.GL_ARRAY_BUFFER, positions.nbytes, positions,
gl.GL_DYNAMIC_DRAW)
#
self._texcoords_handle = gl.glGenBuffers(1)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self._texcoords_handle)
gl.glBufferData(gl.GL_ARRAY_BUFFER, texcoords.nbytes, texcoords,
gl.GL_DYNAMIC_DRAW)
# Create buffer for faces
self._faces_handle = gl.glGenBuffers(1)
gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, self._faces_handle)
gl.glBufferData(gl.GL_ELEMENT_ARRAY_BUFFER, faces.nbytes, faces,
gl.GL_DYNAMIC_DRAW)
def _prepare_vis():
objects = []
# --- program and shaders
# Create program and shaders
hprog = gl.glCreateProgram()
hvert = gl.glCreateShader(gl.GL_VERTEX_SHADER)
hfrag = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
objects.append((gl.glDeleteProgram, hprog))
objects.append((gl.glDeleteShader, hvert))
objects.append((gl.glDeleteShader, hfrag))
# Compile source code
gl.glShaderSource_compat(hvert, VERT)
gl.glShaderSource_compat(hfrag, FRAG)
gl.glCompileShader(hvert)
gl.glCompileShader(hfrag)
# Check
assert_equal(gl.glGetShaderInfoLog(hvert), '')
assert_equal(gl.glGetShaderInfoLog(hfrag), '')
assert_equal(gl.glGetShaderParameter(hvert, gl.GL_COMPILE_STATUS), 1)
assert_equal(gl.glGetShaderParameter(hfrag, gl.GL_COMPILE_STATUS), 1)
# Attach and link
gl.glAttachShader(hprog, hvert)
gl.glAttachShader(hprog, hfrag)
# touch glDetachShader
gl.glDetachShader(hprog, hvert)
gl.glAttachShader(hprog, hvert)
gl.glLinkProgram(hprog)
# Test that indeed these shaders are attached
attached_shaders = gl.glGetAttachedShaders(hprog)
assert_equal(set(attached_shaders), set([hvert, hfrag]))
# Check
assert_equal(gl.glGetProgramInfoLog(hprog), '')
assert_equal(gl.glGetProgramParameter(hprog, gl.GL_LINK_STATUS), 1)
gl.glValidateProgram(hprog)
assert_equal(gl.glGetProgramParameter(hprog, gl.GL_VALIDATE_STATUS), 1)
# Use it!
gl.glUseProgram(hprog)
# Bind one attribute
gl.glBindAttribLocation(hprog, 1, 'a_2')
# Check if all is ok
assert_equal(gl.glGetError(), 0)
# Check source
vert_source = gl.glGetShaderSource(hvert)
assert_true('attribute vec2 a_2;' in vert_source)
# --- get information on attributes and uniforms
# Count attribbutes and uniforms
natt = gl.glGetProgramParameter(hprog, gl.GL_ACTIVE_ATTRIBUTES)
nuni = gl.glGetProgramParameter(hprog, gl.GL_ACTIVE_UNIFORMS)
assert_equal(natt, 4)
assert_equal(nuni, 4+4+3+1)
# Get names
names = {}
for i in range(natt):
name, count, type = gl.glGetActiveAttrib(hprog, i)
names[name] = type
assert_equal(count, 1)
for i in range(nuni):
name, count, type = gl.glGetActiveUniform(hprog, i)
names[name] = type
assert_equal(count, 1)
# Check
assert_equal(names['a_1'], gl.GL_FLOAT)
assert_equal(names['a_2'], gl.GL_FLOAT_VEC2)
assert_equal(names['a_3'], gl.GL_FLOAT_VEC3)
assert_equal(names['a_4'], gl.GL_FLOAT_VEC4)
assert_equal(names['s_1'], gl.GL_SAMPLER_2D)
#
for i, type in enumerate([gl.GL_FLOAT, gl.GL_FLOAT_VEC2,
gl.GL_FLOAT_VEC3, gl.GL_FLOAT_VEC4]):
assert_equal(names['u_f%i' % (i+1)], type)
for i, type in enumerate([gl.GL_INT, gl.GL_INT_VEC2,
gl.GL_INT_VEC3, gl.GL_INT_VEC4]):
assert_equal(names['u_i%i' % (i+1)], type)
for i, type in enumerate([gl.GL_FLOAT_MAT2, gl.GL_FLOAT_MAT3,
gl.GL_FLOAT_MAT4]):
assert_equal(names['u_m%i' % (i+2)], type)
# Check if all is ok
assert_equal(gl.glGetError(), 0)
# --- texture
# Create, bind, activate
htex = gl.glCreateTexture()
objects.append((gl.glDeleteTexture, htex))
gl.glPixelStorei(gl.GL_UNPACK_ALIGNMENT, 1)
gl.glBindTexture(gl.GL_TEXTURE_2D, htex)
# Allocate data and upload
# This data is luminance and not C-contiguous
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_LUMINANCE, gl.GL_LUMINANCE,
gl.GL_UNSIGNED_BYTE, im2) # touch
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_LUMINANCE, gl.GL_LUMINANCE,
gl.GL_UNSIGNED_BYTE, im2.shape[:2])
gl.glTexSubImage2D(gl.GL_TEXTURE_2D, 0, 0, 0, gl.GL_LUMINANCE,
gl.GL_UNSIGNED_BYTE, im2)
# Set texture parameters (use f and i to touch both)
T = gl.GL_TEXTURE_2D
gl.glTexParameterf(T, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR)
gl.glTexParameteri(T, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR)
# Re-allocate data and upload
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGB, gl.GL_RGB,
gl.GL_UNSIGNED_BYTE, im1.shape[:2])
gl.glTexSubImage2D(gl.GL_TEXTURE_2D, 0, 0, 0, gl.GL_RGB,
gl.GL_UNSIGNED_BYTE, im1)
# Attach!
loc = gl.glGetUniformLocation(hprog, 's_1')
unit = 0
gl.glActiveTexture(gl.GL_TEXTURE0+unit)
gl.glUniform1i(loc, unit)
# Mipmaps (just to touch this function)
gl.glGenerateMipmap(gl.GL_TEXTURE_2D)
# Check min filter (touch getTextParameter)
minfilt = gl.glGetTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER)
assert_equal(minfilt, gl.GL_LINEAR)
# Check if all is ok
assert_equal(gl.glGetError(), 0)
# --- buffer vec2 (contiguous VBO)
# Create buffer
hbuf2 = gl.glCreateBuffer()
objects.append((gl.glDeleteBuffer, hbuf2))
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, hbuf2)
# Allocate and set data
gl.glBufferData(gl.GL_ARRAY_BUFFER, buf2.nbytes, gl.GL_DYNAMIC_DRAW)
gl.glBufferSubData(gl.GL_ARRAY_BUFFER, 0, buf2)
# Attach!
loc = gl.glGetAttribLocation(hprog, 'a_2')
gl.glDisableVertexAttribArray(loc) # touch
gl.glEnableVertexAttribArray(loc)
gl.glVertexAttribPointer(loc, 2, gl.GL_FLOAT, False, 2*4, 0)
# Check (touch glGetBufferParameter, glGetVertexAttrib and
# glGetVertexAttribOffset)
size = gl.glGetBufferParameter(gl.GL_ARRAY_BUFFER, gl.GL_BUFFER_SIZE)
assert_equal(size, buf2.nbytes)
stride = gl.glGetVertexAttrib(loc, gl.GL_VERTEX_ATTRIB_ARRAY_STRIDE)
assert_equal(stride, 2*4)
offset = gl.glGetVertexAttribOffset(loc, gl.GL_VERTEX_ATTRIB_ARRAY_POINTER)
assert_equal(offset, 0)
# Check if all is ok
assert_equal(gl.glGetError(), 0)
# --- buffer vec3 (non-contiguous VBO)
# Create buffer
hbuf3 = gl.glCreateBuffer()
objects.append((gl.glDeleteBuffer, hbuf3))
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, hbuf3)
# Allocate and set data
gl.glBufferData(gl.GL_ARRAY_BUFFER, buf3.nbytes, gl.GL_DYNAMIC_DRAW)
gl.glBufferSubData(gl.GL_ARRAY_BUFFER, 0, buf3)
# Attach!
loc = gl.glGetAttribLocation(hprog, 'a_3')
gl.glEnableVertexAttribArray(loc)
gl.glVertexAttribPointer(loc, 3, gl.GL_FLOAT, False, 3*4, 0)
# Check if all is ok
assert_equal(gl.glGetError(), 0)
# --- buffer vec4 (client vertex data)
# Select no FBO
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, 0)
# Attach!
loc = gl.glGetAttribLocation(hprog, 'a_4')
gl.glEnableVertexAttribArray(loc)
gl.glVertexAttribPointer(loc, 4, gl.GL_FLOAT, False, 4*4, buf4)
# Check if all is ok
assert_equal(gl.glGetError(), 0)
# --- element buffer
# Create buffer
global helements
helements = gl.glCreateBuffer()
objects.append((gl.glDeleteBuffer, helements))
gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, helements)
# Allocate and set data
gl.glBufferData(gl.GL_ELEMENT_ARRAY_BUFFER, elements, gl.GL_DYNAMIC_DRAW)
gl.glBufferSubData(gl.GL_ELEMENT_ARRAY_BUFFER, 0, elements)
# Turn off
gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, 0)
# Check if all is ok
assert_equal(gl.glGetError(), 0)
# --- uniforms
# Set integer uniforms to 0
# We set them twice just to touch both i and iv functions
for i, fun1, fun2 in [(1, gl.glUniform1i, gl.glUniform1iv),
(2, gl.glUniform2i, gl.glUniform2iv),
(3, gl.glUniform3i, gl.glUniform3iv),
(4, gl.glUniform4i, gl.glUniform4iv)]:
name = 'u_i%i' % i
value = [0] * i
loc = gl.glGetUniformLocation(hprog, name)
fun1(loc, *value) # e.g. glUniform4i
fun2(loc, 1, value) # e.g. glUniform4iv
# Set float uniforms to 1.0
# We set them twice just to touch both i and iv functions
for i, fun1, fun2 in [(1, gl.glUniform1f, gl.glUniform1fv),
(2, gl.glUniform2f, gl.glUniform2fv),
(3, gl.glUniform3f, gl.glUniform3fv),
(4, gl.glUniform4f, gl.glUniform4fv)]:
name = 'u_f%i' % i
value = [1.0] * i
loc = gl.glGetUniformLocation(hprog, name)
fun1(loc, *value) # e.g. glUniform4f
fun2(loc, 1, value) # e.g. glUniform4fv
# Set matrix uniforms
m = np.eye(5, dtype='float32')
loc = gl.glGetUniformLocation(hprog, 'u_m2')
gl.glUniformMatrix2fv(loc, 1, False, m[:2, :2])
#
loc = gl.glGetUniformLocation(hprog, 'u_m3')
m = np.eye(3, dtype='float32')
gl.glUniformMatrix3fv(loc, 1, False, m[:3, :3])
#
loc = gl.glGetUniformLocation(hprog, 'u_m4')
m = np.eye(4, dtype='float32')
gl.glUniformMatrix4fv(loc, 1, False, m[:4, :4])
# Check some uniforms
loc = gl.glGetUniformLocation(hprog, 'u_i1')
assert_equal(gl.glGetUniform(hprog, loc), 0)
loc = gl.glGetUniformLocation(hprog, 'u_i2')
assert_equal(gl.glGetUniform(hprog, loc), (0, 0))
loc = gl.glGetUniformLocation(hprog, 'u_f2')
assert_equal(gl.glGetUniform(hprog, loc), (1.0, 1.0))
# Check if all is ok
assert_equal(gl.glGetError(), 0)
# --- attributes
# Constant values for attributes. We do not even use this ...
loc = gl.glGetAttribLocation(hprog, 'a_1')
gl.glVertexAttrib1f(loc, 1.0)
loc = gl.glGetAttribLocation(hprog, 'a_2')
gl.glVertexAttrib2f(loc, 1.0, 1.0)
loc = gl.glGetAttribLocation(hprog, 'a_3')
gl.glVertexAttrib3f(loc, 1.0, 1.0, 1.0)
loc = gl.glGetAttribLocation(hprog, 'a_4')
gl.glVertexAttrib4f(loc, 1.0, 1.0, 1.0, 1.0)
# --- flush and finish
# Not really necessary, but we want to touch the functions
gl.glFlush()
gl.glFinish()
#print([i[1] for i in objects])
return objects
def on_initialize(self, event):
# Build data
self.data = np.zeros(4, [("position", np.float32, 2),
("color", np.float32, 4)])
self.data['color'] = [(1, 0, 0, 1), (0, 1, 0, 1), (0, 0, 1, 1),
(1, 1, 0, 1)]
self.data['position'] = [(-1, -1), (-1, +1), (+1, -1), (+1, +1)]
# Build & activate program
# Request a program and shader slots from GPU
program = gl.glCreateProgram()
vertex = gl.glCreateShader(gl.GL_VERTEX_SHADER)
fragment = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
# Set shaders source
gl.glShaderSource(vertex, vertex_code)
gl.glShaderSource(fragment, fragment_code)
# Compile shaders
gl.glCompileShader(vertex)
gl.glCompileShader(fragment)
# Attach shader objects to the program
gl.glAttachShader(program, vertex)
gl.glAttachShader(program, fragment)
# Build program
gl.glLinkProgram(program)
# Get rid of shaders (no more needed)
gl.glDetachShader(program, vertex)
gl.glDetachShader(program, fragment)
# Make program the default program
gl.glUseProgram(program)
# Build buffer
# Request a buffer slot from GPU
buf = gl.glCreateBuffer()
# Make this buffer the default one
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, buf)
# Upload data
gl.glBufferData(gl.GL_ARRAY_BUFFER, self.data, gl.GL_DYNAMIC_DRAW)
# Bind attributes
stride = self.data.strides[0]
offset = 0
loc = gl.glGetAttribLocation(program, "position")
gl.glEnableVertexAttribArray(loc)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, buf)
gl.glVertexAttribPointer(loc, 3, gl.GL_FLOAT, False, stride, offset)
offset = self.data.dtype["position"].itemsize
loc = gl.glGetAttribLocation(program, "color")
gl.glEnableVertexAttribArray(loc)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, buf)
gl.glVertexAttribPointer(loc, 4, gl.GL_FLOAT, False, stride, offset)
# Bind uniforms
# --------------------------------------
loc = gl.glGetUniformLocation(program, "scale")
gl.glUniform1f(loc, 1.0)
def on_initialize(self, event):
# Build & activate cube program
self.cube = gl.glCreateProgram()
vertex = gl.glCreateShader(gl.GL_VERTEX_SHADER)
fragment = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
gl.glShaderSource(vertex, cube_vertex)
gl.glShaderSource(fragment, cube_fragment)
gl.glCompileShader(vertex)
gl.glCompileShader(fragment)
gl.glAttachShader(self.cube, vertex)
gl.glAttachShader(self.cube, fragment)
gl.glLinkProgram(self.cube)
gl.glDetachShader(self.cube, vertex)
gl.glDetachShader(self.cube, fragment)
gl.glUseProgram(self.cube)
# Get data & build cube buffers
vcube_data, self.icube_data = makecube()
vcube = gl.glCreateBuffer()
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vcube)
gl.glBufferData(gl.GL_ARRAY_BUFFER, vcube_data, gl.GL_STATIC_DRAW)
icube = gl.glCreateBuffer()
gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, icube)
gl.glBufferData(gl.GL_ELEMENT_ARRAY_BUFFER, self.icube_data,
gl.GL_STATIC_DRAW)
# Bind cube attributes
stride = vcube_data.strides[0]
offset = 0
loc = gl.glGetAttribLocation(self.cube, "a_position")
gl.glEnableVertexAttribArray(loc)
gl.glVertexAttribPointer(loc, 3, gl.GL_FLOAT, False, stride, offset)
offset = vcube_data.dtype["a_position"].itemsize
loc = gl.glGetAttribLocation(self.cube, "a_texcoord")
gl.glEnableVertexAttribArray(loc)
gl.glVertexAttribPointer(loc, 2, gl.GL_FLOAT, False, stride, offset)
# Create & bind cube texture
crate = checkerboard()
texture = gl.glCreateTexture()
gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER,
gl.GL_LINEAR)
gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER,
gl.GL_LINEAR)
gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S,
gl.GL_CLAMP_TO_EDGE)
gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T,
gl.GL_CLAMP_TO_EDGE)
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_LUMINANCE, gl.GL_LUMINANCE,
gl.GL_UNSIGNED_BYTE, crate.shape[:2])
gl.glTexSubImage2D(gl.GL_TEXTURE_2D, 0, 0, 0, gl.GL_LUMINANCE,
gl.GL_UNSIGNED_BYTE, crate)
loc = gl.glGetUniformLocation(self.cube, "u_texture")
gl.glUniform1i(loc, texture)
gl.glBindTexture(gl.GL_TEXTURE_2D, 0)
# Create & bind cube matrices
view = np.eye(4, dtype=np.float32)
model = np.eye(4, dtype=np.float32)
projection = np.eye(4, dtype=np.float32)
translate(view, 0, 0, -7)
self.phi, self.theta = 60, 20
rotate(model, self.theta, 0, 0, 1)
rotate(model, self.phi, 0, 1, 0)
loc = gl.glGetUniformLocation(self.cube, "u_model")
gl.glUniformMatrix4fv(loc, 1, False, model)
loc = gl.glGetUniformLocation(self.cube, "u_view")
gl.glUniformMatrix4fv(loc, 1, False, view)
loc = gl.glGetUniformLocation(self.cube, "u_projection")
gl.glUniformMatrix4fv(loc, 1, False, projection)
# OpenGL initalization
gl.glClearColor(0.30, 0.30, 0.35, 1.00)
gl.glEnable(gl.GL_DEPTH_TEST)
self._resize(*(self.size + self.physical_size))
self.timer = app.Timer('auto', self.on_timer, start=True)
def on_initialize(self, event):
# Build & activate cube program
self.cube = gl.glCreateProgram()
vertex = gl.glCreateShader(gl.GL_VERTEX_SHADER)
fragment = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
gl.glShaderSource(vertex, cube_vertex)
gl.glShaderSource(fragment, cube_fragment)
gl.glCompileShader(vertex)
gl.glCompileShader(fragment)
gl.glAttachShader(self.cube, vertex)
gl.glAttachShader(self.cube, fragment)
gl.glLinkProgram(self.cube)
gl.glDetachShader(self.cube, vertex)
gl.glDetachShader(self.cube, fragment)
gl.glUseProgram(self.cube)
# Get data & build cube buffers
vcube_data, self.icube_data = makecube()
vcube = gl.glCreateBuffer()
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vcube)
gl.glBufferData(gl.GL_ARRAY_BUFFER, vcube_data, gl.GL_STATIC_DRAW)
icube = gl.glCreateBuffer()
gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, icube)
gl.glBufferData(gl.GL_ELEMENT_ARRAY_BUFFER,
self.icube_data, gl.GL_STATIC_DRAW)
# Bind cube attributes
stride = vcube_data.strides[0]
offset = 0
loc = gl.glGetAttribLocation(self.cube, "a_position")
gl.glEnableVertexAttribArray(loc)
gl.glVertexAttribPointer(loc, 3, gl.GL_FLOAT, False, stride, offset)
offset = vcube_data.dtype["a_position"].itemsize
loc = gl.glGetAttribLocation(self.cube, "a_texcoord")
gl.glEnableVertexAttribArray(loc)
gl.glVertexAttribPointer(loc, 2, gl.GL_FLOAT, False, stride, offset)
# Create & bind cube texture
crate = checkerboard()
texture = gl.glCreateTexture()
gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER,
gl.GL_LINEAR)
gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER,
gl.GL_LINEAR)
gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S,
gl.GL_CLAMP_TO_EDGE)
gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T,
gl.GL_CLAMP_TO_EDGE)
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_LUMINANCE, gl.GL_LUMINANCE,
gl.GL_UNSIGNED_BYTE, crate.shape[:2])
gl.glTexSubImage2D(gl.GL_TEXTURE_2D, 0, 0, 0, gl.GL_LUMINANCE,
gl.GL_UNSIGNED_BYTE, crate)
loc = gl.glGetUniformLocation(self.cube, "u_texture")
gl.glUniform1i(loc, texture)
gl.glBindTexture(gl.GL_TEXTURE_2D, 0)
# Create & bind cube matrices
view = np.eye(4, dtype=np.float32)
model = np.eye(4, dtype=np.float32)
projection = np.eye(4, dtype=np.float32)
translate(view, 0, 0, -7)
self.phi, self.theta = 60, 20
rotate(model, self.theta, 0, 0, 1)
rotate(model, self.phi, 0, 1, 0)
loc = gl.glGetUniformLocation(self.cube, "u_model")
gl.glUniformMatrix4fv(loc, 1, False, model)
loc = gl.glGetUniformLocation(self.cube, "u_view")
gl.glUniformMatrix4fv(loc, 1, False, view)
loc = gl.glGetUniformLocation(self.cube, "u_projection")
gl.glUniformMatrix4fv(loc, 1, False, projection)
# OpenGL initalization
gl.glClearColor(0.30, 0.30, 0.35, 1.00)
gl.glEnable(gl.GL_DEPTH_TEST)
self.timer.start()
def _prepare_vis():
objects = []
# --- program and shaders
# Create program and shaders
hprog = gl.glCreateProgram()
hvert = gl.glCreateShader(gl.GL_VERTEX_SHADER)
hfrag = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
objects.append((gl.glDeleteProgram, hprog))
objects.append((gl.glDeleteShader, hvert))
objects.append((gl.glDeleteShader, hfrag))
# Compile source code
gl.glShaderSource(hvert, VERT)
gl.glShaderSource(hfrag, FRAG)
gl.glCompileShader(hvert)
gl.glCompileShader(hfrag)
# Check
assert gl.glGetShaderInfoLog(hvert) == ''
assert gl.glGetShaderInfoLog(hfrag) == ''
assert gl.glGetShaderParameter(hvert, gl.GL_COMPILE_STATUS) == 1
assert gl.glGetShaderParameter(hfrag, gl.GL_COMPILE_STATUS) == 1
# Attach and link
gl.glAttachShader(hprog, hvert)
gl.glAttachShader(hprog, hfrag)
# touch glDetachShader
gl.glDetachShader(hprog, hvert)
gl.glAttachShader(hprog, hvert)
# Bind all attributes - we could let this occur automatically, but some
# implementations bind an attribute to index 0, which has the unfortunate
# property of being unable to be modified.
gl.glBindAttribLocation(hprog, 1, 'a_1')
gl.glBindAttribLocation(hprog, 2, 'a_2')
gl.glBindAttribLocation(hprog, 3, 'a_3')
gl.glBindAttribLocation(hprog, 4, 'a_4')
gl.glLinkProgram(hprog)
# Test that indeed these shaders are attached
attached_shaders = gl.glGetAttachedShaders(hprog)
assert_equal(set(attached_shaders), set([hvert, hfrag]))
# Check
assert_equal(gl.glGetProgramInfoLog(hprog), '')
assert_equal(gl.glGetProgramParameter(hprog, gl.GL_LINK_STATUS), 1)
gl.glValidateProgram(hprog)
assert_equal(gl.glGetProgramParameter(hprog, gl.GL_VALIDATE_STATUS), 1)
# Use it!
gl.glUseProgram(hprog)
# Check if all is ok
assert_equal(gl.glGetError(), 0)
# Check source
vert_source = gl.glGetShaderSource(hvert)
assert_true('attribute vec2 a_2;' in vert_source)
# --- get information on attributes and uniforms
# Count attributes and uniforms
natt = gl.glGetProgramParameter(hprog, gl.GL_ACTIVE_ATTRIBUTES)
nuni = gl.glGetProgramParameter(hprog, gl.GL_ACTIVE_UNIFORMS)
assert_equal(natt, 4)
assert_equal(nuni, 4+4+3+1)
# Get names
names = {}
for i in range(natt):
name, count, type = gl.glGetActiveAttrib(hprog, i)
names[name] = type
assert_equal(count, 1)
for i in range(nuni):
name, count, type = gl.glGetActiveUniform(hprog, i)
names[name] = type
assert_equal(count, 1)
# Check
assert_equal(names['a_1'], gl.GL_FLOAT)
assert_equal(names['a_2'], gl.GL_FLOAT_VEC2)
assert_equal(names['a_3'], gl.GL_FLOAT_VEC3)
assert_equal(names['a_4'], gl.GL_FLOAT_VEC4)
assert_equal(names['s_1'], gl.GL_SAMPLER_2D)
#
for i, type in enumerate([gl.GL_FLOAT, gl.GL_FLOAT_VEC2,
gl.GL_FLOAT_VEC3, gl.GL_FLOAT_VEC4]):
assert_equal(names['u_f%i' % (i+1)], type)
for i, type in enumerate([gl.GL_INT, gl.GL_INT_VEC2,
gl.GL_INT_VEC3, gl.GL_INT_VEC4]):
assert_equal(names['u_i%i' % (i+1)], type)
for i, type in enumerate([gl.GL_FLOAT_MAT2, gl.GL_FLOAT_MAT3,
gl.GL_FLOAT_MAT4]):
assert_equal(names['u_m%i' % (i+2)], type)
# Check if all is ok
assert_equal(gl.glGetError(), 0)
# --- texture
# Create, bind, activate
htex = gl.glCreateTexture()
objects.append((gl.glDeleteTexture, htex))
gl.glPixelStorei(gl.GL_UNPACK_ALIGNMENT, 1)
gl.glBindTexture(gl.GL_TEXTURE_2D, htex)
# Allocate data and upload
# This data is luminance and not C-contiguous
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_LUMINANCE, gl.GL_LUMINANCE,
gl.GL_UNSIGNED_BYTE, im2) # touch
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_LUMINANCE, gl.GL_LUMINANCE,
gl.GL_UNSIGNED_BYTE, im2.shape[:2])
gl.glTexSubImage2D(gl.GL_TEXTURE_2D, 0, 0, 0, gl.GL_LUMINANCE,
gl.GL_UNSIGNED_BYTE, im2)
# Set texture parameters (use f and i to touch both)
T = gl.GL_TEXTURE_2D
gl.glTexParameterf(T, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR)
gl.glTexParameteri(T, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR)
# Re-allocate data and upload
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGB, gl.GL_RGB,
gl.GL_UNSIGNED_BYTE, im1.shape[:2])
gl.glTexSubImage2D(gl.GL_TEXTURE_2D, 0, 0, 0, gl.GL_RGB,
gl.GL_UNSIGNED_BYTE, im1)
# Attach!
loc = gl.glGetUniformLocation(hprog, 's_1')
unit = 0
gl.glActiveTexture(gl.GL_TEXTURE0+unit)
gl.glUniform1i(loc, unit)
# Mipmaps (just to touch this function)
gl.glGenerateMipmap(gl.GL_TEXTURE_2D)
# Check min filter (touch getTextParameter)
minfilt = gl.glGetTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER)
assert_equal(minfilt, gl.GL_LINEAR)
# Check if all is ok
assert_equal(gl.glGetError(), 0)
# --- buffer vec2 (contiguous VBO)
# Create buffer
hbuf2 = gl.glCreateBuffer()
objects.append((gl.glDeleteBuffer, hbuf2))
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, hbuf2)
# Allocate and set data
gl.glBufferData(gl.GL_ARRAY_BUFFER, buf2.nbytes, gl.GL_DYNAMIC_DRAW)
gl.glBufferSubData(gl.GL_ARRAY_BUFFER, 0, buf2)
# Attach!
loc = gl.glGetAttribLocation(hprog, 'a_2')
gl.glDisableVertexAttribArray(loc) # touch
gl.glEnableVertexAttribArray(loc)
gl.glVertexAttribPointer(loc, 2, gl.GL_FLOAT, False, 2*4, 0)
# Check (touch glGetBufferParameter, glGetVertexAttrib and
# glGetVertexAttribOffset)
size = gl.glGetBufferParameter(gl.GL_ARRAY_BUFFER, gl.GL_BUFFER_SIZE)
assert_equal(size, buf2.nbytes)
stride = gl.glGetVertexAttrib(loc, gl.GL_VERTEX_ATTRIB_ARRAY_STRIDE)
assert_equal(stride, 2*4)
offset = gl.glGetVertexAttribOffset(loc, gl.GL_VERTEX_ATTRIB_ARRAY_POINTER)
assert_equal(offset, 0)
# Check if all is ok
assert_equal(gl.glGetError(), 0)
# --- buffer vec3 (non-contiguous VBO)
# Create buffer
hbuf3 = gl.glCreateBuffer()
objects.append((gl.glDeleteBuffer, hbuf3))
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, hbuf3)
# Allocate and set data
gl.glBufferData(gl.GL_ARRAY_BUFFER, buf3.nbytes, gl.GL_DYNAMIC_DRAW)
gl.glBufferSubData(gl.GL_ARRAY_BUFFER, 0, buf3)
# Attach!
loc = gl.glGetAttribLocation(hprog, 'a_3')
gl.glEnableVertexAttribArray(loc)
gl.glVertexAttribPointer(loc, 3, gl.GL_FLOAT, False, 3*4, 0)
# Check if all is ok
assert_equal(gl.glGetError(), 0)
# --- buffer vec4 (client vertex data)
# Select no FBO
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, 0)
# Attach!
loc = gl.glGetAttribLocation(hprog, 'a_4')
gl.glEnableVertexAttribArray(loc)
gl.glVertexAttribPointer(loc, 4, gl.GL_FLOAT, False, 4*4, buf4)
# Check if all is ok
assert_equal(gl.glGetError(), 0)
# --- element buffer
# Create buffer
global helements
helements = gl.glCreateBuffer()
objects.append((gl.glDeleteBuffer, helements))
gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, helements)
# Allocate and set data
gl.glBufferData(gl.GL_ELEMENT_ARRAY_BUFFER, elements, gl.GL_DYNAMIC_DRAW)
gl.glBufferSubData(gl.GL_ELEMENT_ARRAY_BUFFER, 0, elements)
# Turn off
gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, 0)
# Check if all is ok
assert_equal(gl.glGetError(), 0)
# --- uniforms
# Set integer uniforms to 0
# We set them twice just to touch both i and iv functions
for i, fun1, fun2 in [(1, gl.glUniform1i, gl.glUniform1iv),
(2, gl.glUniform2i, gl.glUniform2iv),
(3, gl.glUniform3i, gl.glUniform3iv),
(4, gl.glUniform4i, gl.glUniform4iv)]:
name = 'u_i%i' % i
value = [0] * i
loc = gl.glGetUniformLocation(hprog, name)
fun1(loc, *value) # e.g. glUniform4i
fun2(loc, 1, value) # e.g. glUniform4iv
# Set float uniforms to 1.0
# We set them twice just to touch both i and iv functions
for i, fun1, fun2 in [(1, gl.glUniform1f, gl.glUniform1fv),
(2, gl.glUniform2f, gl.glUniform2fv),
(3, gl.glUniform3f, gl.glUniform3fv),
(4, gl.glUniform4f, gl.glUniform4fv)]:
name = 'u_f%i' % i
value = [1.0] * i
loc = gl.glGetUniformLocation(hprog, name)
fun1(loc, *value) # e.g. glUniform4f
fun2(loc, 1, value) # e.g. glUniform4fv
# Set matrix uniforms
m = np.eye(5, dtype='float32')
loc = gl.glGetUniformLocation(hprog, 'u_m2')
gl.glUniformMatrix2fv(loc, 1, False, m[:2, :2])
#
loc = gl.glGetUniformLocation(hprog, 'u_m3')
m = np.eye(3, dtype='float32')
gl.glUniformMatrix3fv(loc, 1, False, m[:3, :3])
#
loc = gl.glGetUniformLocation(hprog, 'u_m4')
m = np.eye(4, dtype='float32')
gl.glUniformMatrix4fv(loc, 1, False, m[:4, :4])
# Check some uniforms
loc = gl.glGetUniformLocation(hprog, 'u_i1')
assert_equal(gl.glGetUniform(hprog, loc), 0)
loc = gl.glGetUniformLocation(hprog, 'u_i2')
assert_equal(gl.glGetUniform(hprog, loc), (0, 0))
loc = gl.glGetUniformLocation(hprog, 'u_f2')
assert_equal(gl.glGetUniform(hprog, loc), (1.0, 1.0))
# Check if all is ok
assert_equal(gl.glGetError(), 0)
# --- attributes
# Constant values for attributes. We do not even use this ...
loc = gl.glGetAttribLocation(hprog, 'a_1')
gl.glVertexAttrib1f(loc, 1.0)
loc = gl.glGetAttribLocation(hprog, 'a_2')
gl.glVertexAttrib2f(loc, 1.0, 1.0)
loc = gl.glGetAttribLocation(hprog, 'a_3')
gl.glVertexAttrib3f(loc, 1.0, 1.0, 1.0)
loc = gl.glGetAttribLocation(hprog, 'a_4')
gl.glVertexAttrib4f(loc, 1.0, 1.0, 1.0, 1.0)
# --- flush and finish
# Not really necessary, but we want to touch the functions
gl.glFlush()
gl.glFinish()
# print([i[1] for i in objects])
return objects
def draw(self):
for i in range(4):
if self._bufXglsl[i]:
fragment = fragment_template % self._bufXglsl[i]
self._bufXglsl[i] = None
frag_handle = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
gl.glShaderSource(frag_handle, fragment)
gl.glCompileShader(frag_handle)
status = gl.glGetShaderParameter(frag_handle,
gl.GL_COMPILE_STATUS)
if not status:
errors = gl.glGetShaderInfoLog(frag_handle)
errors = self.process_errors(errors)
print('Shader failed to compile:', file=sys.stderr)
print(errors, file=sys.stderr)
exit(1)
else:
self._BufX[i].set_shaders(vertex, fragment)
gl.glDeleteShader(frag_handle)
if self._glsl:
fragment = fragment_template % self._glsl
self._glsl = None
# Check to see if the shader will compile successfully before we
# set it. We do this here because the ShaderWatcher runs in a
# different thread and so can't access the GL context.
frag_handle = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
gl.glShaderSource(frag_handle, fragment)
gl.glCompileShader(frag_handle)
status = gl.glGetShaderParameter(frag_handle,
gl.GL_COMPILE_STATUS)
if not status:
errors = gl.glGetShaderInfoLog(frag_handle)
errors = self.process_errors(errors)
print('Shader failed to compile:', file=sys.stderr)
print(errors, file=sys.stderr)
exit(1)
# Switch to error shader
self._glsl = error_shader
self.update()
else:
self.program.set_shaders(vertex, fragment)
gl.glDeleteShader(frag_handle)
if self._interactive:
for i in range(4):
with self._fboX[self._doubleFboid][i]:
gloo.set_clear_color((0.0, 0.0, 0.0, 0.0))
gloo.clear(color=True, depth=True)
gloo.set_viewport(0, 0, *self.physical_size)
self._BufX[i].draw()
self.program.draw()
if self._ffmpeg_pipe is not None:
img = _screenshot()
self.write_video_frame(img)
self._render_frame_index += 1
if self._render_frame_count is not None \
and self._render_frame_index \
>= self._render_frame_count:
app.quit()
return
self._doubleFbo = not self._doubleFbo
self._doubleFboid=(0 if self._doubleFbo else 1)
self.advance_time()
self.program['iFrame'] = self._render_frame_index
self.set_Buf_uniform('iFrame' , self._render_frame_index)
self.set_channel_input()
self.set_Buf_channel_input()
else:
for i in range(4):
with self._fboX[self._doubleFboid][i]:
gloo.set_clear_color((0.0, 0.0, 0.0, 0.0))
gloo.clear(color=True, depth=True)
gloo.set_viewport(0, 0, *self.physical_size)
self._BufX[i].draw()
with self._fbo:
rs = list(self._render_size)
if self._tile_coord[0] + rs[0] > self._output_size[0]:
rs[0] = self._output_size[0] - self._tile_coord[0]
if self._tile_coord[1] + rs[1] > self._output_size[1]:
rs[1] = self._output_size[1] - self._tile_coord[1]
gloo.set_viewport(0, 0, *rs)
self.program['iOffset'] = self._tile_coord
self.program.draw()
self._doubleFbo = not self._doubleFbo
self._doubleFboid=(0 if self._doubleFbo else 1)
self.program['iFrame'] = self._render_frame_index
self.set_Buf_uniform('iFrame' , self._render_frame_index)
self.set_channel_input()
self.set_Buf_channel_input()
img = _screenshot()
row = self._output_size[1] - self._tile_coord[1] - rs[1]
col = self._tile_coord[0]
self._img[row:row + rs[1], col:col + rs[0], :] = img
def on_initialize(self, event):
# Build data
self.data = np.zeros(4, [("position", np.float32, 2),
("color", np.float32, 4)])
self.data['color'] = [(1, 0, 0, 1), (0, 1, 0, 1),
(0, 0, 1, 1), (1, 1, 0, 1)]
self.data['position'] = [(-1, -1), (-1, +1),
(+1, -1), (+1, +1)]
# Build & activate program
# Request a program and shader slots from GPU
program = gl.glCreateProgram()
vertex = gl.glCreateShader(gl.GL_VERTEX_SHADER)
fragment = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
# Set shaders source
gl.glShaderSource(vertex, vertex_code)
gl.glShaderSource(fragment, fragment_code)
# Compile shaders
gl.glCompileShader(vertex)
gl.glCompileShader(fragment)
# Attach shader objects to the program
gl.glAttachShader(program, vertex)
gl.glAttachShader(program, fragment)
# Build program
gl.glLinkProgram(program)
# Get rid of shaders (no more needed)
gl.glDetachShader(program, vertex)
gl.glDetachShader(program, fragment)
# Make program the default program
gl.glUseProgram(program)
# Build buffer
# Request a buffer slot from GPU
buf = gl.glCreateBuffer()
# Make this buffer the default one
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, buf)
# Upload data
gl.glBufferData(gl.GL_ARRAY_BUFFER, self.data, gl.GL_DYNAMIC_DRAW)
# Bind attributes
stride = self.data.strides[0]
offset = 0
loc = gl.glGetAttribLocation(program, "position")
gl.glEnableVertexAttribArray(loc)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, buf)
gl.glVertexAttribPointer(loc, 3, gl.GL_FLOAT, False, stride, offset)
offset = self.data.dtype["position"].itemsize
loc = gl.glGetAttribLocation(program, "color")
gl.glEnableVertexAttribArray(loc)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, buf)
gl.glVertexAttribPointer(loc, 4, gl.GL_FLOAT, False, stride, offset)
# Bind uniforms
# --------------------------------------
loc = gl.glGetUniformLocation(program, "scale")
gl.glUniform1f(loc, 1.0)