# program['minor_step'] = 0.25, np.pi/60 # # This scales projected coordinates into texture coordinates # program['scale2'] = Position( # LinearScale(name = 'x', domain=(0.0, 5.0), range=(0,1), discard=False, clamp=False), # LinearScale(name = 'y', domain=(0.0, 2*np.pi), range=(0,1), discard=False, clamp=False)) # Transverse Mercator projection # ------------------------------ # This scales texture coordinates into cartesian coordinates program['scale1'] = Position( LinearScale(name='x', domain=(0, 1), range=(-1.5, 1.5), discard=False, clamp=False), LinearScale(name='y', domain=(1, 0), range=(-2.3, 2.3), discard=False, clamp=False)) # Actual projection program['projection'] = TransverseMercatorProjection() program['major_step'] = np.array([1.00, 0.50]) * np.pi / 6.0 program['minor_step'] = np.array([1.00, 0.50]) * np.pi / 30.0 # This scales projected coordinates into texture coordinates program['scale2'] = Position( LinearScale(name='x',
def __init__(self, user_dtype=None, transform=None, viewport=None, vertex=None, fragment=None, **kwargs): """ Initialize the collection. Parameters ---------- user_dtype: list The base dtype can be completed (appended) by the used_dtype. It only make sense if user also provide vertex and/or fragment shaders viewport: glumpy.Transforms The viewport to use to rende the collection transform: glumpy.Tranforms The default vertex shader apply the supplied transform to the vertices positions before computing the actual vertices positions for path thickness. Note that it is necessary to add the glumpy.transforms.Viewport transform at the end of the supplied transform. vertex: string Vertex shader code fragment: string Fragment shader code caps : string 'local', 'shared' or 'global' color : string 'local', 'shared' or 'global' linewidth : string 'local', 'shared' or 'global' antialias : string 'local', 'shared' or 'global' """ base_dtype = [('prev', (np.float32, 3), '!local', (0, 0, 0)), ('curr', (np.float32, 3), '!local', (0, 0, 0)), ('next', (np.float32, 3), '!local', (0, 0, 0)), ('id', (np.float32, 1), '!local', 0), ('color', (np.float32, 4), 'global', (0, 0, 0, 1)), ('linewidth', (np.float32, 1), 'global', 1), ('antialias', (np.float32, 1), 'global', 1)] dtype = base_dtype if user_dtype: dtype.extend(user_dtype) if vertex is None: vertex = library.get('collections/agg-fast-path.vert') if fragment is None: fragment = library.get('collections/agg-fast-path.frag') Collection.__init__(self, dtype=dtype, itype=None, mode=gl.GL_TRIANGLE_STRIP, vertex=vertex, fragment=fragment, **kwargs) # Set hooks if necessary program = self._programs[0] if "transform" in program.hooks: if transform is not None: program["transform"] = transform else: program["transform"] = Position() + Viewport() if "viewport" in program.hooks: if viewport is not None: program["viewport"] = viewport else: program["viewport"] = Viewport()
def __init__(self, render_objects, **kwargs): self.window = app.Window(**kwargs) self.render_objects = render_objects self.animating = True self.programs = [] for obj in self.render_objects: self.programs.append( gloo.Program(obj.vertex_shader, obj.fragment_shader)) self.programs[-1].bind(obj.vertices) self.set_light_position([0, 0, 2]) self.set_light_intensity([1, 1, 1]) self.view = glm.translation(0, 0, 1) # camera position self.model = np.eye(4, dtype=np.float32) for obj, prog in zip(self.render_objects, self.programs): prog['u_model'] = np.eye(4, dtype=np.float32) prog['u_min_color'] = np.min(obj.vertex_buffer['color']) prog['u_max_color'] = np.max(obj.vertex_buffer['color']) prog['u_view'] = self.view prog['u_colors'] = [[0, 0, 1], [1, 1, 1], [1, 0, 0]] prog['transform'] = Trackball(Position("position"), theta=0, phi=0) self.window.attach(prog['transform']) # glyphs = GlyphCollection(transform=Trackball(Position())) # glyphs.append(jab, FontManager.get("Roboto-Regular.ttf")) #self.window.attach(glyphs["transform"]) #self.window.attach(glyphs["viewport"]) @self.window.event 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() @self.window.timer(1 / 5.0) def timer(dt): self.window.set_title("FPS: {:3.1f}".format( self.window.fps).encode()) @self.window.event def on_init(): gl.glEnable(gl.GL_DEPTH_TEST) gl.glDisable(gl.GL_BLEND) @self.window.event def on_key_press(symbol, modifiers): LOG.debug('Key pressed (symbol=%s, modifiers=%s)', symbol, modifiers) @self.window.event def on_character(character): if character == 'q': self.window.close() app.quit() sys.exit(0) if character == 'r': # random colormap for prog in self.programs: prog['u_colors'] = np.random.rand(3, 3) if character == 'p': available = list( self.render_objects[0].available_properties.keys()) self.change_surface_property(random.choice(available)) LOG.debug('Character entered (character: %s)' % character) LOG.debug('Character == q {}'.format(character == 'q')) @self.window.event def on_key_release(symbol, modifiers): LOG.debug('Key released (symbol=%s, modifiers=%s)', symbol, modifiers)
filename = sys.argv[1] ndata1 = addData(sys.argv[1], points1, color=(0.2, 0.2, 0.2, -1.0)) tuniq1 = np.unique(ndata1['t']) ndata2 = addData(sys.argv[2], points2, color=(0.2, 0.8, 0.2, 0.7)) tuniq2 = np.unique(ndata2['t']) maxtime = len(tuniq1) # prepare coordinate P0 = np.array([[0, 0, 0], [0, 0, 0], [0, 0, 0]]) P1 = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]]) CP = [(0.9, 0.1, 0.1, 1), (0.1, 0.9, 0.1, 1), (0.1, 0.1, 0.9, 1)] coord.append(P0, P1, color=CP, linewidth=[1, 1, 1]) coord['antialias'] = 1 transform = Trackball(Position()) points1["transform"] = transform points2["transform"] = transform coord['transform'] = transform window.attach(points1["transform"]) window.attach(points1["viewport"]) window.attach(points2["transform"]) window.attach(points2["viewport"]) window.attach(coord["transform"]) window.attach(coord["viewport"]) @window.event def on_draw(dt): global time, maxtime, toggleStop window.clear()
} """ fragment = """ const vec4 blue = vec4(0.80,0.80,1.00,1.00); const vec4 white = vec4(1.00,1.00,1.00,1.00); uniform sampler2D texture; varying vec2 v_texcoord; void main() { float v = texture2D(texture, v_texcoord).r; gl_FragColor = mix(white,blue,v); } """ transform = Arcball(Position(), znear=1, zfar=10) viewport = Viewport() radius = 1.5 vertices, indices = sphere(radius, 64, 64) earth = gloo.Program(vertex, fragment) earth.bind(vertices) earth['texture'] = data.get("earth-black.jpg") earth['texture'].interpolation = gl.GL_LINEAR earth['transform'] = transform paths = PathCollection(mode="agg+", color="global", linewidth="global", viewport=viewport, transform=transform)
# ----------------------------------------------------------------------------- # Copyright (c) 2009-2016 Nicolas P. Rougier. All rights reserved. # Distributed under the (new) BSD License. # ----------------------------------------------------------------------------- import re import numpy as np from glumpy import app, gl, data, svg, collections from glumpy.transforms import Position, OrthographicProjection, PanZoom, Viewport window = app.Window(800, 800, color=(1, 1, 1, 1)) transform = PanZoom(OrthographicProjection(Position())) @window.event def on_draw(dt): window.clear() paths["antialias"] = -0.5 collections.Collection.draw(paths) paths["antialias"] = +1.0 collections.Collection.draw(paths) @window.event def on_init(): gl.glEnable(gl.GL_DEPTH_TEST) paths = collections.PathCollection("agg", transform=transform) # paths["miter_limit"] = 4.0 paths["linewidth"] = 50.0 paths["color"] = 0.0, 0.0, 0.0, 0.5
pos = <transform.trackball_projection> * pos; gl_FragDepth = 0.5*(pos.z / pos.w)+0.5; vec3 normal = vec3(x,y,z); float diffuse = clamp(dot(normal, v_light_direction), 0.0, 1.0); vec4 color = vec4((0.5 + 0.5*diffuse)*v_color, 1.0); gl_FragColor = outline(distance, 1.0, 1.0, vec4(0,0,0,1), color); // gl_FragColor = color; } """ window = app.Window(width=800, height=800, color=(1, 1, 1, 1)) protein = gloo.Program(vertex, fragment) protein['light_position'] = 0., 0., 2. protein["transform"] = Trackball(Position()) protein.bind(data.get("protein.npy").view(gloo.VertexBuffer)) protein['color'] *= .25 protein['color'] += .75 @window.event def on_draw(dt): window.clear() protein.draw(gl.GL_POINTS) @window.event def on_init(): gl.glEnable(gl.GL_DEPTH_TEST)
"He left it dead, and with its head\n" " He went galumphing back.\n" "\"And, has thou slain the Jabberwock?\n" " Come to my arms, my beamish boy!\n" "O frabjous day! Callooh! Callay!'\n" " He chortled in his joy.\n" "\n" "`Twas brillig, and the slithy toves\n" " Did gyre and gimble in the wabe;\n" "All mimsy were the borogoves,\n" " And the mome raths outgrabe.\n") window = app.Window(width=700, height=700, title="hello", color=(1, 1, 1, 1)) @window.event def on_draw(dt): window.clear() glyphs.draw() glyphs = GlyphCollection(transform=Trackball(Position())) glyphs.append(jabberwocky, FontManager.get("c:/windows/fonts/arial.ttf")) window.attach(glyphs["transform"]) window.attach(glyphs["viewport"]) app.run()
def __init__(self, marker='heart', user_dtype=None, transform=None, viewport=None, vertex=None, fragment=None, **kwargs): """ Initialize the collection. Parameters ---------- user_dtype: list The base dtype can be completed (appended) by the user_dtype. It only make sense if user also provide vertex and/or fragment shaders transform: glumpy.Tranforms The default vertex shader apply the supplied transform to the vertices positions before computing the actual vertices positions for path thickness. Note that it is necessary to add the glumpy.transforms.Viewport transform at the end of the supplied transform. vertex: string Vertex shader code fragment: string Fragment shader code size : string 'local', 'shared' or 'global' orientation : string 'local', 'shared' or 'global' fg_color : string 'local', 'shared' or 'global' bg_color : string 'local', 'shared' or 'global' linewidth : string 'local', 'shared' or 'global' antialias : string 'local', 'shared' or 'global' """ base_dtype = [('position', (np.float32, 3), '!local', (0, 0, 0)), ('size', (np.float32, 1), 'local', 1), ('marker', (np.float32, 1), 'local', 1), ('orientation', (np.float32, 1), 'local', 0.0), ('fg_color', (np.float32, 4), 'local', (0, 0, 0, 1)), ('bg_color', (np.float32, 4), 'local', (1, 1, 1, 1)), ('linewidth', (np.float32, 1), 'global', 1.0), ('antialias', (np.float32, 1), 'global', 1.0)] dtype = base_dtype if user_dtype: dtype.extend(user_dtype) if vertex is None: vertex = library.get('collections/marker.vert') if fragment is None: fragment = library.get('collections/marker.frag') Collection.__init__(self, dtype=dtype, itype=None, mode=gl.GL_POINTS, vertex=vertex, fragment=fragment, **kwargs) # Set hooks if necessary program = self._programs[0] if "transform" in program.hooks: if transform is not None: program["transform"] = transform else: program["transform"] = Position() if "viewport" in program.hooks: if viewport is not None: program["viewport"] = viewport else: program["viewport"] = Viewport() program["marker"] = marker program["paint"] = "outline"
source = parents.pop(0) for i in range(branch): try: target = next(nodes) parents.append(target) A[source, target] = 1 except StopIteration: break # Current selected node selected = -1 # Get edges src, tgt = np.nonzero(A) transform = OrthographicProjection(Position(), aspect=None) viewport = Viewport() markers = collections.MarkerCollection(marker='disc', transform=transform, viewport=viewport) markers.append(N, size=15, linewidth=2, itemsize=1, fg_color=(1, 1, 1, 1), bg_color=(1, .5, .5, 1)) segments = collections.SegmentCollection('agg', transform=transform, viewport=viewport) segments.append(N[src],
float specular_angle = max(dot(half_direction, normal), 0.0); specular = pow(specular_angle, shininess); } vec3 color_linear = ambient_color + lambertian * diffuse_color + specular * specular_color; vec3 color_gamma = pow(color_linear, vec3(1.0/gamma)); gl_FragColor = vec4(color_gamma, 1.0); } """ log.info("Loading brain mesh") vertices, indices = data.get("brain.obj") brain = gloo.Program(vertex, fragment) brain.bind(vertices) trackball = Trackball(Position("position")) brain["transform"] = trackball trackball.theta, trackball.phi, trackball.zoom = 80, -135, 15 window = app.Window(width=1024, height=768) def update(): model = brain["transform"]["model"].reshape(4, 4) view = brain["transform"]["view"].reshape(4, 4) brain["m_view"] = view brain["m_model"] = model brain["m_normal"] = np.array(np.matrix(np.dot(view, model)).I.T) @window.event
// the falloff equation, starts at falloff and is kind of 1/x^2 falling bl += step(falloff,depthDifference)*normDiff*(1.0-smoothstep(falloff,strength,depthDifference)); } // output the result float ao = 1.0 - base*bl/16; gl_FragColor.rgb = color * ao; gl_FragColor.a = 1.0; } """ window = app.Window(width=800, height=800, color=(1,1,1,1)) protein = gloo.Program(vertex, fragment) protein['light_position'] = 0., 0., 2. protein["transform"] = Trackball(Position(), znear=2.0, zfar=100.0) protein.bind(data.get("protein.npy").view(gloo.VertexBuffer)) ssao= gloo.Program(ssao_vertex, ssao_fragment, count=4) ssao['position']= [(0,0), (0,1), (1,0), (1,1)] ssao['base'] = 1.00 ssao['strength']= 0.20; ssao['falloff'] = 0.000002; ssao['radius'] = 0.01; ssao['normals'] = np.zeros((800,800,4),np.float32).view(gloo.Texture2D) ssao['normals'].interpolation = gl.GL_LINEAR ssao['colors'] = np.zeros((800,800,4),np.float32).view(gloo.Texture2D) ssao['colors'].interpolation = gl.GL_LINEAR ssao['noise'] = np.random.uniform(0,1,(256,256,3)) ssao['noise'].interpolation = gl.GL_LINEAR
def plot(self, cmap=None, color_function=None): """ Method used to plot a surface. """ print("Plotting object of dimension: {}".format( self.decomposition.dimension)) data = self.decomposition tuples = data.surface.surface_sampler_data points = extract_points(data) triangle = [] for i in range(len(tuples)): for tri in tuples[i]: x_coordinate = int(tri[0]) y_coordinate = int(tri[1]) z_coordinate = int(tri[2]) point = [x_coordinate, y_coordinate, z_coordinate] triangle.append(point) triangle = np.asarray(triangle) # ----------------------------------------------------------------------------- # # Vertex and fragment are OpenGL code # ----------------------------------------------------------------------------- # vertex = """ attribute vec4 a_color; // Vertex Color uniform mat4 u_model; // Model matrix uniform mat4 u_view; // View matrix uniform mat4 u_projection; // Projection matrix attribute vec3 position; // Vertex position varying vec4 v_color; // Interpolated fragment color (out) void main() { v_color = a_color; gl_Position = <transform>; } """ fragment = """ varying vec4 v_color; // Interpolated fragment color (in) void main() { gl_FragColor = v_color; } """ window = app.Window(width=2048, height=2048, color=(0.30, 0.30, 0.35, 1.00)) verts = np.zeros(len(points), [("position", np.float32, 3), ("a_color", np.float32, 4)]) verts["position"] = points verts["a_color"] = make_colors(verts["position"], cmap, color_function) verts = verts.view(gloo.VertexBuffer) indeces = np.array(triangle).astype(np.uint32) indeces = indeces.view(gloo.IndexBuffer) surface = gloo.Program(vertex, fragment) surface.bind(verts) surface['u_model'] = np.eye(4, dtype=np.float32) surface['u_view'] = glm.translation(0, 0, -5) surface['transform'] = Trackball(Position("position"), znear=0) window.attach(surface['transform']) @window.event def on_draw(draw_triangles): window.clear() surface.draw(gl.GL_TRIANGLES, indeces) # surface.draw(gl.GL_LINES, indeces) @window.event def on_init(): 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) app.run()
gl.glEnable(gl.GL_DEPTH_TEST) gl.glEnable(gl.GL_POLYGON_OFFSET_FILL) color_all_cubes() # 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) # cube2['u_color'] = 0, 0, 0, 1 # cube2.draw(gl.GL_LINES, outline) # gl.glDepthMask(gl.GL_TRUE) zoom = PanZoom(Position("position"), aspect=1, zoom=1) @window.event def on_key_press(key, modifiers): global phi, theta if key == app.window.key.UP: for cube in CUBES: glm.translate(view, 0, -0.01, 0) cube['view'] = view if key == app.window.key.DOWN: for cube in CUBES: glm.translate(view, 0, 0.01, 0) cube['view'] = view if key == app.window.key.LEFT: for cube in CUBES:
data['orientation'] = 0 radius, theta, dtheta = 250.0, 0.0, 5.5 / 180.0 * np.pi for i in range(500): theta += dtheta x = 256 + radius * np.cos(theta) y = 256 + radius * np.sin(theta) r = 10.0 - i * 0.02 radius -= 0.45 data['orientation'][i] = theta - np.pi/2 data['position'][i] = x, y data['size'][i] = 2 * r data['linewidth'][i] = 1 data['position'][-1] = 512+256, 256 data['size'][-1] = 512/np.sqrt(2) data['linewidth'][-1] = 3.0 data['fg_color'][-1] = 0, 0, 0, 1 data['bg_color'][-1] = .95, .95, .95, 1 data['orientation'][-1] = 0 program = gloo.Program("markers/marker.vert", "markers/marker.frag") program.bind(data) program['antialias'] = 1.00 program['marker'] = "square" program['paint'] = "stroke" transform = OrthographicProjection(Position("position")) program['transform'] = transform window.attach(transform) app.run()
# print(dt.min(), dt.max(), dt.mean()) idx = np.where(dt > 0.5) blue = np.linspace(0.7, 0.0, len(t)) green = np.linspace(0.7, 0.0, len(t)) red = np.ones_like(t) * 1.0 alpha = np.ones_like(t) * 0.5 red[idx] = 0.0 green[idx] = 0.0 blue[idx] = 1.0 alpha[idx] = 1.0 radius = np.ones_like(t) radius[0] = 10 points = gloo.Program(vertex, fragment, count=len(x)) points['a_position'] = np.dstack((x, y, z))[0] points['transform'] = Trackball(Position('a_position')) points['a_color'] = np.dstack((red, green, blue, alpha))[0] points['a_radius'] = radius window.attach(points['transform']) pidx = 0 pointsCol = PointCollection('agg', color='local', size='local') window.attach(pointsCol['transform']) # window.attach(pointsCol['viewport']) if os.path.isfile('active_site.pt'): print('... plot with active_site.pt') data = np.genfromtxt('active_site.pt', dtype=[('x', 'f8'), ('y', 'f8'), ('z', 'f8')]) apoint = gloo.Program(vertex, fragment, count=len(data)) apoint['a_position'] = np.dstack((data['x'], data['y'], data['z']))[0]
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) transform['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(Position("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()
# Distributed under the (new) BSD License. # ----------------------------------------------------------------------------- from glumpy import app from glumpy.log import log from glumpy.graphics.text import FontManager from glumpy.graphics.collections import GlyphCollection from glumpy.transforms import Position, OrthographicProjection, Viewport window = app.Window(width=1200, height=800, color=(1, 1, 1, 1)) @window.event def on_draw(dt): window.clear() labels.draw() labels = GlyphCollection('agg', transform=OrthographicProjection(Position())) text = "The quick brown fox jumps over the lazy dog" x, y, z = 2, window.height, 0 log.info("Caching texture fonts") for i in range(6, 54, 2): font = FontManager.get("OpenSans-Regular.ttf", size=i, mode='agg') y -= i * 1.1 labels.append(text, font, origin=(x, y, z), anchor_x="left") window.attach(labels["transform"]) window.attach(labels["viewport"]) app.run()
@window.event def on_draw(dt): window.clear() program.draw(gl.GL_TRIANGLE_STRIP) @window.event def on_key_press(key, modifiers): if key == app.window.key.SPACE: transform.reset() @window.event def on_resize(width, height): program['viewport'] = 0, 0, width, height program = gloo.Program(vertex, fragment, count=4) n = 64 program['position'] = [(-1, -1), (-1, 1), (1, -1), (1, 1)] program['texcoord'] = [(0, 1), (0, 0), (1, 1), (1, 0)] program['data'] = np.random.uniform(0, 1, (n, n)) program['data_shape'] = program['data'].shape[:2] transform = PanZoom(Position("position"), aspect=1) program['transform'] = transform window.attach(transform) app.run()
window.clear() quads.draw(gl.GL_TRIANGLES, indices) @window.event def on_init(): gl.glEnable(gl.GL_DEPTH_TEST) gl.glEnable(gl.GL_BLEND) quads = gloo.Program(vertex, fragment, count=12) quads["position"] = [(-1, -1, -1), (-1, +1, -1), (+1, -1, -1), (+1, +1, -1), (-1, -1, 0), (-1, +1, 0), (+1, -1, 0), (+1, +1, 0), (-1, -1, +1), (-1, +1, +1), (+1, -1, +1), (+1, +1, +1)] quads["position"] *= 10 quads["color"] = C1, C1, C1, C1, C2, C2, C2, C2, C3, C3, C3, C3 indices = np.zeros((3, 6), dtype=np.uint32) indices[0] = 0 + np.array([0, 1, 2, 1, 2, 3]) indices[1] = 4 + np.array([0, 1, 2, 1, 2, 3]) indices[2] = 8 + np.array([0, 1, 2, 1, 2, 3]) indices = indices.view(gloo.IndexBuffer) trackball = Trackball(Position("position"), znear=0.1, zfar=500, distance=50) quads['transform'] = trackball trackball.theta = 40 trackball.phi = 45 trackball.zoom = 40 window.attach(quads['transform']) app.run()
{ gl_Position = <transform>; } """ fragment = """ void main() { gl_FragColor = vec4(1,0,0,1); } """ window = app.Window(width=800, height=800) @window.event def on_draw(dt): window.clear() quad.draw(gl.GL_TRIANGLE_STRIP) @window.event def on_resize(w, h): quad['position'] = [(w - 100, h - 100), (w - 100, h), (w, h - 100), (w, h)] quad = gloo.Program(vertex, fragment, count=4) quad["transform"] = OrthographicProjection(Position("position")) window.attach(quad["transform"]) app.run()
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) # 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) cube["transform"] = Trackball(Position("position")) window.attach(cube["transform"]) # 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) # Run app.run()
} """ window = app.Window(width=1024, height=1024, color=(0.30, 0.30, 0.35, 1.00)) # 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) # create an instance of the TrackballPan object. trackball = TrackballPan(Position("position"), znear=3, zfar=10, distance=5) cube['transform'] = trackball trackball.aspect = 1 # rotation around the X axis trackball.phi = 0 # rotation around the Y axis trackball.theta = 0 trackball.zoom = 50 @window.event def on_draw(dt): window.clear() # Filled cube