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 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(_): 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, 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)