def on_draw(dt):
global phi, theta, duration, i, cube_prog, indices
window.clear()
gl.glEnable(gl.GL_DEPTH_TEST)
cube_prog.draw(gl.GL_TRIANGLES, indices)
# Rotate cube
theta += random.randint(0, 300) # degrees
phi += random.randint(0, 300) # degrees
view = cube_prog['u_view'].reshape(4, 4)
model = np.eye(4, dtype=np.float32)
glm.rotate(model, theta, 0, 0, 1)
glm.rotate(model, phi, 0, 1, 0)
cube_prog['u_model'] = model
cube_prog['u_normal'] = np.array(np.matrix(np.dot(view, model)).I.T)
if i < count:
framebuffer = np.zeros((window.height, window.width * 3),
dtype=np.uint8)
gl.glReadPixels(0, 0, window.width, window.height, gl.GL_RGB,
gl.GL_UNSIGNED_BYTE, framebuffer)
png.from_array(framebuffer, 'RGB').save("color/" + str(dice_val) +
"_" + str(i) + '.png')
i += 1
else:
app.quit()
i = 0
def on_draw(dt):
global phi, theta, writer, duration
window.clear()
gl.glEnable(gl.GL_DEPTH_TEST)
cube.draw(gl.GL_TRIANGLES, faces)
# Write one frame
if writer is not None:
if duration > 0:
gl.glReadPixels(0, 0, window.width, window.height, gl.GL_RGB,
gl.GL_UNSIGNED_BYTE, fbuffer)
writer.write_frame(fbuffer)
duration -= dt
else:
writer.close()
writer = None
# Make cube rotate
theta += 0.5 # degrees
phi += 0.5 # degrees
model = np.eye(4, dtype=np.float32)
glm.rotate(model, theta, 0, 0, 1)
glm.rotate(model, phi, 0, 1, 0)
cube['model'] = model
def on_draw(dt):
self.window.clear()
gl.glEnable(gl.GL_DEPTH_TEST)
for obj, prog in zip(self.render_objects, self.programs):
prog.draw(gl.GL_TRIANGLES, obj.indices)
# Rotate cube
self.update_camera()
def ApplyImpulse(dest, position, value):
prog_splat["FillColor"] = value, value, value
dest.activate()
gl.glEnable(gl.GL_BLEND)
prog_splat.draw(gl.GL_TRIANGLE_STRIP)
dest.deactivate()
gl.glDisable(gl.GL_BLEND)
def update(self):
self.window.clear()
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_POLYGON_OFFSET_FILL)
self.shader.draw(gl.GL_TRIANGLES, self.faces)
self.check_recording()
def draw_depth(shape, vertex_buffer, index_buffer, mat_model, mat_view, mat_proj):
program = gloo.Program(_depth_vertex_code, _depth_fragment_code)
program.bind(vertex_buffer)
program['u_mv'] = _compute_model_view(mat_model, mat_view)
program['u_mvp'] = _compute_model_view_proj(mat_model, mat_view, mat_proj)
# Frame buffer object
color_buf = np.zeros((shape[0], shape[1], 4), np.float32).view(gloo.TextureFloat2D)
depth_buf = np.zeros((shape[0], shape[1]), np.float32).view(gloo.DepthTexture)
fbo = gloo.FrameBuffer(color=color_buf, depth=depth_buf)
fbo.activate()
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_CULL_FACE)
gl.glCullFace(gl.GL_BACK) # Back-facing polygons will be culled
gl.glClearColor(0.0, 0.0, 0.0, 0.0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glViewport(0, 0, shape[1], shape[0])
# Rendering
program.draw(gl.GL_TRIANGLES, index_buffer)
# Retrieve the contents of the FBO texture
depth = np.zeros((shape[0], shape[1], 4), dtype=np.float32)
gl.glReadPixels(0, 0, shape[1], shape[0], gl.GL_RGBA, gl.GL_FLOAT, depth)
depth.shape = shape[0], shape[1], 4
depth = depth[::-1, :]
depth = depth[:, :, 0] # Depth is saved in the first channel
fbo.deactivate()
return depth
def on_draw(dt):
self.window.clear()
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
# print('brightness_k', self.brightness_k) # this function runs when running app.run()
self.render_kernels[self.class_name][self.brightness_k].draw(
gl.GL_TRIANGLES)
def on_draw(dt):
global phi, theta
# Phi and Theta are the cube rotation paramters
window.clear()
lock.acquire()
try:
# Disable depth of OpenGL to update background tecture
gl.glDisable(gl.GL_DEPTH_TEST)
quad.draw(gl.GL_TRIANGLE_STRIP)
# R-enable depth
gl.glEnable(gl.GL_DEPTH_TEST)
# Color of path
path["u_color"] = 0, 1, 1
# Filled path
path.draw(gl.GL_TRIANGLE_STRIP)
# Mask depth
gl.glDepthMask(gl.GL_FALSE)
# Color of edge lines of path
path["u_color"] = 0, 0, 0
# Width of edge lines
gl.glLineWidth(10.0)
# Draw edge lines with index buffer bline_I
path.draw(gl.GL_LINES, bline_I)
# Reset line width
gl.glLineWidth(1.0)
gl.glDepthMask(gl.GL_TRUE)
# Define the model matrix with updated rotation
model = np.eye(4, dtype=np.float32)
glm.rotate(model, theta, 0, 0, 1)
glm.rotate(model, phi, 0, 1, 0)
for obj in bag.values():
obj["u_color"] = 1, 0, 0
# Filled cube
obj.draw(gl.GL_TRIANGLES, I)
# Another method to disable depth, instead of disabling it, mask it
gl.glDepthMask(gl.GL_FALSE)
# Black color for edge lines of cube
obj["u_color"] = 0, 0, 0
# Draw the edge lines with the given index buffer
obj.draw(gl.GL_LINES, O)
# Unmask OpenGL depth aparamter
gl.glDepthMask(gl.GL_TRUE)
# Model matrix is used to define orientation ,in this case, used to rotate cube
obj["model"] = model
# Update cube rotations
theta += 2.0 # degrees
phi += 2.0 # degrees
finally:
lock.release()
def on_draw(self, dt):
program = self.program
window = self.window
# set title
window.set_title(str(window.fps).encode("ascii"))
self.update_VertexBuffer(dt)
# Filled cube
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_POLYGON_OFFSET_FILL)
program['ucolor'] = 1, 1, 1, 1
program.draw(gl.GL_QUADS, self.outline)
# Outlined program
# gl.glDisable(gl.GL_POLYGON_OFFSET_FILL)
# gl.glEnable(gl.GL_BLEND)
# gl.glDepthMask(gl.GL_FALSE)
# program['ucolor'] = 0, 0, 0, 1
# program.draw(gl.GL_LINES, self.outline)
# gl.glDepthMask(gl.GL_TRUE)
# Make program rotate
self.theta += 0 * dt # degrees
self.phi += 10 * dt # degrees
model = np.eye(4, dtype=np.float32)
glm.rotate(model, 90, 1, 0, 0)
glm.rotate(model, self.theta, 0, 0, 1)
glm.rotate(model, self.phi, 0, 1, 0)
glm.rotate(model, 45, 1, 0, 0)
program['model'] = model
def draw_depth(shape, vertex_buffer, index_buffer, mat_model, mat_view, mat_proj):
program = gloo.Program(_depth_vertex_code, _depth_fragment_code)
program.bind(vertex_buffer)
program['u_mv'] = _compute_model_view(mat_model, mat_view)
program['u_mvp'] = _compute_model_view_proj(mat_model, mat_view, mat_proj)
# Frame buffer object
color_buf = np.zeros((shape[0], shape[1], 4), np.float32).view(gloo.TextureFloat2D)
depth_buf = np.zeros((shape[0], shape[1]), np.float32).view(gloo.DepthTexture)
fbo = gloo.FrameBuffer(color=color_buf, depth=depth_buf)
fbo.activate()
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_CULL_FACE)
gl.glCullFace(gl.GL_BACK) # Back-facing polygons will be culled
gl.glClearColor(0.0, 0.0, 0.0, 0.0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glViewport(0, 0, shape[1], shape[0])
# Rendering
program.draw(gl.GL_TRIANGLES, index_buffer)
# Retrieve the contents of the FBO texture
depth = np.zeros((shape[0], shape[1], 4), dtype=np.float32)
gl.glReadPixels(0, 0, shape[1], shape[0], gl.GL_RGBA, gl.GL_FLOAT, depth)
depth.shape = shape[0], shape[1], 4
depth = depth[::-1, :]
depth = depth[:, :, 0] # Depth is saved in the first channel
fbo.deactivate()
return depth
def on_draw(dt):
if self.vertices is None:
return
gl.glEnable(gl.GL_DEPTH_TEST)
self.framebuffer.activate()
window.clear()
self.mesh_shader.draw(gl.GL_TRIANGLES)
if self.click is not None:
gl.glReadBuffer(gl.GL_COLOR_ATTACHMENT1)
r, g, b, a = gl.glReadPixels(self.click[0], self.click[1], 1,
1, gl.GL_RGBA,
gl.GL_UNSIGNED_BYTE)
if type(r) is not int: r = ord(r)
if type(g) is not int: g = ord(g)
if type(b) is not int: b = ord(b)
index = b + 256 * g + 256 * 256 * r
self.mesh_shader['select_id'] = index
self.click = None
if self.click_callback is None:
print('Click callback function not defined')
else:
self.click_callback(index - 1)
self.framebuffer.deactivate()
window.clear()
self.render()
def init_program(self):
# Ensure size is set
#print("program param: ", self.program_params)
#print("---[")
#print(self.fragment)
#print("]---")
self.program = gloo.Program(self.vertex,
self.fragment,
count=4,
version="450")
self.program['position'] = [(-1, -1), (-1, +1), (+1, -1), (+1, +1)]
if self.title == "Map":
self.point_history = collections.deque(maxlen=250)
self.point_program = gloo.Program(self.dot_vertex,
self.dot_fragment,
count=self.point_history.maxlen)
self.point_program['position'] = np.zeros(
(self.point_history.maxlen, 2), dtype=np.float32) - 2.0
self.point_program['age'] = np.zeros(self.point_history.maxlen,
dtype=np.float32)
# TODO: make those setting parameter
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
self.on_resize(*self.winsize)
if self.iMouse:
self.program["iMouse"] = self.iMouse
def on_draw(dt):
# window.clear()
global rgb
extent_shape = (int(shape[0] * ssaa), int(shape[1] * ssaa))
# Frame buffer object
color_buf = np.zeros((extent_shape[0], extent_shape[1], 4),
np.float32).view(gloo.TextureFloat2D)
depth_buf = np.zeros((extent_shape[0], extent_shape[1]),
np.float32).view(gloo.DepthTexture)
fbo = gloo.FrameBuffer(color=color_buf, depth=depth_buf)
fbo.activate()
# OpenGL setup
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glViewport(0, 0, extent_shape[1], extent_shape[0])
gl.glDisable(gl.GL_CULL_FACE)
program.draw(gl.GL_TRIANGLES, I)
rgb = np.zeros((extent_shape[0], extent_shape[1], 4), dtype=np.float32)
gl.glReadPixels(0, 0, extent_shape[1], extent_shape[0], gl.GL_RGBA,
gl.GL_FLOAT, rgb)
rgb.shape = extent_shape[0], extent_shape[1], 4
rgb = rgb[::-1, :]
rgb = np.round(rgb[:, :, :3] * 255).astype(
np.uint8) # Convert to [0, 255]
import cv2
rgb = cv2.resize(rgb, shape, interpolation=cv2.INTER_AREA)
fbo.deactivate()
def ApplyImpulse(dest, position, value):
prog_splat["FillColor"] = value,value,value
dest.activate()
gl.glEnable(gl.GL_BLEND)
prog_splat.draw(gl.GL_TRIANGLE_STRIP)
dest.deactivate()
gl.glDisable(gl.GL_BLEND)
def on_draw(dt):
window.clear(color=C0)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glDepthMask(gl.GL_FALSE)
gl.glEnable(gl.GL_BLEND)
# Transparent surfaces
# Pass 1: accumulation
quads["pass"] = 0
framebuffer.color = accumulation
framebuffer.activate()
gl.glBlendFunc(gl.GL_ONE, gl.GL_ONE)
window.clear(color=(0, 0, 0, 0))
quads.draw(gl.GL_TRIANGLES, indices)
framebuffer.deactivate()
# Pass 2: revealage
quads["pass"] = 1
framebuffer.color = revealage
framebuffer.activate()
gl.glBlendFunc(gl.GL_ZERO, gl.GL_ONE_MINUS_SRC_COLOR)
window.clear(color=(1, 1, 1, 1))
quads.draw(gl.GL_TRIANGLES, indices)
framebuffer.deactivate()
# Compositing
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
post.draw(gl.GL_TRIANGLE_STRIP)
def on_draw(dt):
window.clear(color=C0)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glDepthMask(gl.GL_FALSE)
gl.glEnable(gl.GL_BLEND)
# Transparent surfaces
# Pass 1: accumulation
quads["pass"] = 0
framebuffer.color = accumulation
framebuffer.activate()
gl.glBlendFunc(gl.GL_ONE, gl.GL_ONE)
window.clear(color=(0,0,0,0))
quads.draw(gl.GL_TRIANGLES, indices)
framebuffer.deactivate()
# Pass 2: revealage
quads["pass"] = 1
framebuffer.color = revealage
framebuffer.activate()
gl.glBlendFunc(gl.GL_ZERO, gl.GL_ONE_MINUS_SRC_COLOR)
window.clear(color=(1,1,1,1))
quads.draw(gl.GL_TRIANGLES, indices)
framebuffer.deactivate()
# Compositing
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
post.draw(gl.GL_TRIANGLE_STRIP)
def on_draw(dt):
window.clear()
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_PROGRAM_POINT_SIZE)
gl.glLineWidth(30.0)
pc_program.draw(mode=gl.GL_POINTS)
line_program.draw(mode=gl.GL_LINES)
def on_draw(dt):
# Clear depth and color buffers
gl.glClearColor(*C0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
# Opaque objects rendering
gl.glDepthMask(gl.GL_TRUE)
gl.glDisable(gl.GL_BLEND)
# Transparent objects rendering
gl.glDepthMask(gl.GL_FALSE)
gl.glEnable(gl.GL_BLEND)
framebuffer.activate()
gl.glClearColor(0,0,0,1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
window.clear(color=(0,0,0,1))
gl.glBlendFuncSeparate(gl.GL_ONE, gl.GL_ONE,
gl.GL_ZERO, gl.GL_ONE_MINUS_SRC_ALPHA)
scene.draw(gl.GL_TRIANGLES, indices)
framebuffer.deactivate()
# Compositing
gl.glBlendFunc(gl.GL_ONE_MINUS_SRC_ALPHA, gl.GL_SRC_ALPHA)
compose.draw(gl.GL_TRIANGLE_STRIP)
def draw(self, projection, view, width, height):
if self._draw_mode == self.DRAW_PIXELS:
np_type = self._framebuffer.color_attachments[
self._color_index].dtype
gl_type = opengl_utils.get_gl_type(np_type)
pixels = self._framebuffer.read_rgba_pixels(self._color_index)
if self._color_scale != 1.0:
pixels *= self._color_scale
if self._color_offset != 1.0:
pixels += self._color_offset
width = min(width, self._framebuffer.width)
height = min(height, self._framebuffer.height)
gl.glDrawPixels(width, height, gl.GL_RGBA, gl_type, pixels)
elif self._draw_mode == self.DRAW_QUAD:
gl.glDisable(gl.GL_DEPTH_TEST)
gl.glDisable(gl.GL_CULL_FACE)
with self._quad.activate():
self._quad["u_color_offset"] = self._color_offset
self._quad["u_color_scale"] = self._color_scale
self._quad.draw(gl.GL_TRIANGLE_STRIP)
gl.glEnable(gl.GL_CULL_FACE)
gl.glEnable(gl.GL_DEPTH_TEST)
elif self._draw_mode == self.BLIT:
gl.glBindFramebuffer(gl.GL_READ_FRAMEBUFFER,
self._framebuffer.native_framebuffer.handle)
gl.glReadBuffer(gl.GL_COLOR_ATTACHMENT0 + self._color_index)
gl.glBindFramebuffer(gl.GL_DRAW_FRAMEBUFFER, 0)
gl.glBlitFramebuffer(0, 0, self._framebuffer.width,
self._framebuffer.height, 0, 0, width, height,
gl.GL_COLOR_BUFFER_BIT, gl.GL_LINEAR)
else:
raise RuntimeError("Unknown drawing mode")
def on_draw(dt):
global phi, theta, writer, duration
window.clear()
gl.glEnable(gl.GL_DEPTH_TEST)
cube.draw(gl.GL_TRIANGLES, faces)
# Write one frame
if writer is not None:
if duration > 0:
gl.glReadPixels(0, 0, window.width, window.height,
gl.GL_RGB, gl.GL_UNSIGNED_BYTE, fbuffer)
writer.write_frame(fbuffer)
duration -= dt
else:
writer.close()
writer = None
# Make cube rotate
theta += 0.5 # degrees
phi += 0.5 # degrees
model = np.eye(4, dtype=np.float32)
glm.rotate(model, theta, 0, 0, 1)
glm.rotate(model, phi, 0, 1, 0)
cube['model'] = model
def on_draw(_):
window.clear()
gl.glLineWidth(2)
gl.glPolygonMode(gl.GL_FRONT_AND_BACK, gl.GL_LINE)
gl.glEnable(gl.GL_LINE_SMOOTH)
program.draw(gl.GL_TRIANGLES,
indices.reshape(-1).astype(np.uint32).view(gloo.IndexBuffer))
def on_draw(dt):
# Clear depth and color buffers
gl.glClearColor(*C0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
# Opaque objects rendering
gl.glDepthMask(gl.GL_TRUE)
gl.glDisable(gl.GL_BLEND)
# Transparent objects rendering
gl.glDepthMask(gl.GL_FALSE)
gl.glEnable(gl.GL_BLEND)
framebuffer.activate()
gl.glClearColor(0, 0, 0, 1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
window.clear(color=(0, 0, 0, 1))
gl.glBlendFuncSeparate(gl.GL_ONE, gl.GL_ONE, gl.GL_ZERO,
gl.GL_ONE_MINUS_SRC_ALPHA)
scene.draw(gl.GL_TRIANGLES, indices)
framebuffer.deactivate()
# Compositing
gl.glBlendFunc(gl.GL_ONE_MINUS_SRC_ALPHA, gl.GL_SRC_ALPHA)
compose.draw(gl.GL_TRIANGLE_STRIP)
def _activate(self):
""" Activate texture on GPU """
log.debug("GPU: Activate texture cube")
gl.glEnable(gl.GL_TEXTURE_CUBE_MAP)
gl.glBindTexture(self.target, self._handle)
if self._need_setup:
self._setup()
def _activate(self):
""" Activate texture on GPU """
log.debug("GPU: Activate texture cube")
gl.glEnable(gl.GL_TEXTURE_CUBE_MAP)
gl.glBindTexture(self.target, self._handle)
if self._need_setup:
self._setup()
def activate(self, clear=False):
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
gl.glViewport(0, 0, self.width, self.height)
if clear:
# self._win.clear()
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glEnable(gl.GL_DEPTH_TEST)
yield self
def on_draw(dt):
window.clear()
# Filled cube
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_POLYGON_OFFSET_FILL)
color_all_cubes()
def on_draw(dt):
window.clear()
gl.glEnable(gl.GL_DEPTH_TEST)
earth.draw(gl.GL_TRIANGLES, indices)
paths.draw()
gl.glDisable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_BLEND)
markers.draw()
labels.draw()
def update(self):
# draw to screen
self.window.clear()
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_POLYGON_OFFSET_FILL)
self.shader.draw(gl.GL_TRIANGLES, self.faces)
def on_draw(dt):
nonlocal frame, x, y, z, theta, phi, gamma
# Export screenshot
gl.glReadPixels(0, 0, window.width, window.height, gl.GL_RGB,
gl.GL_UNSIGNED_BYTE, framebuffer)
if frame > 2: # Skip empty zero frame
if (frame) % 3 == 0:
pbar.update()
gt.append(
[f'{(frame-3)//3:05d}.png', x, y, z, theta, phi, gamma])
png.from_array(framebuffer, 'RGB').save(
root / 'images' / f'{(frame-3)//3:05d}.png')
elif (frame) % 3 == 1:
png.from_array(framebuffer, 'RGB').save(
root / 'no_rotation' / f'{(frame-4)//3:05d}.png')
elif (frame) % 3 == 2:
png.from_array(framebuffer, 'RGB').save(
root / 'no_translation' / f'{(frame-5)//3:05d}.png')
if (frame - 1) % 3 == 0:
theta = np.random.random_sample() * 360
x, y = np.random.random_sample(2) * (max_xy - min_xy) + min_xy
if not fixed_z:
z = np.random.random_sample() * (max_z - min_z) + min_z
if shape == 'cube':
phi = np.random.random_sample() * 180
if shape in shapes:
phi = np.random.random_sample() * 180
gamma = np.random.random_sample() * 360
window.clear()
# Fill cube
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_POLYGON_OFFSET_FILL)
cube['u_color'] = 1, 1, 1, 1
cube.draw(gl.GL_TRIANGLES, I)
# Rotate cube
view = cube['u_view'].reshape(4, 4)
model = np.eye(4, dtype=np.float32)
if (frame - 1) % 3 != 1:
glm.rotate(model, theta, 0, 0, 1)
glm.rotate(model, phi, 0, 1, 0)
glm.rotate(model, gamma, 1, 0, 0)
# Translate cube
if (frame - 1) % 3 != 2:
glm.translate(model, x, y, z)
cube['u_model'] = model
cube['u_normal'] = np.array(np.matrix(np.dot(view, model)).I.T)
frame += 1
def on_draw(dt):
self.window.clear()
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
self.render_kernel_list[self.cls_idx].draw(gl.GL_TRIANGLES)
gl.glReadPixels(0, 0, self.width, self.height, gl.GL_RGBA,
gl.GL_FLOAT, self.rgb_buffer)
gl.glReadPixels(0, 0, self.width, self.height,
gl.GL_DEPTH_COMPONENT, gl.GL_FLOAT,
self.depth_buffer)
def draw_color(shape, vertex_buffers, index_buffers, mat_models, mat_views,
mat_projs, ambient_weight, light_color, bg_color):
assert (len(vertex_buffers) == len(index_buffers))
assert (len(vertex_buffers) == len(mat_models))
assert (len(vertex_buffers) == len(mat_views))
assert (len(vertex_buffers) == len(mat_projs))
program = gloo.Program(_color_vertex_code, _color_fragment_code)
# Frame buffer object
color_buf = np.zeros((shape[0], shape[1], 4),
np.float32).view(gloo.TextureFloat2D)
depth_buf = np.zeros((shape[0], shape[1]),
np.float32).view(gloo.DepthTexture)
fbo = gloo.FrameBuffer(color=color_buf, depth=depth_buf)
fbo.activate()
# OpenGL setup
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_CULL_FACE)
gl.glCullFace(gl.GL_BACK) # Back-facing polygons will be culled
gl.glClearColor(bg_color[0], bg_color[1], bg_color[2], bg_color[3])
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glViewport(0, 0, shape[1], shape[0])
for i in xrange(len(vertex_buffers)):
vertex_buffer = vertex_buffers[i]
index_buffer = index_buffers[i]
mat_model = mat_models[i]
mat_view = mat_views[i]
mat_proj = mat_projs[i]
program.bind(vertex_buffer)
program['u_light_eye_pos'] = [0, 0, 0]
program['light_color'] = [
light_color[0], light_color[1], light_color[2]
]
program['u_light_ambient_w'] = ambient_weight
program['u_mv'] = _compute_model_view(mat_model, mat_view)
program['u_mvp'] = _compute_model_view_proj(mat_model, mat_view,
mat_proj)
# Rendering
program.draw(gl.GL_TRIANGLES, index_buffer)
# Retrieve the contents of the FBO texture
rgb = np.zeros((shape[0], shape[1], 4), dtype=np.float32)
gl.glReadPixels(0, 0, shape[1], shape[0], gl.GL_RGBA, gl.GL_FLOAT, rgb)
rgb.shape = shape[0], shape[1], 4
rgb = rgb[::-1, :]
rgb = np.round(rgb[:, :, :3] * 255).astype(np.uint8) # Convert to [0, 255]
fbo.deactivate()
return rgb
def on_draw(dt):
window.clear()
# Outlined cube
gl.glDisable(gl.GL_POLYGON_OFFSET_FILL)
gl.glEnable(gl.GL_BLEND)
gl.glDepthMask(gl.GL_FALSE)
cube['u_color'] = 0, 0, 0, 1
cube.draw(gl.GL_LINES, outline)
gl.glDepthMask(gl.GL_TRUE)
def activate(self, clear=False):
self._framebuffer.activate()
gl.glViewport(0, 0, self.width, self.height)
if clear:
# color_attachment_flags = []
# for i in range(len(self._color_attachments)):
# color_attachment_flags.append(gl.GL_COLOR_ATTACHMENT0 + i)
# gl.glDrawBuffers(np.array(color_attachment_flags, dtype=np.uint32))
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glEnable(gl.GL_DEPTH_TEST)
yield self
self._framebuffer.deactivate()
def on_draw(dt):
app.clock.tick()
window.clear()
gl.glEnable(gl.GL_BLEND);
gl.glBlendEquationSeparate(gl.GL_FUNC_ADD, gl.GL_FUNC_ADD);
gl.glBlendFuncSeparate(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA, gl.GL_ONE, gl.GL_ONE_MINUS_SRC_ALPHA);
w, h = window.get_size()
#print("----------")
pipeline.render_screen(None, (w, h))
var.ReloadVar.reload_vars()
def draw_label(shape, vertex_buffers, index_buffers, mat_models, mat_views,
mat_projs, labels):
assert (len(vertex_buffers) == len(index_buffers))
assert (len(vertex_buffers) == len(mat_models))
assert (len(vertex_buffers) == len(mat_views))
assert (len(vertex_buffers) == len(mat_projs))
assert (labels is not None)
assert (len(vertex_buffers) == len(labels))
program = gloo.Program(_label_vertex_code, _label_fragment_code)
# Frame buffer object
color_buf = np.zeros((shape[0], shape[1], 4),
np.float32).view(gloo.TextureFloat2D)
depth_buf = np.zeros((shape[0], shape[1]),
np.float32).view(gloo.DepthTexture)
fbo = gloo.FrameBuffer(color=color_buf, depth=depth_buf)
fbo.activate()
# OpenGL setup
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_CULL_FACE)
gl.glCullFace(gl.GL_BACK) # Back-facing polygons will be culled
gl.glClearColor(0.0, 0.0, 0.0, 0.0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glViewport(0, 0, shape[1], shape[0])
for i in range(len(vertex_buffers)):
vertex_buffer = vertex_buffers[i]
index_buffer = index_buffers[i]
mat_model = mat_models[i]
mat_view = mat_views[i]
mat_proj = mat_projs[i]
label = labels[i]
program.bind(vertex_buffer)
program['u_mv'] = _compute_model_view(mat_model, mat_view)
# program['u_nm'] = compute_normal_matrix(model, view)
program['u_mvp'] = _compute_model_view_proj(mat_model, mat_view,
mat_proj)
program['label'] = label
# Rendering
program.draw(gl.GL_TRIANGLES, index_buffer)
# Retrieve the contents of the FBO texture
label_map = np.zeros((shape[0], shape[1], 4), dtype=np.float32)
gl.glReadPixels(0, 0, shape[1], shape[0], gl.GL_RGBA, gl.GL_FLOAT,
label_map)
label_map.shape = shape[0], shape[1], 4
label_map = label_map[::-1, :]
label_map = label_map[:, :, 0]
fbo.deactivate()
return label_map
def init_program(self):
self.program = gloo.Program(vertex, fragment, count=n)
self.program['position'] = np.zeros((n, 3), dtype=np.float32)
self.program['radius'] = 1
self.program['projection'] = glm.perspective(
45.0, self.winsize[0] / float(self.winsize[1]), 1.0, 1000.0)
self.program["distance"] = np.linspace(0, 1, n)
gl.glEnable(gl.GL_DEPTH_TEST)
self.posx = 0
self.posy = 0
def on_draw(dt):
global phi, theta
with compose:
window.clear()
gl.glEnable(gl.GL_DEPTH_TEST)
cube.draw(gl.GL_TRIANGLES, faces)
theta += 0.5
phi += 0.5
model = np.eye(4, dtype=np.float32)
glm.rotate(model, theta, 0, 0, 1)
glm.rotate(model, phi, 0, 1, 0)
cube['model'] = model
def on_draw(dt):
global phi, theta, duration
window.clear()
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
cube.draw(gl.GL_TRIANGLES, indices)
# Rotate cube
theta += 0.5 # degrees
phi += 0.5 # degrees
model = np.eye(4, dtype=np.float32)
glm.rotate(model, theta, 0, 0, 1)
glm.rotate(model, phi, 0, 1, 0)
cube['u_model'] = model
def on_draw(dt):
gl.glEnable(gl.GL_DEPTH_TEST)
framebuffer.activate()
window.clear()
program.draw(gl.GL_POINTS)
if mouse is not None:
gl.glReadBuffer(gl.GL_COLOR_ATTACHMENT1, gl.GL_FRONT)
r,g,b,a = gl.glReadPixels(mouse[0],mouse[1],1,1, gl.GL_RGBA, gl.GL_UNSIGNED_BYTE)
index = ord(b) + 256*ord(g) + 256*256*ord(r)
if index < len(program):
program["bg_color"][index] = 0,0,0,1
framebuffer.deactivate()
gl.glDisable(gl.GL_DEPTH_TEST)
quad.draw(gl.GL_TRIANGLE_STRIP)
def _setup(self):
""" Setup texture on GPU """
Texture._setup(self)
gl.glEnable(gl.GL_TEXTURE_CUBE_MAP)
gl.glBindTexture(self.target, self._handle)
targets = [ gl.GL_TEXTURE_CUBE_MAP_POSITIVE_X,
gl.GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
gl.GL_TEXTURE_CUBE_MAP_POSITIVE_Y,
gl.GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
gl.GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
gl.GL_TEXTURE_CUBE_MAP_NEGATIVE_Z ]
for i,target in enumerate(targets):
gl.glTexImage2D(target, 0, self._gpu_format, self.width, self.height,
0, self._cpu_format, self.gtype, None)
self._need_setup = False
def on_draw(dt):
global phi, theta, duration
window.clear()
gl.glEnable(gl.GL_DEPTH_TEST)
cube.draw(gl.GL_TRIANGLES, indices)
# Rotate cube
theta += 0.5 # degrees
phi += 0.5 # degrees
view = cube['u_view'].reshape(4,4)
model = np.eye(4, dtype=np.float32)
glm.rotate(model, theta, 0, 0, 1)
glm.rotate(model, phi, 0, 1, 0)
cube['u_model'] = model
cube['u_normal'] = np.array(np.matrix(np.dot(view, model)).I.T)
def on_draw(dt):
window.clear(color=C0)
gl.glDepthMask(gl.GL_FALSE)
gl.glEnable(gl.GL_BLEND)
# Transparent surfaces
framebuffer.activate()
window.clear(color=(0,0,0,1))
gl.glBlendFuncSeparate(gl.GL_ONE, gl.GL_ONE,
gl.GL_ZERO, gl.GL_ONE_MINUS_SRC_ALPHA)
quads.draw(gl.GL_TRIANGLES, indices)
framebuffer.deactivate()
# Compositing
gl.glBlendFunc(gl.GL_ONE_MINUS_SRC_ALPHA, gl.GL_SRC_ALPHA)
gl.glEnable(gl.GL_BLEND)
post.draw(gl.GL_TRIANGLE_STRIP)
def on_draw(dt):
gl.glViewport(0, 0, GridWidth, GridHeight)
gl.glDisable(gl.GL_BLEND)
Advect(Velocity.Ping, Velocity.Ping, Obstacles, Velocity.Pong, VelocityDissipation)
Velocity.swap()
Advect(Velocity.Ping, Temperature.Ping, Obstacles, Temperature.Pong, TemperatureDissipation)
Temperature.swap()
Advect(Velocity.Ping, Density.Ping, Obstacles, Density.Pong, DensityDissipation)
Density.swap()
ApplyBuoyancy(Velocity.Ping, Temperature.Ping, Density.Ping, Velocity.Pong)
Velocity.swap()
ApplyImpulse(Temperature.Ping, ImpulsePosition, ImpulseTemperature)
ApplyImpulse(Density.Ping, ImpulsePosition, ImpulseDensity)
ComputeDivergence(Velocity.Ping, Obstacles, Divergence)
ClearSurface(Pressure.Ping, 0.0)
for i in range(NumJacobiIterations):
Jacobi(Pressure.Ping, Divergence, Obstacles, Pressure.Pong)
Pressure.swap()
SubtractGradient(Velocity.Ping, Pressure.Ping, Obstacles, Velocity.Pong)
Velocity.swap()
gl.glViewport(0,0,window.width,window.height)
gl.glClearColor(0, 0, 0, 1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
prog_visualize['u_data'] = Density.Ping.texture
prog_visualize['u_shape'] = Density.Ping.texture.shape[1], Density.Ping.texture.shape[0]
prog_visualize['u_kernel'] = data.get("spatial-filters.npy")
prog_visualize["Sampler"] = Density.Ping.texture
prog_visualize["FillColor"] = 0.95, 0.925, 1.00
prog_visualize["Scale"] = 1.0/window.width, 1.0/window.height
prog_visualize.draw(gl.GL_TRIANGLE_STRIP)
def on_draw(dt):
window.clear()
demo_idx = 0
for program_object in self.programs:
program = program_object.program
model = matrix_model(np.copy(program_object.u_model))
#self.deg_x += dt*20
#self.deg_y += dt*40
self.demo_dt += dt/5
demo_idx += 1
'''
if self.demo_dt > 2:
if demo_idx == 1:
if self.demo_dt > 2.4:
if program['alpha'] <= 0.1:
continue
else:
program['alpha'] -= 0.01
elif demo_idx == 2:
if self.demo_dt > 2.8:
program['alpha'] += 0.01
'''
program['u_model'] = np.dot(model, self.u_model)
program['u_view'] = self.u_view
program['u_projection'] = self.u_projection
if program_object.draw_mode == gl.GL_TRIANGLES:
program.draw(program_object.draw_mode, program_object.face)
elif program_object.draw_mode == gl.GL_LINES and program_object.name == 'ProgramSFM3DRegion':
gl.glDisable(gl.GL_POLYGON_OFFSET_FILL)
gl.glEnable(gl.GL_BLEND)
gl.glDepthMask(gl.GL_FALSE)
program.draw(program_object.draw_mode, program_object.O)
gl.glDepthMask(gl.GL_TRUE)
else:
program.draw(program_object.draw_mode)
def on_draw(dt):
global phi, theta
window.clear()
# Filled cube
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_POLYGON_OFFSET_FILL)
cube['u_color'] = 1, 1, 1, 1
cube.draw(gl.GL_TRIANGLES, faces)
# Outlined cube
gl.glDisable(gl.GL_POLYGON_OFFSET_FILL)
gl.glEnable(gl.GL_BLEND)
gl.glDepthMask(gl.GL_FALSE)
cube['u_color'] = 0, 0, 0, 1
cube.draw(gl.GL_LINES, outline)
gl.glDepthMask(gl.GL_TRUE)
# Make cube rotate
theta += 0.5 # degrees
phi += 0.5 # degrees
model = np.eye(4, dtype=np.float32)
glm.rotate(model, theta, 0, 0, 1)
glm.rotate(model, phi, 0, 1, 0)
cube['model'] = model
def on_draw(dt):
global phi, theta, duration
window.clear()
# Filled cube
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_POLYGON_OFFSET_FILL)
cube['u_color'] = 1, 1, 1, 1
cube.draw(gl.GL_TRIANGLES, I)
# Outlined cube
gl.glDisable(gl.GL_POLYGON_OFFSET_FILL)
gl.glEnable(gl.GL_BLEND)
gl.glDepthMask(gl.GL_FALSE)
cube['u_color'] = 0, 0, 0, 1
cube.draw(gl.GL_LINES, O)
gl.glDepthMask(gl.GL_TRUE)
# Rotate cube
theta += 0.5 # degrees
phi += 0.5 # degrees
view = cube['u_view'].reshape(4,4)
model = np.eye(4, dtype=np.float32)
glm.rotate(model, theta, 0, 0, 1)
glm.rotate(model, phi, 0, 1, 0)
cube['u_model'] = model
cube['u_normal'] = np.array(np.matrix(np.dot(view, model)).I.T)
def on_draw(dt):
global phi, theta, time
time += dt
window.clear()
surface['data']
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_POLYGON_OFFSET_FILL)
surface["color"] = 1,1,1,1
surface.draw(gl.GL_TRIANGLES, s_indices)
gl.glDisable(gl.GL_POLYGON_OFFSET_FILL)
gl.glEnable(gl.GL_BLEND)
gl.glDepthMask(gl.GL_FALSE)
surface["color"] = 0,0,0,1
surface.draw(gl.GL_LINE_LOOP, b_indices)
gl.glDepthMask(gl.GL_TRUE)
model = surface['transform']['model'].reshape(4,4)
view = surface['transform']['view'].reshape(4,4)
surface['view'] = view
surface['model'] = model
surface['normal'] = np.array(np.matrix(np.dot(view, model)).I.T)
def _update(self):
log.debug("GPU: Updating texture cube")
if self.need_update:
gl.glEnable(gl.GL_TEXTURE_CUBE_MAP)
gl.glBindTexture(self.target, self.handle)
targets = [ gl.GL_TEXTURE_CUBE_MAP_POSITIVE_X,
gl.GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
gl.GL_TEXTURE_CUBE_MAP_POSITIVE_Y,
gl.GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
gl.GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
gl.GL_TEXTURE_CUBE_MAP_NEGATIVE_Z ]
for i,target in enumerate(targets):
face = self[i]
pending = self.pending_data
extents = face._extents
if pending is None: continue
if pending[1] < extents[0]: continue
if pending[0] > extents[1]: continue
start = max(extents[0], pending[0]) - extents[0]
stop = min(extents[1], pending[1]) - extents[0]
offset,nbytes = start, stop-start
itemsize = face.strides[1]
offset /= itemsize
nbytes /= itemsize
nbytes += offset % self.width
offset -= offset % self.width
nbytes += (self.width - ((offset + nbytes) % self.width)) % self.width
x = 0
y = offset // self.width
width = self.width
height = nbytes // self.width
gl.glTexSubImage2D(target, 0, x, y, width, height,
self._cpu_format, self.gtype, face)
self._pending_data = None
self._need_update = False
def draw_color(shape, vertex_buffer, index_buffer, mat_model, mat_view, mat_proj,
ambient_weight, bg_color):
program = gloo.Program(_color_vertex_code, _color_fragment_code)
program.bind(vertex_buffer)
program['u_light_eye_pos'] = [0, 0, 0]
program['u_light_ambient_w'] = ambient_weight
program['u_mv'] = _compute_model_view(mat_model, mat_view)
# program['u_nm'] = compute_normal_matrix(model, view)
program['u_mvp'] = _compute_model_view_proj(mat_model, mat_view, mat_proj)
# Frame buffer object
color_buf = np.zeros((shape[0], shape[1], 4), np.float32).view(gloo.TextureFloat2D)
depth_buf = np.zeros((shape[0], shape[1]), np.float32).view(gloo.DepthTexture)
fbo = gloo.FrameBuffer(color=color_buf, depth=depth_buf)
fbo.activate()
# OpenGL setup
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_CULL_FACE)
gl.glCullFace(gl.GL_BACK) # Back-facing polygons will be culled
gl.glClearColor(bg_color[0], bg_color[1], bg_color[2], bg_color[3])
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glViewport(0, 0, shape[1], shape[0])
# Rendering
program.draw(gl.GL_TRIANGLES, index_buffer)
# Retrieve the contents of the FBO texture
rgb = np.zeros((shape[0], shape[1], 4), dtype=np.float32)
gl.glReadPixels(0, 0, shape[1], shape[0], gl.GL_RGBA, gl.GL_FLOAT, rgb)
rgb.shape = shape[0], shape[1], 4
rgb = rgb[::-1, :]
rgb = np.round(rgb[:, :, :3] * 255).astype(np.uint8) # Convert to [0, 255]
fbo.deactivate()
return rgb
def on_draw(dt):
window.clear()
# Cells
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_POLYGON_OFFSET_FILL)
cells.draw()
# Cell outlines
gl.glDisable(gl.GL_POLYGON_OFFSET_FILL)
gl.glEnable(gl.GL_BLEND)
gl.glDepthMask(gl.GL_FALSE)
outlines.draw()
gl.glDepthMask(gl.GL_TRUE)
def on_draw(dt):
window.clear()
# Filled cube
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_POLYGON_OFFSET_FILL)
cube['u_color'] = 1, 1, 1, 1
cube.draw(gl.GL_TRIANGLES, faces)
# Outlined cube
gl.glDisable(gl.GL_POLYGON_OFFSET_FILL)
gl.glEnable(gl.GL_BLEND)
gl.glDepthMask(gl.GL_FALSE)
cube['u_color'] = 0, 0, 0, 1
cube.draw(gl.GL_LINES, outline)
gl.glDepthMask(gl.GL_TRUE)
phi += 0.5 # degrees
model = np.eye(4, dtype=np.float32)
glm.rotate(model, theta, 0, 0, 1)
glm.rotate(model, phi, 0, 1, 0)
cube['model'] = model
# Build cube data
V, I, O = colorcube()
vertices = V.view(gloo.VertexBuffer)
faces = I.view(gloo.IndexBuffer)
outline = O.view(gloo.IndexBuffer)
cube = gloo.Program(vertex, fragment)
cube.bind(vertices)
transform = PVMProjection(Position3D("position"))
cube['transform'] = transform
window.attach(transform)
phi, theta = 0, 0
# OpenGL initalization
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glPolygonOffset(1, 1)
gl.glEnable(gl.GL_LINE_SMOOTH)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glLineWidth(0.75)
# Run
app.run()
@window.event
def on_mouse_scroll(x, y, dx, dy):
scale = C["scale"][0]
C["scale"] = min(max(0.01, scale + .01 * dy * scale), 100)
font = Font("Vera.ttf")
C = gp.GlyphCollection(dtypes=[('translate', np.float32, 2)], translate='shared')
for anchor_x in ['left', 'center', 'right']:
for anchor_y in ['bottom', 'center', 'top']:
C.append("Hello", font, anchor_x=anchor_x, anchor_y=anchor_y, color=(0,0,0,.5))
theta,dtheta = 0,0
C['u_kernel'] = gp.data.get("spatial-filters.npy")
C['atlas_data'] = font.atlas
C['atlas_data'].interpolation = gl.GL_LINEAR
C['atlas_shape'] = font.atlas.shape[1],font.atlas.shape[0]
C['scale'] = 1.0
C['model'] = np.eye(4, dtype=np.float32)
gl.glClearColor(1.0, 1.0, 1.0, 1.0)
gl.glDisable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gp.run()
def on_init(self):
gl.glEnable(gl.GL_VERTEX_PROGRAM_POINT_SIZE)
gl.glEnable(gl.GL_POINT_SPRITE)
def on_draw(dt):
with borders:
window.clear()
gl.glEnable(gl.GL_DEPTH_TEST)
cones.draw(gl.GL_TRIANGLES, I)
def on_init():
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glDisable(gl.GL_BLEND)
def draw_color(shape, vertex_buffer, index_buffer, texture, mat_model, mat_view,
mat_proj, ambient_weight, bg_color, shading):
# Set shader for the selected shading
if shading == 'flat':
color_fragment_code = _color_fragment_flat_code
else: # 'phong'
color_fragment_code = _color_fragment_phong_code
program = gloo.Program(_color_vertex_code, color_fragment_code)
program.bind(vertex_buffer)
program['u_light_eye_pos'] = [0, 0, 0] # Camera origin
program['u_light_ambient_w'] = ambient_weight
program['u_mv'] = _compute_model_view(mat_model, mat_view)
program['u_nm'] = _compute_normal_matrix(mat_model, mat_view)
program['u_mvp'] = _compute_model_view_proj(mat_model, mat_view, mat_proj)
if texture is not None:
program['u_use_texture'] = int(True)
program['u_texture'] = texture
else:
program['u_use_texture'] = int(False)
program['u_texture'] = np.zeros((1, 1, 4), np.float32)
# Frame buffer object
color_buf = np.zeros((shape[0], shape[1], 4), np.float32).view(gloo.TextureFloat2D)
depth_buf = np.zeros((shape[0], shape[1]), np.float32).view(gloo.DepthTexture)
fbo = gloo.FrameBuffer(color=color_buf, depth=depth_buf)
fbo.activate()
# OpenGL setup
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glClearColor(bg_color[0], bg_color[1], bg_color[2], bg_color[3])
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glViewport(0, 0, shape[1], shape[0])
# gl.glEnable(gl.GL_BLEND)
# gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
# gl.glHint(gl.GL_LINE_SMOOTH_HINT, gl.GL_NICEST)
# gl.glHint(gl.GL_POLYGON_SMOOTH_HINT, gl.GL_NICEST)
# gl.glDisable(gl.GL_LINE_SMOOTH)
# gl.glDisable(gl.GL_POLYGON_SMOOTH)
# gl.glEnable(gl.GL_MULTISAMPLE)
# Keep the back-face culling disabled because of objects which do not have
# well-defined surface (e.g. the lamp from the dataset of Hinterstoisser)
gl.glDisable(gl.GL_CULL_FACE)
# gl.glEnable(gl.GL_CULL_FACE)
# gl.glCullFace(gl.GL_BACK) # Back-facing polygons will be culled
# Rendering
program.draw(gl.GL_TRIANGLES, index_buffer)
# Retrieve the contents of the FBO texture
rgb = np.zeros((shape[0], shape[1], 4), dtype=np.float32)
gl.glReadPixels(0, 0, shape[1], shape[0], gl.GL_RGBA, gl.GL_FLOAT, rgb)
rgb.shape = shape[0], shape[1], 4
rgb = rgb[::-1, :]
rgb = np.round(rgb[:, :, :3] * 255).astype(np.uint8) # Convert to [0, 255]
fbo.deactivate()
return rgb
def on_init():
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glPolygonOffset(1, 1)
gl.glEnable(gl.GL_LINE_SMOOTH)
gl.glLineWidth(2.5)
def on_init():
gl.glEnable(gl.GL_DEPTH_TEST)
