def on_initialize(self, event): # Build cube data V, I, O = create_cube() vertices = VertexBuffer(V) self.faces = IndexBuffer(I) self.outline = IndexBuffer(O) # Build program # -------------------------------------- self.program = Program(vertex, fragment) self.program.bind(vertices) # Build view, model, projection & normal # -------------------------------------- view = np.eye(4, dtype=np.float32) model = np.eye(4, dtype=np.float32) translate(view, 0, 0, -5) self.program['u_model'] = model self.program['u_view'] = view self.phi, self.theta = 0, 0 # OpenGL initalization # -------------------------------------- gloo.set_state(clear_color=(0.30, 0.30, 0.35, 1.00), depth_test=True, polygon_offset=(1, 1), line_width=0.75, blend_func=('src_alpha', 'one_minus_src_alpha')) self.timer.start()
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.timer = app.Timer('auto', connect=self.on_timer, start=True) with open('vertex.glsl') as f: self.vshader = f.read() with open('fragment.glsl') as f: self.fshader = f.read() self.program = Program(self.vshader, self.fshader) v, i, iOutline = create_cube() self.vertices = VertexBuffer(v) self.indices = IndexBuffer(i) self.outlineIndices = IndexBuffer(iOutline) self.program.bind(self.vertices) self.theta, self.phi = 0, 0 self.program['model'] = np.eye(4) self.program['view'] = translate([0, 0, -5]) self.program['texture'] = checkerboard() gloo.set_state(clear_color=(0.30, 0.30, 0.35, 1.00), polygon_offset=(1, 1), blend_func=('src_alpha', 'one_minus_src_alpha'), line_width=5, depth_test=True)
def on_initialize(self, event): # Build cube data V, F, O = create_cube() vertices = VertexBuffer(V) self.faces = IndexBuffer(F) self.outline = IndexBuffer(O) # Build view, model, projection & normal # -------------------------------------- self.view = np.eye(4, dtype=np.float32) model = np.eye(4, dtype=np.float32) translate(self.view, 0, 0, -5) normal = np.array(np.matrix(np.dot(self.view, model)).I.T) # Build program # -------------------------------------- self.program = Program(vertex, fragment) self.program.bind(vertices) self.program["u_light_position"] = 2, 2, 2 self.program["u_light_intensity"] = 1, 1, 1 self.program["u_model"] = model self.program["u_view"] = self.view self.program["u_normal"] = normal self.phi, self.theta = 0, 0 # OpenGL initalization # -------------------------------------- gloo.set_state(clear_color=(0.30, 0.30, 0.35, 1.00), depth_test=True, polygon_offset=(1, 1), blend_func=('src_alpha', 'one_minus_src_alpha'), line_width=0.75) self.timer.start()
def __init__(self): app.Canvas.__init__(self, size=(512, 512), title='Rotating cube', keys='interactive') self.timer = app.Timer('auto', self.on_timer) # Build cube data V, I, O = create_cube() vertices = VertexBuffer(V) self.faces = IndexBuffer(I) self.outline = IndexBuffer(O) # Build program # -------------------------------------- self.program = Program(vertex, fragment) self.program.bind(vertices) # Build view, model, projection & normal # -------------------------------------- view = np.eye(4, dtype=np.float32) model = np.eye(4, dtype=np.float32) translate(view, 0, 0, -5) self.program['u_model'] = model self.program['u_view'] = view self.phi, self.theta = 0, 0 # OpenGL initalization # -------------------------------------- gloo.set_state(clear_color=(0.30, 0.30, 0.35, 1.00), depth_test=True, polygon_offset=(1, 1), line_width=0.75, blend_func=('src_alpha', 'one_minus_src_alpha')) self.timer.start()
def __init__(self): app.Canvas.__init__(self, size=(512, 512), title='Textured cube', keys='interactive') self.timer = app.Timer('auto', self.on_timer) # Build cube data V, I, _ = create_cube() vertices = VertexBuffer(V) self.indices = IndexBuffer(I) # Build program self.program = Program(vertex, fragment) self.program.bind(vertices) # Build view, model, projection & normal view = np.eye(4, dtype=np.float32) model = np.eye(4, dtype=np.float32) translate(view, 0, 0, -5) self.program['model'] = model self.program['view'] = view self.program['texture'] = checkerboard() self.phi, self.theta = 0, 0 # OpenGL initalization gloo.set_state(clear_color=(0.30, 0.30, 0.35, 1.00), depth_test=True) self.timer.start()
def render(mesh, view): program['xyz'] = mesh.vertices program['color'] = mesh.colors program['model'] = mesh.transform program['view'] = view.transform program['projection'] = view.proj program.draw('triangles', IndexBuffer(mesh.indices))
def __init__(self): app.Canvas.__init__(self, size=(512, 512), title='Colored cube', keys='interactive') # Build cube data V, I, _ = create_cube() vertices = VertexBuffer(V) self.indices = IndexBuffer(I) # Build program self.program = Program(vertex, fragment) self.program.bind(vertices) # Build view, model, projection & normal view = translate((0, 0, -5)) model = np.eye(4, dtype=np.float32) self.program['model'] = model self.program['view'] = view self.phi, self.theta = 0, 0 gloo.set_state(clear_color=(0.30, 0.30, 0.35, 1.00), depth_test=True) self.activate_zoom() self.timer = app.Timer('auto', self.on_timer, start=True) self.show()
def uvsphere(radius, h, v): size = h*v index_count = size*2 - h*2 # hard to explain # What is rad for? rad = np.full(size, radius, dtype=np.float32) azi = np.zeros(size, dtype=np.float32) inc = np.zeros(size, dtype=np.float32) tex = np.zeros((size, 2), dtype=np.float32) ind = np.zeros(index_count, dtype=np.uint32) # TODO: Explain this boggy mess. for row in range(h): lat = pi * row / (h-1) t_y = row / (h-1) for col in range(v): i = row*h + col lon = pi * 2 * col / (v-1) t_x = col / (v-1) inc[i] = lat azi[i] = lon tex[i, :] = (t_x, t_y) # Generate indices for triangle_strip in another step. n1, n2 = 0, h for i in range(index_count): if i%2 == 0: ind[i] = n1 n1 += 1 else: ind[i] = n2 n2 += 1 #print(list(zip(azi, inc))) print(ind) return rad, azi, inc, tex, IndexBuffer(ind)
def make_eye(self, texture, eye): '''make_eye (eye_texture, eye) Arguments: - eye_texture: The texture (bound to a framebuffer), that represents the view of the eye - eye: 'left' or 'right', the eye being rendered Todo: - Use vertex buffer instead of manually binding ''' assert isinstance(texture, Texture2D), "texture not a texture 2D instance!" assert eye in ['left', 'right' ], eye + " is not a valid eye (Should be left or right)" program = Program(self._vert_shader, self._frag_shader) i_buffer = self._i_buffers[eye + '_indices'] _buffer = self._v_buffers[eye + '_buffer'] Logger.log('Loading {} eye distortion mesh pos'.format(eye)) program['pos'] = _buffer['pos'] Logger.log('Loading {} eye distortion mesh red_xy'.format(eye)) program['red_xy'] = _buffer['red_xy'] Logger.log('Loading {} eye distortion mesh green_xy'.format(eye)) program['green_xy'] = _buffer['green_xy'] Logger.log('Loading {} eye distortion mesh blue_xy'.format(eye)) program['blue_xy'] = _buffer['blue_xy'] program['vignette'] = _buffer['vignette'] program['texture'] = texture return program, IndexBuffer(i_buffer)
def _update(self): """ Update vertex buffers & texture """ if self._vertices_buffer is not None: self._vertices_buffer.delete() self._vertices_buffer = VertexBuffer(self._vertices_list.data) if self.itype is not None: if self._indices_buffer is not None: self._indices_buffer.delete() self._indices_buffer = IndexBuffer(self._indices_list.data) if self.utype is not None: if self._uniforms_texture is not None: self._uniforms_texture.delete() # We take the whole array (_data), not the data one texture = self._uniforms_list._data.view(np.float32) size = len(texture) / self._uniforms_float_count shape = self._compute_texture_shape(size) # shape[2] = float count is only used in vertex shader code texture = texture.reshape(shape[0], shape[1], 4) self._uniforms_texture = Texture2D(texture) self._uniforms_texture.data = texture self._uniforms_texture.interpolation = "nearest" if len(self._programs): for program in self._programs: program.bind(self._vertices_buffer) if self._uniforms_list is not None: program["uniforms"] = self._uniforms_texture program["uniforms_shape"] = self._ushape
def __init__(self, vol, clim=None, method='mip', threshold=None, relative_step_size=0.8, cmap='grays', emulate_texture=False): tex_cls = TextureEmulated3D if emulate_texture else Texture3D # Storage of information of volume self._vol_shape = () self._clim = None self._need_vertex_update = True # Set the colormap self._cmap = get_colormap(cmap) # Create gloo objects self._vertices = VertexBuffer() self._texcoord = VertexBuffer( np.array([ [0, 0, 0], [1, 0, 0], [0, 1, 0], [1, 1, 0], [0, 0, 1], [1, 0, 1], [0, 1, 1], [1, 1, 1], ], dtype=np.float32)) self._tex = tex_cls((10, 10, 10), interpolation='linear', wrapping='clamp_to_edge') # Create program Visual.__init__(self, vcode=VERT_SHADER, fcode="") self.shared_program['u_volumetex'] = self._tex self.shared_program['a_position'] = self._vertices self.shared_program['a_texcoord'] = self._texcoord self._draw_mode = 'triangle_strip' self._index_buffer = IndexBuffer() # Only show back faces of cuboid. This is required because if we are # inside the volume, then the front faces are outside of the clipping # box and will not be drawn. self.set_gl_state('translucent', cull_face=False) # Set data self.set_data(vol, clim) # Set params self.method = method self.relative_step_size = relative_step_size self.threshold = threshold if (threshold is not None) else vol.mean() self.freeze()
def __init__(self): app.Canvas.__init__(self, size=(512, 512), title='Lighted cube', keys='interactive') self.timer = app.Timer('auto', self.on_timer) # Build cube data V, F, outline = create_cube() vertices = VertexBuffer(V) self.faces = IndexBuffer(F) self.outline = IndexBuffer(outline) # Build view, model, projection & normal # -------------------------------------- self.view = translate((0, 0, -5)) model = np.eye(4, dtype=np.float32) normal = np.array(np.matrix(np.dot(self.view, model)).I.T) # Build program # -------------------------------------- self.program = Program(vertex, fragment) self.program.bind(vertices) self.program["u_light_position"] = 2, 2, 2 self.program["u_light_intensity"] = 1, 1, 1 self.program["u_model"] = model self.program["u_view"] = self.view self.program["u_normal"] = normal self.phi, self.theta = 0, 0 self.activate_zoom() # OpenGL initialization # -------------------------------------- gloo.set_state(clear_color=(0.30, 0.30, 0.35, 1.00), depth_test=True, polygon_offset=(1, 1), blend_func=('src_alpha', 'one_minus_src_alpha'), line_width=0.75) self.timer.start() self.show()
def __init__(self, sensor=None, i=0, yaw=False, title='Rotating Cube'): app.Canvas.__init__(self, size=(640, 640), title=title, keys='interactive') self.timer = app.Timer('auto', self.on_timer) self.sensor = sensor self.i = i self.yaw = yaw # Build cube data V, I, O = create_cube() vertices = VertexBuffer(V) self.faces = IndexBuffer(I) self.outline = IndexBuffer(O) # Build program # -------------------------------------- self.program = Program(vertex, fragment) self.program.bind(vertices) # Build view, model, projection & normal # -------------------------------------- view = translate((0, 0, -5)) model = np.eye(4, dtype=np.float32) self.program['u_model'] = model self.program['u_view'] = view self.theta, self.psi, self.phi = 0, 0, 0 self.activate_zoom() # OpenGL initialization # -------------------------------------- gloo.set_state(clear_color=(0.30, 0.30, 0.35, 1.00), depth_test=True, polygon_offset=(1, 1), line_width=0.75, blend_func=('src_alpha', 'one_minus_src_alpha')) self.timer.start() self.show()
def __init__(self, data, relative_step_size=0.8, emulate_texture=False): # Choose texture class tex_cls = TextureEmulated3D if emulate_texture else Texture3D # Storage of information of volume self._need_vertex_update = True # Create OpenGL program Visual.__init__(self, vcode=VERT_SHADER, fcode=FRAG_SHADER) # Create gloo objects self._vertices = VertexBuffer() self._texcoord = VertexBuffer( np.array([ [0, 0, 0], [1, 0, 0], [0, 1, 0], [1, 1, 0], [0, 0, 1], [1, 0, 1], [0, 1, 1], [1, 1, 1], ], dtype=np.float32)) # Set up RGBA texture self.texture = tex_cls((10, 10, 10, 4), interpolation='linear', wrapping='clamp_to_edge') self.texture.set_data(data.astype(np.float32)) self.shared_program['u_volumetex'] = self.texture self._vol_shape = data.shape[:-1] self.shared_program['u_shape'] = self._vol_shape[::-1] self.shared_program['a_position'] = self._vertices self.shared_program['a_texcoord'] = self._texcoord self._draw_mode = 'triangle_strip' self._index_buffer = IndexBuffer() self.shared_program.frag['sampler_type'] = self.texture.glsl_sampler_type self.shared_program.frag['sample'] = self.texture.glsl_sample # Only show back faces of cuboid. This is required because if we are # inside the volume, then the front faces are outside of the clipping # box and will not be drawn. self.set_gl_state('translucent', cull_face=False) self.relative_step_size = relative_step_size self.freeze()
def __init__(self): vertices, indices, _ = create_cube() vertices = VertexBuffer(vertices) self.indices = IndexBuffer(indices) self.program = Program(self.cube_vertex, self.cube_fragment) self.model = np.eye(4) self.view = np.eye(4) self.program.bind(vertices) self.program['texture'] = utils.checkerboard() self.program['texture'].interpolation = 'linear' self.program['model'] = self.model self.program['view'] = self.view
def initialize_renderer(self): self.fbuffer = FrameBuffer() vertices = np.array( [[-1.0, -1.0], [+1.0, -1.0], [-1.0, +1.0], [+1.0, +1.0]], np.float32) texcoords = np.array([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]], dtype=np.float32) self.fbuf_vertices = VertexBuffer(data=vertices) self.fbuf_texcoords = VertexBuffer(data=texcoords) self.fbuffer_prog['texcoord'] = self.fbuf_texcoords self.fbuffer_prog['position'] = self.fbuf_vertices self.vertex_buffer = VertexBuffer() self.index_buffer = IndexBuffer()
def on_initialize(self, event): # Build cube data V, I, _ = create_cube() vertices = VertexBuffer(V) self.indices = IndexBuffer(I) # Build program self.program = Program(vertex, fragment) self.program.bind(vertices) # Build view, model, projection & normal view = np.eye(4, dtype=np.float32) model = np.eye(4, dtype=np.float32) translate(view, 0, 0, -5) self.program['model'] = model self.program['view'] = view self.phi, self.theta = 0, 0 gloo.set_state(clear_color=(0.30, 0.30, 0.35, 1.00), depth_test=True) self.timer.start()
def __init__(self): app.Canvas.__init__(self, title='Framebuffer post-processing', keys='interactive', size=(512, 512)) # Build cube data # -------------------------------------- vertices, indices, _ = create_cube() vertices = VertexBuffer(vertices) self.indices = IndexBuffer(indices) # Build program # -------------------------------------- view = np.eye(4, dtype=np.float32) model = np.eye(4, dtype=np.float32) translate(view, 0, 0, -7) self.phi, self.theta = 60, 20 rotate(model, self.theta, 0, 0, 1) rotate(model, self.phi, 0, 1, 0) self.cube = Program(cube_vertex, cube_fragment) self.cube.bind(vertices) self.cube["texture"] = checkerboard() self.cube["texture"].interpolation = 'linear' self.cube['model'] = model self.cube['view'] = view color = Texture2D((512, 512, 3), interpolation='linear') self.framebuffer = FrameBuffer(color, RenderBuffer((512, 512))) self.quad = Program(quad_vertex, quad_fragment, count=4) self.quad['texcoord'] = [(0, 0), (0, 1), (1, 0), (1, 1)] self.quad['position'] = [(-1, -1), (-1, +1), (+1, -1), (+1, +1)] self.quad['texture'] = color # OpenGL and Timer initalization # -------------------------------------- set_state(clear_color=(.3, .3, .35, 1), depth_test=True) self.timer = app.Timer('auto', connect=self.on_timer, start=True) self._set_projection(self.size)
def initialize_renderer(self): self.fbuffer = FrameBuffer() vertices = np.array( [[-1.0, -1.0], [+1.0, -1.0], [-1.0, +1.0], [+1.0, +1.0]], np.float32) texcoords = np.array([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]], dtype=np.float32) self.fbuf_vertices = VertexBuffer(data=vertices) self.fbuf_texcoords = VertexBuffer(data=texcoords) self.fbuffer_prog = Program(src_fbuffer.vert, src_fbuffer.frag) self.fbuffer_prog['texcoord'] = self.fbuf_texcoords self.fbuffer_prog['position'] = self.fbuf_vertices self.vertex_buffer = VertexBuffer() self.index_buffer = IndexBuffer() self.default_prog = Program(src_default.vert, src_default.frag) self.reset_view()
def buildProgram(self): ''' In dieser Methode wird das Programm samt Indices einer Kugel errechnet. Das Ganze wird mithilfe der Bibliothek vispy.gloo gemacht. Parameter: - Rueckgabewerte: - ''' vertices = np.zeros(self._mesh.getVertices().shape[0], [("position", np.float32, 3)]) vertices["position"] = self._mesh.getVertices() vertices = VertexBuffer(vertices) indices = self._mesh.getIndices() self._indices = IndexBuffer(indices) self._program = Program(vertex, fragment) self._program.bind(vertices) self._program['color'] = self._color self._program['model'] = None self._program['view'] = None self._program['drawHorizon'] = -3
def initialize_renderer(): """Initialize the OpenGL renderer. For an OpenGL based renderer this sets up the viewport and creates the shader programs. """ global fbuffer global fbuffer_prog global default_prog global texture_prog global vertex_buffer global index_buffer fbuffer = FrameBuffer() vertices = np.array( [[-1.0, -1.0], [+1.0, -1.0], [-1.0, +1.0], [+1.0, +1.0]], np.float32) texcoords = np.array([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]], dtype=np.float32) fbuf_vertices = VertexBuffer(data=vertices) fbuf_texcoords = VertexBuffer(data=texcoords) fbuffer_prog = Program(src_fbuffer.vert, src_fbuffer.frag) fbuffer_prog['texcoord'] = fbuf_texcoords fbuffer_prog['position'] = fbuf_vertices vertex_buffer = VertexBuffer() index_buffer = IndexBuffer() default_prog = Program(src_default.vert, src_default.frag) texture_prog = Program(src_texture.vert, src_texture.frag) texture_prog['texcoord'] = fbuf_texcoords reset_view()
def __init__(self, n_volume_max=16, emulate_texture=False, bgcolor='white', resolution=256): # Choose texture class tex_cls = TextureEmulated3D if emulate_texture else Texture3D self._n_volume_max = n_volume_max self._vol_shape = (resolution, resolution, resolution) self._need_vertex_update = True self._data_bounds = None self.resolution = resolution # We deliberately don't use super here because we don't want to call # VolumeVisual.__init__ Visual.__init__(self, vcode=VERT_SHADER, fcode="") self.volumes = defaultdict(dict) # We turn on clipping straight away - the following variable is needed # by _update_shader self._clip_data = True # Set up initial shader so that we can start setting shader variables # that don't depend on what volumes are actually active. self._update_shader() # Set initial clipping parameters self.shared_program['u_clip_min'] = [0, 0, 0] self.shared_program['u_clip_max'] = [1, 1, 1] # Set up texture vertices - note that these variables are required by # the parent VolumeVisual class. self._vertices = VertexBuffer() self._texcoord = VertexBuffer( np.array([[0, 0, 0], [1, 0, 0], [0, 1, 0], [1, 1, 0], [0, 0, 1], [1, 0, 1], [0, 1, 1], [1, 1, 1]], dtype=np.float32)) self._draw_mode = 'triangle_strip' self._index_buffer = IndexBuffer() self.shared_program['a_position'] = self._vertices self.shared_program['a_texcoord'] = self._texcoord # Only show back faces of cuboid. This is required because if we are # inside the volume, then the front faces are outside of the clipping # box and will not be drawn. self.set_gl_state('translucent', cull_face=False) # Set up the underlying volume shape and define textures self._vol_shape = (resolution, resolution, resolution) self.shared_program['u_shape'] = self._vol_shape self.textures = [] for i in range(n_volume_max): # Set up texture object self.textures.append(tex_cls(self._vol_shape, interpolation='linear', wrapping='clamp_to_edge')) # Pass texture object to shader program self.shared_program['u_volumetex_{0}'.format(i)] = self.textures[i] # Make sure all textures are disabled self.shared_program['u_enabled_{0}'.format(i)] = 0 self.shared_program['u_weight_{0}'.format(i)] = 1 # Don't use downsampling initially (1 means show 1:1 resolution) self.shared_program['u_downsample'] = 1. # Set up texture sampler self.shared_program.frag['sampler_type'] = self.textures[0].glsl_sampler_type self.shared_program.frag['sample'] = self.textures[0].glsl_sample # Set initial background color self.shared_program['u_bgcolor'] = Color(bgcolor).rgba # Prevent additional attributes from being added try: self.freeze() except AttributeError: # Older versions of VisPy pass
def _prepare_draw(self, view): # attributes / uniforms are not available until program is built if len(self.text) == 0: return False if self._vertices is None: text = self.text if isinstance(text, str): text = [text] n_char = sum(len(t) for t in text) # we delay creating vertices because it requires a context, # which may or may not exist when the object is initialized self._vertices = np.concatenate([ _text_to_vbo(t, self._font, self._anchors[0], self._anchors[1], self._font._lowres_size) for t in text ]) self._vertices = VertexBuffer(self._vertices) idx = (np.array([0, 1, 2, 0, 2, 3], np.uint32) + np.arange(0, 4 * n_char, 4, dtype=np.uint32)[:, np.newaxis]) self._index_buffer = IndexBuffer(idx.ravel()) self.shared_program.bind(self._vertices) # This is necessary to reset the GL drawing state after generating # SDF textures. A better way would be to enable the state to be # pushed/popped by the context. self._configure_gl_state() if self._pos_changed: # now we promote pos to the proper shape (attribute) text = self.text if not isinstance(text, str): repeats = [4 * len(t) for t in text] text = ''.join(text) else: repeats = [4 * len(text)] n_text = len(repeats) pos = self.pos # Rotation _rot = self._rotation if isinstance(_rot, (int, float)): _rot = np.full((pos.shape[0], ), self._rotation) _rot = np.asarray(_rot) if _rot.shape[0] < n_text: _rep = [1] * (len(_rot) - 1) + [n_text - len(_rot) + 1] _rot = np.repeat(_rot, _rep, axis=0) _rot = np.repeat(_rot[:n_text], repeats, axis=0) self.shared_program['a_rotation'] = _rot.astype(np.float32) # Position if pos.shape[0] < n_text: _rep = [1] * (len(pos) - 1) + [n_text - len(pos) + 1] pos = np.repeat(pos, _rep, axis=0) pos = np.repeat(pos[:n_text], repeats, axis=0) assert pos.shape[0] == self._vertices.size == len(_rot) self.shared_program['a_pos'] = pos self._pos_changed = False if self._color_changed: # now we promote color to the proper shape (varying) text = self.text if not isinstance(text, str): repeats = [4 * len(t) for t in text] text = ''.join(text) else: repeats = [4 * len(text)] n_text = len(repeats) color = self.color.rgba if color.shape[0] < n_text: color = np.repeat(color, [1] * (len(color) - 1) + [n_text - len(color) + 1], axis=0) color = np.repeat(color[:n_text], repeats, axis=0) assert color.shape[0] == self._vertices.size self._color_vbo = VertexBuffer(color) self.shared_program.vert['color'] = self._color_vbo self._color_changed = False transforms = self.transforms n_pix = (self._font_size / 72.) * transforms.dpi # logical pix tr = transforms.get_transform('document', 'render') px_scale = (tr.map((1, 0)) - tr.map((0, 1)))[:2] self._text_scale.scale = px_scale * n_pix self.shared_program.vert['text_scale'] = self._text_scale self.shared_program['u_npix'] = n_pix self.shared_program['u_kernel'] = self._font._kernel self.shared_program['u_color'] = self._color.rgba self.shared_program['u_font_atlas'] = self._font._atlas self.shared_program['u_font_atlas_shape'] = self._font._atlas.shape[:2]
def __init__(self, text, canvas, position=1, color=(0.1, 0.0, 0.7)): ''' Give this the - text to be written - main app.canvas - position (1-9, or which button position this should occupy) ''' # State Controller State.register_button(position, text) self.position = position self.canvas = canvas self.projection = np.eye(4) self.view = np.eye(4) self.model = np.eye(4) height, width = 5.0, 15.0 # Meters orientation_vector = (1, 1, 0) unit_orientation_angle = np.array(orientation_vector) / np.linalg.norm( orientation_vector) scale_factor = 0.2 lowest_button = -5.2 midset = 0.2 scale(self.model, scale_factor) yrotate(self.model, -60) # rotate(self.model, 30, *unit_orientation_angle) offset = (position * ((height + midset) * scale_factor)) translate(self.model, -7.4, lowest_button + offset, -10) pixel_to_length = 10 self.size = map(lambda o: pixel_to_length * o, [width, height]) # Add texture coordinates # Rectangle of height height self.vertices = np.array([ [-width / 2, -height / 2, 0], [width / 2, -height / 2, 0], [width / 2, height / 2, 0], [-width / 2, height / 2, 0], ], dtype=np.float32) self.tex_coords = np.array([ [0, 0], [1, 0], [1, 1], [0, 1], ], dtype=np.float32) self.indices = IndexBuffer([ 0, 1, 2, 2, 3, 0, ]) self.program = Program(self.button_vertex_shader, self.button_fragment_shader) self.program['vertex_position'] = self.vertices self.program['default_texcoord'] = self.tex_coords self.program['view'] = self.view self.program['model'] = self.model self.program['projection'] = self.projection self.program['background_color'] = color self.program['highlighted'] = 0 # self.texture = Texture2D(shape=(1000, 1000) + (3,)) # self.text_buffer = FrameBuffer(self.texture, RenderBuffer((1000, 1000))) self.texture = Texture2D(shape=(500, 1500) + (3, )) self.text_buffer = FrameBuffer(self.texture, RenderBuffer((500, 1500))) self.program['texture'] = self.texture self.text = text self.make_text(self.text) self.first = True
glut.glutTimerFunc(1000 / 60, timer, 60) # Build cube data # -------------------------------------- V = np.zeros(8, [("position", np.float32, 3), ("color", np.float32, 4)]) V["position"] = [[1, 1, 1], [-1, 1, 1], [-1, -1, 1], [1, -1, 1], [1, -1, -1], [1, 1, -1], [-1, 1, -1], [-1, -1, -1]] V["color"] = [[0, 1, 1, 1], [0, 0, 1, 1], [0, 0, 0, 1], [0, 1, 0, 1], [1, 1, 0, 1], [1, 1, 1, 1], [1, 0, 1, 1], [1, 0, 0, 1]] vertices = VertexBuffer(data=V) I = [ 0, 1, 2, 0, 2, 3, 0, 3, 4, 0, 4, 5, 0, 5, 6, 0, 6, 1, 1, 6, 7, 1, 7, 2, 7, 4, 3, 7, 3, 2, 4, 7, 6, 4, 6, 5 ] indices = IndexBuffer(I) # Build program # -------------------------------------- program = Program(vertex, fragment) program.bind(vertices) # Build view, model, projection & normal # -------------------------------------- view = np.eye(4, dtype=np.float32) model = np.eye(4, dtype=np.float32) projection = np.eye(4, dtype=np.float32) translate(view, 0, 0, -5) program['model'] = model program['view'] = view phi, theta = 0, 0
def __init__(self): '''Map drawable - contains the goddamn map ''' self.projection = np.eye(4) self.view = np.eye(4) self.model = scale(np.eye(4), 0.6) orientation_vector = (0, 1, 0) unit_orientation_angle = np.array(orientation_vector) / np.linalg.norm( orientation_vector) rotate(self.model, -30, *unit_orientation_angle) translate(self.model, -2.2, -2.4, -9) height, width = 5.0, 5.0 # Meters # Add texture coordinates # Rectangle of height height self.vertices = np.array([ [-width / 2, -height / 2, 0], [width / 2, -height / 2, 0], [width / 2, height / 2, 0], [-width / 2, height / 2, 0], ], dtype=np.float32) self.tex_coords = np.array([ [0, 1], [1, 1], [1, 0], [0, 0], ], dtype=np.float32) self.indices = IndexBuffer([ 0, 1, 2, 2, 3, 0, ]) ###### TESTING self.position_lla = self.ecef2llh((738575.65, -5498374.10, 3136355.42)) ###### TESTING self.map, self.ranges = self.cache_map(self.position_lla[:2]) self.map, self.ranges = self.get_map(self.position_lla[:2]) self.program = Program(self.frame_vertex_shader, self.frame_frag_shader) default_map_transform = np.eye(4) self.program['vertex_position'] = self.vertices self.program['default_texcoord'] = self.tex_coords self.program['zoom'] = 1 self.program['view'] = self.view self.program['model'] = self.model self.program['projection'] = self.projection self.program['map_transform'] = default_map_transform self.program['map_center'] = self.position_lla[:2] self.program['map_texture'] = self.map self.program['corners'] = self.ranges self.program['user_position'] = self.position_lla[:2] self.program['hide'] = 0
def __init__(self, canvas, background_color=(0,0,0,0), text_color=(1,1,1)): # State.register_button(position, text) self.canvas = canvas self.text = None self.tcolor = (text_color[0],text_color[1],text_color[2], 1) self.bcolor = background_color self.timer = 0 self.fade_timer = 0 self.projection = np.eye(4) self.view = np.eye(4) self.model = np.eye(4) height, width = 5.0, 15.0 # Meters orientation_vector = (1, 1, 0) unit_orientation_angle = np.array(orientation_vector) / np.linalg.norm(orientation_vector) scale_factor = 0.4 lowest_button = -5.2 midset = 0.2 position = -2 scale(self.model, scale_factor) #yrotate(self.model, -90) # rotate(self.model, 30, *unit_orientation_angle) offset = (position * ((height + midset) * scale_factor)) translate(self.model, -4.4, lowest_button + offset, -10) self.size = (int(height*100), int(width*100)) # Add texture coordinates # Rectangle of height height self.vertices = np.array([ [-width / 2, -height / 2, 0], [ width / 2, -height / 2, 0], [ width / 2, height / 2, 0], [-width / 2, height / 2, 0], ], dtype=np.float32) self.tex_coords = np.array([ [0, 0], [1, 0], [1, 1], [0, 1], ], dtype=np.float32) self.indices = IndexBuffer([ 0, 1, 2, 2, 3, 0, ]) self.program = Program(self.toast_vertex_shader, self.toast_fragment_shader) self.program['vertex_position'] = self.vertices self.program['default_texcoord'] = self.tex_coords self.program['view'] = self.view self.program['model'] = self.model self.program['projection'] = self.projection self.program['background_color'] = (0,0,0,0) # no background yet self.program['text_color'] = (0,0,0,0) # no text yet # self.texture = Texture2D(shape=(1000, 1000) + (3,)) # self.text_buffer = FrameBuffer(self.texture, RenderBuffer((1000, 1000))) self.texture = Texture2D(shape=self.size + (3,)) self.text_buffer = FrameBuffer(self.texture, RenderBuffer(self.size)) self.program['texture'] = self.texture #self.program['text_color'] = self.tcolor # set the tcolor #self.program['background_color'] = self.bcolor # set the tcolor self.first = False # do not draw text until needed self.make_text('Default Text') # Create Empty text object
# Glut init # -------------------------------------- glut.glutInit(sys.argv) glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGBA | glut.GLUT_DEPTH) glut.glutCreateWindow('Lighted Cube') glut.glutReshapeWindow(512, 512) glut.glutReshapeFunc(reshape) glut.glutKeyboardFunc(keyboard) glut.glutDisplayFunc(display) glut.glutTimerFunc(1000 / 60, timer, 60) # Build cube data # -------------------------------------- V, F, O = cube() vertices = VertexBuffer(V) faces = IndexBuffer(F) outline = IndexBuffer(O) # Build view, model, projection & normal # -------------------------------------- view = np.eye(4, dtype=np.float32) model = np.eye(4, dtype=np.float32) projection = np.eye(4, dtype=np.float32) translate(view, 0, 0, -5) normal = np.array(np.matrix(np.dot(view, model)).I.T) # Build program # -------------------------------------- program = Program(vertex, fragment) program.bind(vertices) program["u_light_position"] = 2, 2, 2
def __init__(self): self.projection = np.eye(4) self.view = np.eye(4) self.model = np.eye(4) height, width = 3.0, 6.0 scale_factor = 0.2 x_offset = -8 y_offset = 2 pixel_to_length = 10 color = (1.0, 1.0, 1.0) scale(self.model, scale_factor) yrotate(self.model, -60) translate(self.model, x_offset, y_offset, -10) size = (int(height * 100), int(width * 100)) self.vertices = np.array([ [-width / 2, -height / 2, 0], [width / 2, -height / 2, 0], [width / 2, height / 2, 0], [-width / 2, height / 2, 0], ], dtype=np.float32) self.tex_coords = np.array([ [0, 0], [1, 0], [1, 1], [0, 1], ], dtype=np.float32) self.indices = IndexBuffer([ 0, 1, 2, 2, 3, 0, ]) self.program = Program(self.battery_vertex_shader, self.battery_fragment_shader) self.texture = Texture2D(shape=size + (3, )) self.text_buffer = FrameBuffer(self.texture, RenderBuffer(size)) images = [] images.append( Image.open( os.path.join(Paths.get_path_to_visar(), 'visar', 'images', 'battery', 'battery_low_color.png'))) images.append( Image.open( os.path.join(Paths.get_path_to_visar(), 'visar', 'images', 'battery', 'battery_used_color.png'))) images.append( Image.open( os.path.join(Paths.get_path_to_visar(), 'visar', 'images', 'battery', 'battery_full_color.png'))) self.level_texture = {} # texture for each level for x in range(0, len(images)): default_image = images[x] default_image = default_image.rotate(-90) default_image = default_image.resize(size) default_image = default_image.transpose(Image.FLIP_TOP_BOTTOM) default_image_array = np.asarray(default_image) self.level_texture[x + 1] = default_image_array #default_image_array = imageio.imread(os.path.join(Paths.get_path_to_visar(), 'visar', 'images', 'battery', 'battery_full_color.png')) # self.default_tex = Texture2D(data=default_image_array) # self.default_tex = Texture2D(shape=size + (3,)) # self.default_tex.set_data(self.level_texture[3]) self.program['vertex_position'] = self.vertices self.program['default_texcoord'] = self.tex_coords self.program['view'] = self.view self.program['model'] = self.model self.program['projection'] = self.projection self.program['hide'] = 0 # self.tex_program = Program(self.tex_vert_shader, self.battery_fragment_shader) # self.tex_program['vertex_position'] = self.vertices # self.tex_program['default_texcoord'] = self.tex_coords # self.tex_program['hide'] = 0 # self.tex_program['texture'] = self.default_tex self.flag = True # flag to update the texture self.level = 3 # level of the battery 1 - 3 full_middle_split = 75 # split between levels 2 and 3 middle_low_split = 25 # split between levels 1 and 2 fault_tolerance = 5 self.full_lower = full_middle_split - fault_tolerance # lower limit for going from 3 to 2 self.middle_upper = full_middle_split + fault_tolerance # upper limit for going from 2 to 3 self.middle_lower = middle_low_split - fault_tolerance # lower limit for going from 2 to 1 self.low_upper = middle_low_split + fault_tolerance # upper limit for going from 1 to 2
def draw(): global program, interface index = IndexBuffer(interface.indices()) program.draw('triangles', index)