def __init__(self, size=(1600, 900), no_distort=False): '''Distorter object: Applies distortion to Contexts and drawables - size (X, Y): Size of monitor - distortion (Bool): Apply distortion or not? ''' self.size = size self.left_eye_tex = gloo.Texture2D(shape=(4096, 4096) + (3, )) self.right_eye_tex = gloo.Texture2D(shape=(4096, 4096) + (3, )) self.left_eye = gloo.FrameBuffer(self.left_eye_tex, gloo.RenderBuffer(self.size)) self.right_eye = gloo.FrameBuffer(self.right_eye_tex, gloo.RenderBuffer(self.size)) self.left_eye_program, self.left_eye_indices = Mesh.make_eye( self.left_eye_tex, 'left') self.right_eye_program, self.right_eye_indices = Mesh.make_eye( self.right_eye_tex, 'right') self.IPD = 0.0647 # Interpupilary distance in m # Male: 64.7 mm # Female: 62.3 mm self.L_projection = parameters.projection_left.T self.R_projection = parameters.projection_right.T self.no_distort = no_distort if self.no_distort: self.projection = perspective(30.0, 1920 / float(1080), 2.0, 10.0) self.draw = self.draw_no_distortion else: self.draw = self.draw_distortion
def init_BufX(self): # Create texture to render to # Create FBO, attach the color buffer and depth buffer self._texX = [] self._fboX = [] self._BufX = [] self._texX.append([]) self._fboX.append([]) self._texX.append([]) self._fboX.append([]) for i in range(4): self._texX[0].append( gloo.Texture2D(shape=self._render_size[::-1] + (4, ), format='rgba', interpolation='linear', wrapping='repeat', internalformat='rgba32f')) self._fboX[0].append( gloo.FrameBuffer( self._texX[0][i], gloo.RenderBuffer(shape=self._render_size[::-1]))) self._texX[1].append( gloo.Texture2D(shape=self._render_size[::-1] + (4, ), format='rgba', interpolation='linear', wrapping='repeat', internalformat='rgba32f')) self._fboX[1].append( gloo.FrameBuffer( self._texX[1][i], gloo.RenderBuffer(shape=self._render_size[::-1]))) self._BufX.append( gloo.Program(vertex, fragment_template % error_shader))
def test_buffer(self): # Some data that we need data = np.zeros(100, np.uint16) im2 = np.zeros((50, 50), np.uint16) im3 = np.zeros((20, 20, 20), np.uint16) shaders = gloo.VertexShader("x"), gloo.FragmentShader("x") items = [ # Buffers (gloo.buffer.Buffer(target=gl.GL_ARRAY_BUFFER), 'set_data', data), (gloo.buffer.VertexBuffer(np.uint16), 'set_data', data), (gloo.buffer.ElementBuffer(np.uint16), 'set_data', data), # Textures (gloo.Texture2D(), 'set_data', im2), (gloo.Texture3D(), 'set_data', im3), # FBO stuff (gloo.RenderBuffer(), 'set_shape', (1, 1)), (gloo.FrameBuffer(), 'attach_color', gloo.RenderBuffer((1, 1))), # Shader stuff (gloo.VertexShader(), 'set_code', "x"), (gloo.FragmentShader(), 'set_code', "x"), (gloo.Program(), 'attach', shaders), ] for ob, funcname, value in items: self._fix_ob(ob) #print('Testing GLObject compliance for %s' % ob.__class__.__name__) # Initially a clear state self.assertEqual(ob._need_update, False) # Set value, now we should have a "dirty" state x = ob for part in funcname.split('.'): x = getattr(x, part) x(value) self.assertEqual(ob._need_update, True) # Activate the object ob.activate() # Now we should be activated self.assertEqual(len(ob._actions), 3) self.assertEqual(ob._actions[0], 'create') self.assertEqual(ob._actions.count('update'), 1) self.assertEqual(ob._actions.count('activate'), 1) # Deactivate ob.deactivate() # Now we should be deactivated self.assertEqual(len(ob._actions), 4) self.assertEqual(ob._actions[-1], 'deactivate') # Activate some more for i in range(10): ob.activate() # Create and update should not have been called self.assertEqual(ob._actions.count('create'), 1) self.assertEqual(ob._actions.count('update'), 1)
def __init__(self, canvas=None, _protocol=None): if canvas is None: canvas = gloo.context.FakeCanvas() self.canvas: app.Canvas = canvas self.parameters: Dict[str, Any] = dict() self.custom_programs: Dict[str, gloo.Program] = dict() self.data_appendix: Dict[str, Any] = dict() self.transform_uniforms = dict() self.protocol: protocol.AbstractProtocol = _protocol self._buffer_shape = (calib.CALIB_DISP_WIN_SIZE_HEIGHT, calib.CALIB_DISP_WIN_SIZE_WIDTH) self._out_texture = gloo.Texture2D(self._buffer_shape + (3, ), format='rgb') self._out_fb = gloo.FrameBuffer(self._out_texture) self.frame = self._out_fb # Create display program: renders the out texture from FB to screen self.square = [[-1, -1], [-1, 1], [1, -1], [1, 1]] self._display_prog = gloo.Program(self._vertex_display, self._frag_display, count=4) self._display_prog['a_position'] = self.square self._display_prog['u_texture'] = self._out_texture # Get all visual parameters self.static_parameters: List[Parameter] = [] self.variable_parameters: List[Parameter] = [] self.trigger_functions: List[Callable] = [] self._collect_parameters() self.is_active = True gloo.set_state(depth_test=True)
def __init__(self, size, cam): config = dict(red_size=8, green_size=8, blue_size=8, alpha_size=8, depth_size=24, stencil_size=0, double_buffer=True, stereo=False, samples=0) app.Canvas.__init__(self, show=False, size=size, config=config) self.shape = (size[1], size[0]) self.yz_flip = np.eye(4, dtype=np.float32) self.yz_flip[1, 1], self.yz_flip[2, 2] = -1, -1 self.set_cam(cam) # Set up shader programs self.program_col = gloo.Program(_vertex_code_colored, _fragment_code_colored) self.program_tex = gloo.Program(_vertex_code_textured, _fragment_code_textured) # Texture where we render the color/depth and its FBO self.col_tex = gloo.Texture2D(shape=self.shape + (3, )) self.fbo = gloo.FrameBuffer(self.col_tex, gloo.RenderBuffer(self.shape)) self.fbo.activate() gloo.set_state(depth_test=True, blend=False, cull_face=True) gl.glEnable(gl.GL_LINE_SMOOTH) gloo.set_clear_color((0.0, 0.0, 0.0)) gloo.set_viewport(0, 0, *self.size)
def cubemap_to_dual_paraboloid(cube_faces): _, height, width, n_channels = cube_faces.shape height, width = height * 2, width * 2 internal_format = 'rgba32f' if n_channels == 4 else 'rgb32f' with ContextProvider((height, width)): rendtex = gloo.Texture2D((height, width, n_channels), interpolation='linear', wrapping='repeat', internalformat=internal_format) framebuffer = gloo.FrameBuffer( rendtex, gloo.RenderBuffer((width, height, n_channels))) program = CubemapToDualParaboloidProgram().compile() program['u_cubemap'] = gloo.TextureCubeMap( cube_faces, internalformat=internal_format, mipmap_levels=8) results = [] for i in [0, 1]: with framebuffer: gloo.set_viewport(0, 0, width, height) program['u_hemisphere'] = i program.draw(gl.GL_TRIANGLE_STRIP) results.append( np.flipud( gloo.read_pixels(out_type=np.float32, format='rgb'))) return results[0], results[1]
def __init__(self, size, num_points: int, center, color, radius): '''[summary] Arguments: size {[type]} -- size of the rendered image num_points {int} -- number of valid depth values center {[type]} -- the (x, y) coordinate of each valid depth value color {[type]} -- encode the 16bit depth value to (R, G) channels, corresponding to 'center' ''' # We hide the canvas upon creation. app.Canvas.__init__(self, show=False, size=size) self._t0 = time() # Texture where we render the scene. self._rendertex = gloo.Texture2D(shape=size[::-1] + (4, )) # FBO. self._fbo = gloo.FrameBuffer(self._rendertex, gloo.RenderBuffer(size[::-1])) # Regular program that will be rendered to the FBO. V = np.zeros(num_points, [("center", np.float32, 2), ("color", np.float32, 3), ("radius", np.float32, 1)]) V["center"] = center V["color"] = color V["radius"] = radius self.program = gloo.Program(vertex, fragment) self.program.bind(gloo.VertexBuffer(V)) self.program['resolution'] = self.size # We manually draw the hidden canvas. self.update()
def __init__(self, size, cam): app.Canvas.__init__(self, show=False, size=size) self.shape = (size[1], size[0]) self.yz_flip = np.eye(4, dtype=np.float32) self.yz_flip[1, 1], self.yz_flip[2, 2] = -1, -1 self.set_cam(cam) # Set up shader programs self.program_col = gloo.Program(_vertex_code_colored, _fragment_code_colored) self.program_bbox = gloo.Program(_vertex_code_colored, _fragment_code_bbox) self.program_tex = gloo.Program(_vertex_code_textured, _fragment_code_textured) self.program_bg = gloo.Program(_vertex_code_background, _fragment_code_background) # Texture where we render the color/depth and its FBO self.col_tex = gloo.Texture2D(shape=self.shape + (3,)) self.fbo = gloo.FrameBuffer(self.col_tex, gloo.RenderBuffer(self.shape)) self.fbo.activate() gloo.set_state(depth_test=True, blend=False, cull_face=True) gl.glEnable(gl.GL_LINE_SMOOTH) gloo.set_clear_color((0.0, 0.0, 0.0)) gloo.set_viewport(0, 0, *self.size) # Set up background render quad in NDC quad = [[-1, -1], [1, -1], [1, 1], [-1, 1]] tex = [[0, 1], [1, 1], [1, 0], [0, 0]] vertices_type = [('a_position', np.float32, 2), ('a_texcoord', np.float32, 2)] collated = np.asarray(list(zip(quad, tex)), vertices_type) self.bg_vbuffer = gloo.VertexBuffer(collated) self.bg_ibuffer = gloo.IndexBuffer([0, 1, 2, 0, 2, 3])
def __init__(self, program, rview=1, zview=None, zoom_speed=0.1, move_speed=0.01, *args, **kwargs): """ Constructor """ InteractiveViewportMixin.__init__(self, rview, zview, zoom_speed, move_speed) Canvas.__init__(self, *args, **kwargs) # self._program = program self._program.set_projection_matrix(self.get_projection_matrix()) self._program.set_view_matrix(self.get_view_matrix()) # Set up framebuffer width, height = self.physical_size shape = (height, width, 3) rendertex = gloo.Texture2D(shape) self._fbo = gloo.FrameBuffer(rendertex, gloo.RenderBuffer(shape)) self._display_program = TextureDisplayShader(rendertex)
def draw_color(self): program = gloo.Program(_color_vertex_code, _color_fragment_code) program.bind(self.vertex_buffer) program['u_light_eye_pos'] = [0, 0, 0] program['u_light_ambient_w'] = self.ambient_weight program['u_mv'] = _compute_model_view(self.mat_model, self.mat_view) # program['u_nm'] = compute_normal_matrix(self.model, self.view) program['u_mvp'] = _compute_model_view_proj(self.mat_model, self.mat_view, self.mat_proj) # Texture where we render the scene render_tex = gloo.Texture2D(shape=self.shape + (4, )) # Frame buffer object fbo = gloo.FrameBuffer(render_tex, gloo.RenderBuffer(self.shape)) with fbo: gloo.set_state(depth_test=True) gloo.set_state(cull_face=True) gloo.set_cull_face('back') # Back-facing polygons will be culled gloo.set_clear_color(self.bg_color) gloo.clear(color=True, depth=True) gloo.set_viewport(0, 0, *self.size) program.draw('triangles', self.index_buffer) # Retrieve the contents of the FBO texture self.rgb = gloo.read_pixels( (0, 0, self.size[0], self.size[1]))[:, :, :3] self.rgb = np.copy(self.rgb)
def render(self, region=None, size=None, bgcolor=None, crop=None): self.set_current() # Set up a framebuffer to render to offset = (0, 0) if region is None else region[:2] csize = self.size if region is None else region[2:] s = self.pixel_scale size = tuple([x * s for x in csize]) if size is None else size fbo = gloo.FrameBuffer(color=gloo.RenderBuffer(size[::-1]), depth=gloo.RenderBuffer(size[::-1])) self.push_fbo(fbo, offset, csize) try: if crop is None: h, w = fbo.color_buffer.shape[:2] crop = (0, 0, w, h) self._draw_scene(bgcolor=bgcolor) color = read_pixels(crop, mode='color', out_type='unsigned_byte') depth = read_pixels(crop, mode='depth', out_type='float') return color, depth finally: self.pop_fbo()
def draw_depth(self): program = gloo.Program(_depth_vertex_code, _depth_fragment_code) program.bind(self.vertex_buffer) program['u_mv'] = _compute_model_view(self.mat_model, self.mat_view) program['u_mvp'] = _compute_model_view_proj(self.mat_model, self.mat_view, self.mat_proj) # Texture where we render the scene render_tex = gloo.Texture2D(shape=self.shape + (4, ), format=gl.GL_RGBA, internalformat=gl.GL_RGBA32F) # Frame buffer object fbo = gloo.FrameBuffer(render_tex, gloo.RenderBuffer(self.shape, format='depth')) with fbo: gloo.set_state(depth_test=True) gloo.set_state(cull_face=True) gloo.set_cull_face('back') # Back-facing polygons will be culled gloo.set_clear_color((0.0, 0.0, 0.0, 0.0)) gloo.clear(color=True, depth=True) gloo.set_viewport(0, 0, *self.size) program.draw('triangles', self.index_buffer) # Retrieve the contents of the FBO texture self.depth = self.read_fbo_color_rgba32f(fbo) self.depth = self.depth[:, :, 0] # Depth is saved in the first channel
def draw_segmentation(self): program = gloo.Program(_segmentation_vertex_code, _segmentation_fragment_code) # Texture where we render the scene render_tex = gloo.Texture2D(shape=self.shape + (4, )) # Frame buffer object fbo = gloo.FrameBuffer(render_tex, gloo.RenderBuffer(self.shape)) self.do_render(program, fbo, self.retrieve_segmentation)
def __init__(self, size=(960, 540)): app.Canvas.__init__(self, show=False, size=size) self._t0 = time() self._rendertex = gloo.Texture2D(shape=self.size[::-1] + (4, )) self._fbo = gloo.FrameBuffer(self._rendertex, gloo.RenderBuffer(self.size[::-1])) self.program = gloo.Program(vertex, fragment)
def draw_color(self): program = gloo.Program(_color_vertex_code, _color_fragment_code) program['u_light_eye_pos'] = [0, 0, 0] program['u_light_ambient_w'] = self.ambient_weight # Texture where we render the scene render_tex = gloo.Texture2D(shape=self.shape + (4, )) # Frame buffer object fbo = gloo.FrameBuffer(render_tex, gloo.RenderBuffer(self.shape)) self.do_render(program, fbo, self.retrieve_color)
def __init__(self, *args, **kwargs): AbstractVisual.__init__(self, *args, **kwargs) # Create mask model self._mask_model = sphere.UVSphere(azim_lvls=50, elev_lvls=50, azimuth_range=np.pi / 2, upper_elev=np.pi / 4, radius=1.0) self._mask_position_buffer = gloo.VertexBuffer( self._mask_model.a_position) self._mask_index_buffer = gloo.IndexBuffer(self._mask_model.indices) # Set textures and FBs self._mask_texture = gloo.Texture2D(self._buffer_shape + (3, ), format='rgb') self._mask_depth_buffer = gloo.RenderBuffer(self._buffer_shape) self._mask_fb = gloo.FrameBuffer(self._mask_texture, self._mask_depth_buffer) self._raw_texture = gloo.Texture2D(self._buffer_shape + (3, ), format='rgb') self._raw_depth_buffer = gloo.RenderBuffer(self._buffer_shape) self._raw_fb = gloo.FrameBuffer(self._raw_texture, self._raw_depth_buffer) self._display_texture = gloo.Texture2D(self._buffer_shape + (3, ), format='rgb') self._display_fb = gloo.FrameBuffer(self._display_texture) # Create mask program: renders binary mask of quarter-sphere to FB sphere_vert = self.parse_vertex_shader(self._sphere_vert) self._mask_program = gloo.Program(sphere_vert, self._mask_frag) self._mask_program['a_position'] = self._mask_position_buffer # Create out program: renders the output texture to FB # by combining raw and mask textures # (to be saved and re-rendered in display program) # square = [[-1, -1], [-1, 1], [1, -1], [1, 1]] self._out_prog = gloo.Program(self._out_vert, self._out_frag, count=4) self._out_prog['a_position'] = self.square self._out_prog['u_raw_texture'] = self._raw_texture self._out_prog['u_mask_texture'] = self._mask_texture self._out_prog['u_out_texture'] = self._out_texture
def create_rend_target(size): shape = (size[1], size[0]) rendtex = gloo.Texture2D((*shape, 4), interpolation='linear', internalformat='rgba32f') depthtex = gloo.Texture2D((*shape, 1), format='depth_component', internalformat='depth_component32_oes') framebuffer = gloo.FrameBuffer(rendtex, depthtex) return framebuffer, rendtex, depthtex
def draw_obj_coords(self): program = gloo.Program(_obj_coords_vertex_code, _obj_coords_fragment_code) # Texture where we render the scene render_tex = gloo.Texture2D(shape=self.shape + (4, ), format=gl.GL_RGBA, internalformat=gl.GL_RGBA32F) # Frame buffer object fbo = gloo.FrameBuffer(render_tex, gloo.RenderBuffer(self.shape)) self.do_render(program, fbo, self.retrieve_obj_coords)
def __init__(self, camera, mesh, vertex_shader=VERTEX_SHADER_BASIC, fragment_shader=FRAGMENT_SHADER_COLOR, clip_near=0.001, clip_far=100.0, background_color=(.0, .0, .0), ambient_light=0.15, directional_light_vector=[0., 0., 0.]): """ Initialize the mesh renderer :param camera: Camera instance :param mesh: Mesh containing vertices and faces (e.g. fom PyMesh) :param vertex_shader: Vertex shader code :param fragment_shader: Fragment shader code :param clip_near: Clip-near value (elements closer than this won't be rendered) :param clip_far: Clip-far value (elements farther than this won't be rendered) :param background_color: Background color :param ambient_light: Ambient light factor :param directional_light_vector: Vector of directional light """ # Initialize Vispy canvas: app.Canvas.__init__(self, show=False, size=camera.image_size) self.shape = (camera.image_size[1], camera.image_size[0]) self.camera = camera self.mesh = mesh self.background_color = background_color self.ambient_light = ambient_light self.directional_light_vector = np.asarray(directional_light_vector) self.clip_near = clip_near self.clip_far = clip_far # OpenGL shader program: self.gl_program = gloo.Program(vertex_shader, fragment_shader) # Matrix to convert to OpenGL camera system (flipping Y-Z axes): self.yz_flip = np.eye(4, dtype=np.float32) self.yz_flip[1, 1], self.yz_flip[2, 2] = -1, -1 # Model matrix (defining the mesh/model pose): self.model_matrix = np.eye(4, dtype=np.float32) # Projection matrix: self.projection_matrix = convert_hz_intrinsic_to_opengl_projection( camera.K, 0, 0, camera.image_size[0], camera.image_size[1], clip_near, clip_far, True) # Texture to render the image into:FBO self.image_texture = gloo.Texture2D(shape=self.shape + (3,)) # Corresponding FBO (frame buffer): self.fbo = gloo.FrameBuffer(self.image_texture, gloo.RenderBuffer(self.shape)) self.fbo.activate() # Drawing parameters (face culling, background color, viewport size, etc.): gloo.set_state(depth_test=True, blend=False, cull_face=False) gloo.set_clear_color(background_color) gloo.set_viewport(0, 0, *self.size)
def generate_image(img_def): c = context.FakeCanvas() img = _load_img(img_def['background']['path']) h, w, _ = img.shape render_fbo = gloo.FrameBuffer(gloo.Texture2D(img), gloo.RenderBuffer( (h, w))) program = gloo.Program(_vert_std, _frag_tex) program['a_pos'] = _unit_square() program['a_tex_coord'] = _unit_square() gloo.set_state(blend=True, blend_func=('one', 'one_minus_src_alpha'), depth_test=True, depth_func='always') with render_fbo: gloo.set_viewport(0, 0, w, h) gloo.set_clear_depth(0) gloo.clear(depth=True, color=False) instances = img_def['instances'] # The unsigned byte depth buffer extraction sets a limit of 255 instances. # Can be extracted as short if necessary. assert (len(instances) <= 255) for i, inst in enumerate(instances): img = _load_img(inst['path']) ih, iw, _ = img.shape x, y, s, r = (inst[k] for k in ['x', 'y', 's', 'r']) program['u_tex'] = gloo.Texture2D(img, interpolation='linear') program['u_mvp'] = \ transforms.translate((-0.5, -0.5, 0)) @ \ transforms.scale((s * iw, s * ih, 1)) @ \ transforms.rotate(r, (0, 0, 1)) @ \ transforms.translate((x, y, -i-1)) @ \ transforms.ortho(0, w, 0, h, 0, 255) program.draw() rgb = render_fbo.read(alpha=False) depth = gl.glReadPixels(0, 0, w, h, gl.GL_DEPTH_COMPONENT, gl.GL_UNSIGNED_BYTE) if not isinstance(depth, np.ndarray): depth = np.frombuffer(depth, np.uint8) depth = np.flip(depth.reshape(h, w), axis=0) masks = np.empty((h, w, len(instances)), np.bool) for i in range(len(instances)): masks[:, :, i] = depth == i + 1 return rgb, depth, masks
def render(self, size=(400, 400)): self.set_current() fbo = gloo.FrameBuffer(color=gloo.RenderBuffer(size[::-1]), depth=gloo.RenderBuffer(size[::-1])) try: self.update_resolution(size) fbo.activate() self.program.draw() return fbo.read() finally: fbo.deactivate() self.update_resolution()
def __init__(self, im, conf, roi, logger): vispy.set_log_level('DEBUG') try: vispy.use(app='glfw', gl='gl+') except RuntimeError as e: pass app.Canvas.__init__(self, keys = 'interactive', size = (conf['ipmWidth'], conf['ipmHeight']), position = (0,0), title = 'IPM', show = False, resizable = False) self._rendertex = gloo.Texture2D(shape=(self.size[1], self.size[0], 4)) self._fbo = gloo.FrameBuffer(self._rendertex, gloo.RenderBuffer((self.size[1], self.size[0]))) try: fragmentShaderSourceString = open(FRAGMENT_SHADER_FILENAME).read() except: logger.fatal("%s does not exist !", FRAGMENT_SHADER_FILENAME) sys.exit() try: vertexShaderSourceString = open(VERTEX_SHADER_FILENAME).read() except: logger.fatal("%s does not exist !", VERTEX_SHADER_FILENAME) sys.exit() self.program = gloo.Program(vertexShaderSourceString, fragmentShaderSourceString) self.program["position"] = [(-1, -1), (-1, 1), (1, 1), (-1, -1), (1, 1), (1, -1)] gloo.set_viewport(0, 0, *self.size) tex = gloo.Texture2D(im) tex.interpolation = 'linear' tex.wrapping = 'repeat' self.program['iChannel'] = tex if len(im.shape) == 3: self.program['iChannelResolution'] = (im.shape[1], im.shape[0], im.shape[2]) else: self.program['iChannelResolution'] = (im.shape[1], im.shape[0], 1) self.program['iResolution'] = (self.size[0], self.size[1], 0.) self.getUniforms(conf, roi) self.update() app.run() return self
def __init__(self, size=(512, 512), save_png=False, compression=0, layer_cls=VispyLayer, **kwargs): app.Canvas.__init__(self, size=size, **kwargs) Renderer.__init__(self, size=size, save_png=save_png, compression=compression, layer_cls=layer_cls) self._rendertex = gloo.Texture2D(shape=self._size + (4, )) self._fbo = gloo.FrameBuffer(self._rendertex, gloo.RenderBuffer(self._size))
def __init__(self, mesh, color, size): # We hide the canvas upon creation. app.Canvas.__init__(self, show=False, size=size) self._t0 = time() # Texture where we render the scene. self._rendertex = gloo.Texture2D(shape=self.size[::-1] + (4, ), internalformat='rgba32f') # FBO. self._fbo = gloo.FrameBuffer(self._rendertex, gloo.RenderBuffer(self.size[::-1])) # Regular program that will be rendered to the FBO. self.program = gloo.Program(vertex_shader, fragment_shader) self.program["position"] = mesh self.program['color'] = color # We manually draw the hidden canvas. self.update()
def __init__(self, size, near, far, camera, *args, **kwargs): super().__init__(size=size, *args, **kwargs) gloo.set_state(depth_test=True) gloo.set_viewport(0, 0, *self.size) self.program = None self.size = size self.far = far self.near = near # Buffer shapes are HxW, not WxH... self._rendertex = gloo.Texture2D(shape=(size[1], size[0]) + (4, )) self._fbo = gloo.FrameBuffer( self._rendertex, gloo.RenderBuffer(shape=(size[1], size[0]))) self.camera = camera self.model_mat = np.eye(4) self.mesh = None
def __init__(self, size=(600, 600)): # We hide the canvas upon creation. app.Canvas.__init__(self, show=False, size=size) self._t0 = time() # Texture where we render the scene. self._rendertex = gloo.Texture2D(shape=self.size + (4,)) # FBO. self._fbo = gloo.FrameBuffer(self._rendertex, gloo.RenderBuffer(self.size)) # Regular program that will be rendered to the FBO. self.program = gloo.Program(vertex, fragment) self.program["position"] = [(-1, -1), (-1, 1), (1, 1), (-1, -1), (1, 1), (1, -1)] self.program["scale"] = 3 self.program["center"] = [-0.5, 0] self.program["iter"] = 300 self.program['resolution'] = self.size # We manually draw the hidden canvas. self.update()
def __init__(self, title, width=800, height=600, wireframe=False, pixel_scale=1.0 ): app.Canvas.__init__(self, resizable=False, size=(width, height), show=False, px_scale=pixel_scale ) self.width = width self.height = height self.wireframe = wireframe self._rendertex = gloo.Texture2D(shape=(height,width,4), internalformat="rgba32f") #self._rendertex = gloo.Texture2D(shape=(height,width,4), internalformat="rgba8") self._fbo = gloo.FrameBuffer(self._rendertex, gloo.RenderBuffer((height,width,4) )) self.quad_bg = gloo.Program(vertex_bg, fragment_bg, count=4) self.quad_bg['position'] = [(-1, -1), (-1, +1), (+1, -1), (+1, +1)] self.quad_bg['texcoord'] = [(0, 1), (0, 0), (1, 1), (1, 0)] gloo.set_clear_color('white') self.update()
def __init__(self): app.Canvas.__init__(self, keys='interactive') self.size = 560, 420 # Create texture to render to shape = self.size[1], self.size[0] self._rendertex = gloo.Texture2D((shape + (3, ))) # Create FBO, attach the color buffer and depth buffer self._fbo = gloo.FrameBuffer(self._rendertex, gloo.RenderBuffer(shape)) # Create program to render a shape self._program1 = gloo.Program(VERT_SHADER1, FRAG_SHADER1) self._program1['u_color'] = 0.9, 1.0, 0.4, 1 self._program1['a_position'] = gloo.VertexBuffer(vPosition) # Create program to render FBO result self._program2 = gloo.Program(VERT_SHADER2, FRAG_SHADER2) self._program2['a_position'] = gloo.VertexBuffer(vPosition) self._program2['a_texcoord'] = gloo.VertexBuffer(vTexcoord) self._program2['u_texture1'] = self._rendertex
def __init__(self): app.Canvas.__init__(self) self.size = 560, 420 # Create texture to render to self._rendertex = gloo.Texture2D() # Create FBO, attach the color buffer and depth buffer self._fbo = gloo.FrameBuffer(self._rendertex, gloo.RenderBuffer()) # Create program to render a shape self._program1 = gloo.Program( gloo.VertexShader(VERT_SHADER1), gloo.FragmentShader(FRAG_SHADER1) ) self._program1['u_color'] = 0.9, 1.0, 0.4, 1 self._program1['a_position'] = gloo.VertexBuffer(vPosition) # Create program to render FBO result self._program2 = gloo.Program( gloo.VertexShader(VERT_SHADER2), gloo.FragmentShader(FRAG_SHADER2) ) self._program2['a_position'] = gloo.VertexBuffer(vPosition) self._program2['a_texcoord'] = gloo.VertexBuffer(vTexcoord) self._program2['u_texture1'] = self._rendertex
def __init__(self): app.Canvas.__init__(self) # Create program self._program = gloo.Program(VERT_SHADER, FRAG_SHADER) # Creat FBO self._fbo = gloo.FrameBuffer() self._fbo.attach_depth(gloo.RenderBuffer(im1.shape)) # Create vbo self._vbo = gloo.VertexBuffer(vertex_data) # Create textures self._tex1 = gloo.Texture2D(im1) self._tex2 = gloo.Texture2D(im1.shape) for tex in (self._tex1, self._tex2): tex.set_filter('NEAREST', 'NEAREST') # Set uniforms and attributes self._program.set_vars(self._vbo) self._program['u_texsize'] = im1.shape[1], im1.shape[0]