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
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
default_prog = Program(src_default.vert, src_default.frag)
reset_view()
def set_data(self, **kwds):
"""
Keyword arguments:
pos (N, 2-3) array
color (3-4) or (N, 3-4) array
width scalar or (N,) array
"""
self._opts.update(kwds)
typ = [('pos', np.float32, self._opts['pos'].shape[-1])]
if isinstance(self._opts['color'], np.ndarray):
typ.append(('color', np.float32, self._opts['color'].shape[-1]))
self._data = np.empty(self._opts['pos'].shape[:-1], typ)
self._data['pos'] = self._opts['pos']
if isinstance(self._opts['color'], np.ndarray):
self._data['color'] = self._opts['color']
self.vbo = VertexBuffer(data=self._data)
#tex = np.zeros((len(self._data), 1, 3), dtype=np.float32)
#tex[...,:2] = self._data['pos'][:,np.newaxis]
# recast float to RGBA bytes
d = self._data['pos'].astype(np.float32).view(np.ubyte).reshape(len(self._data), 2, 4)
self.ptex = Texture2D(d)
self.ptex.set_filter(gl.GL_NEAREST, gl.GL_NEAREST)
self.indexes = VertexBuffer(data=np.arange(len(self._data)*2, dtype=np.float32))
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)
# Time
self._t = time.time()
self._pos = 0.0, 0.0
self._button = None
# Create program
self.program = Program(VERT_SHADER, FRAG_SHADER)
self.program['color'] = VertexBuffer(particles['color'], client=True)
self.program['size'] = VertexBuffer(particles['size'], client=True)
def __init__(self):
app.Canvas.__init__(self)
# Create program
self._program = Program(VERT_SHADER, FRAG_SHADER)
# Set uniforms and samplers
self._program['a_position'] = VertexBuffer(positions)
self._program['a_texcoord'] = VertexBuffer(texcoords)
#
self._program['u_texture1'] = Texture2D(im1)
self._program['u_texture2'] = Texture2D(im2)
self._program['u_texture3'] = Texture2D(im3)
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 updateMesh(self,
vertices=None,
faces=None,
colors=None,
texture=None,
textureCoordinates=None):
# Set
if vertices is not None:
self._meshData.set_vertices(verts=vertices)
if faces is not None:
self._meshData.set_faces(faces)
if colors is not None:
self._meshData.set_vertex_colors(colors)
# Update
if vertices is not None or faces is not None:
self._vertices = VertexBuffer(
self._meshData.get_vertices(indexed='faces').astype(
np.float32))
if faces is not None and vertices is not None:
self._normals = VertexBuffer(
self._meshData.get_vertex_normals(indexed='faces').astype(
np.float32))
if colors is not None:
self._colors = VertexBuffer(
self._meshData.get_vertex_colors(indexed='faces').astype(
np.float32))
if texture is not None:
self._texture = Texture2D(np.array(texture, dtype=np.float32),
interpolation='linear',
wrapping='mirrored_repeat')
if textureCoordinates is not None:
textureMesh = MeshData(vertices=textureCoordinates,
faces=self._meshData.get_faces())
self._textureCoordinates = VertexBuffer(
textureMesh.get_vertices(indexed='faces').astype(np.float32))
# Update GPU - geometry
self.shared_program.vert['position'] = self._vertices
self.shared_program.vert['normal'] = self._normals
# Update GPU - color
if self._texture is None:
self.shared_program.vert['color'] = self._colors
else:
self.shared_program.vert[
'textureCoordinates'] = self._textureCoordinates
self.shared_program['u_objectTexture'] = self._texture
def __init__(self, texture, texcoords, enabled=True):
"""Apply a texture on a mesh."""
vfunc = Function("""
void pass_coords() {
$v_texcoords = $texcoords;
}
""")
ffunc = Function("""
void apply_texture() {
if ($enabled == 1) {
gl_FragColor *= texture2D($u_texture, $texcoords);
}
}
""")
self._texcoord_varying = Varying('v_texcoord', 'vec2')
vfunc['v_texcoords'] = self._texcoord_varying
ffunc['texcoords'] = self._texcoord_varying
self._texcoords_buffer = VertexBuffer(
np.zeros((0, 2), dtype=np.float32)
)
vfunc['texcoords'] = self._texcoords_buffer
super().__init__(vcode=vfunc, vhook='pre', fcode=ffunc)
self.enabled = enabled
self.texture = texture
self.texcoords = texcoords
def __init__(self, vertices=None, faces=None, vertex_colors=None,
face_colors=None, color=(0.5, 0.5, 1, 1), vertex_values=None,
meshdata=None, shading=None, mode='triangles', **kwargs):
Visual.__init__(self, vcode=vertex_template, fcode=fragment_template,
**kwargs)
self.set_gl_state('translucent', depth_test=True, cull_face=False)
self.events.add(data_updated=Event)
# Define buffers
self._vertices = VertexBuffer(np.zeros((0, 3), dtype=np.float32))
self._cmap = get_colormap('cubehelix')
self._clim = 'auto'
# Uniform color
self._color = Color(color)
# add filters for various modifiers
self.shading_filter = None
self.shading = shading
# Init
self._bounds = None
# Note we do not call subclass set_data -- often the signatures
# do no match.
MeshVisual.set_data(
self, vertices=vertices, faces=faces, vertex_colors=vertex_colors,
face_colors=face_colors, vertex_values=vertex_values,
meshdata=meshdata, color=color)
# primitive mode
self._draw_mode = mode
self.freeze()
def setup_features(self):
verts = np.zeros(
0, [('position', np.float32, 3), ('normal', np.float32, 3),
('color', np.float32, 3)]) #start with an empty array
all_feature_groups = self.current_data['features']
if self.render_params['top_dogs_only'] or all_feature_groups == None:
all_feature_groups = self.current_data['top_dog_features']
colors = distinct_colors(2)
base_roof_color = [0.35, 0.35, 0.35]
wallcolor = [0.72, 0.72, 0.72]
yellow = [1, 0.76, 0]
topwallcolor = [0.94, 0.94, 0.99]
origin = [0, 0]
for feature_group, gid in zip(all_feature_groups,
range(len(all_feature_groups))):
feature_group_wall_color = yellow
feature_roof_color = base_roof_color
top_roof_colors = distinct_colors(len(feature_group))
if self.render_params['top_dogs_only'] or self.__bfps[
gid].id in self.__top_dogs:
feature_group_wall_color = topwallcolor
for feature, fid in zip(feature_group, range(len(feature_group))):
get_verts = feature['roof'].get_gl_vertex_data(origin)
data = np.zeros(len(get_verts), [('position', np.float32, 3),
('normal', np.float32, 3),
('color', np.float32, 3)])
data['position'] = get_verts['position']
data['normal'] = get_verts['normal']
data['color'] = feature_roof_color
if self.render_params['top_dogs_only'] or self.__bfps[
gid].id in self.__top_dogs:
data['color'] = top_roof_colors[fid]
if self.render_params['debug_colors']:
data['color'] = top_roof_colors[fid]
verts = np.concatenate([verts, data])
get_verts = feature['walls'].get_gl_vertex_data(origin)
data = np.zeros(len(get_verts), [('position', np.float32, 3),
('normal', np.float32, 3),
('color', np.float32, 3)])
data['position'] = get_verts['position']
data['normal'] = get_verts['normal']
data['color'] = feature_group_wall_color
if self.render_params['debug_colors']:
data['color'] = [i * 1.3 for i in top_roof_colors[fid]]
verts = np.concatenate([verts, data])
self.program_solids.bind(VertexBuffer(verts))
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 __init__(self, *args, **kwargs):
'''Drawable(*args, **kwargs) -> Drawable
Everything is tracked internally, different drawables will handle things differently
Inherit from this for all drawables.
Inheriting:
You must define a make_mesh, make_shaders, and draw method.
If you do not make shaders, you will get a default
If you do not make a mesh, you'll get a square that takes up the screen
'''
self.model = np.eye(4)
self.view = np.eye(4)
self.projection = np.eye(4)
self.mesh = self.make_mesh()
self.vert_shader, self.frag_shader = self.make_shaders()
self.program = Program(self.vert_shader, self.frag_shader)
self.program.bind(VertexBuffer(self.mesh))
if hasattr(self, make_texture):
self.texture = self.make_texture()
assert isinstance(self.texture,
Texture2D), "Texture passed is not a texture!"
self.program['texture'] = self.texture
cube["texture"].interpolation = 'linear'
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, texture, texcoords, enabled=True):
"""Apply a texture on a mesh.
Parameters
----------
texture : (M, N) or (M, N, C) array
The 2D texture image.
texcoords : (N, 2) array
The texture coordinates.
enabled : bool
Whether the display of the texture is enabled.
"""
vfunc = Function("""
void pass_coords() {
$v_texcoords = $texcoords;
}
""")
ffunc = Function("""
void apply_texture() {
if ($enabled == 1) {
gl_FragColor *= texture2D($u_texture, $texcoords);
}
}
""")
self._texcoord_varying = Varying('v_texcoord', 'vec2')
vfunc['v_texcoords'] = self._texcoord_varying
ffunc['texcoords'] = self._texcoord_varying
self._texcoords_buffer = VertexBuffer(
np.zeros((0, 2), dtype=np.float32))
vfunc['texcoords'] = self._texcoords_buffer
super().__init__(vcode=vfunc, vhook='pre', fcode=ffunc)
self.enabled = enabled
self.texture = texture
self.texcoords = texcoords
def on_initialize(self, event):
# Note: read as bytes, then decode; py2.6 compat
with open(op.join(this_dir, 'vertex_vispy.glsl'), 'rb') as fid:
vert = fid.read().decode('ASCII')
with open(op.join(this_dir, 'fragment_seed.glsl'), 'rb') as f:
frag_seed = f.read().decode('ASCII')
with open(op.join(this_dir, 'fragment_flood.glsl'), 'rb') as f:
frag_flood = f.read().decode('ASCII')
with open(op.join(this_dir, 'fragment_display.glsl'), 'rb') as f:
frag_display = f.read().decode('ASCII')
self.programs = [
Program(vert, frag_seed),
Program(vert, frag_flood),
Program(vert, frag_display)
]
# Initialize variables
# using two FBs slightly faster than switching on one
self.fbo_to = [FrameBuffer(), FrameBuffer()]
self._setup_textures('shape1.tga')
vtype = np.dtype([('position', 'f4', 2), ('texcoord', 'f4', 2)])
vertices = np.zeros(4, dtype=vtype)
vertices['position'] = [[-1., -1.], [-1., 1.], [1., -1.], [1., 1.]]
vertices['texcoord'] = [[0., 0.], [0., 1.], [1., 0.], [1., 1.]]
vertices = VertexBuffer(vertices)
for program in self.programs:
program.bind(vertices)
def setup_bfps(self):
verts = np.zeros(
0, [('position', np.float32, 3), ('normal', np.float32, 3),
('color', np.float32, 3)]) #start with an empty array
colors = distinct_colors(2)
for i in range(len(self.__solids)):
if self.render_params['top_dogs_only']:
if self.__bfps[i].id in self.__top_dogs:
get_verts = self.__solids[i].get_gl_vertex_data(
self.__offset)
data = np.zeros(len(get_verts),
[('position', np.float32, 3),
('normal', np.float32, 3),
('color', np.float32, 3)])
data['position'] = get_verts['position']
data['normal'] = get_verts['normal']
data['color'] = colors[1]
verts = np.concatenate([verts, data])
else:
get_verts = self.__solids[i].get_gl_vertex_data(self.__offset)
data = np.zeros(len(get_verts), [('position', np.float32, 3),
('normal', np.float32, 3),
('color', np.float32, 3)])
data['position'] = get_verts['position']
data['normal'] = get_verts['normal']
if self.__bfps[i].id in self.__top_dogs:
data['color'] = colors[1]
else:
data['color'] = colors[0]
verts = np.concatenate([verts, data])
self.program_solids.bind(VertexBuffer(verts))
def render_image(self, image, location, size):
"""Render the image.
:param image: image to be rendered
:type image: builtins.Image
:param location: top-left corner of the image
:type location: tuple | list | builtins.Vector
:param size: target size of the image to draw.
:type size: tuple | list | builtins.Vector
"""
self.flush_geometry()
self.texture_prog[
'fill_color'] = self.tint_color if self.tint_enabled else self.COLOR_WHITE
self.texture_prog['transform'] = self.transform_matrix.T.flatten()
x, y = location
sx, sy = size
imx, imy = image.size
data = np.zeros(4,
dtype=[('position', np.float32, 2),
('texcoord', np.float32, 2)])
data['texcoord'] = np.array(
[[0.0, 1.0], [1.0, 1.0], [0.0, 0.0], [1.0, 0.0]], dtype=np.float32)
data['position'] = np.array(
[[x, y + sy], [x + sx, y + sy], [x, y], [x + sx, y]],
dtype=np.float32)
self.texture_prog['texture'] = image._texture
self.texture_prog.bind(VertexBuffer(data))
self.texture_prog.draw('triangle_strip')
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,
title='Rain [Move mouse]',
size=(512, 512),
keys='interactive')
# Build data
# --------------------------------------
n = 500
self.data = np.zeros(n, [('a_position', np.float32, 2),
('a_fg_color', np.float32, 4),
('a_size', np.float32, 1)])
self.index = 0
self.program = Program(vertex, fragment)
self.vdata = VertexBuffer(self.data)
self.program.bind(self.vdata)
self.program['u_antialias'] = 1.00
self.program['u_linewidth'] = 1.00
self.program['u_model'] = np.eye(4, dtype=np.float32)
self.program['u_view'] = np.eye(4, dtype=np.float32)
self.activate_zoom()
gloo.set_clear_color('white')
gloo.set_state(blend=True,
blend_func=('src_alpha', 'one_minus_src_alpha'))
self.timer = app.Timer('auto', self.on_timer, start=True)
self.show()
def __init__(self, shading='flat',
ambient_coefficient=(1, 1, 1, 1),
diffuse_coefficient=(1, 1, 1, 1),
specular_coefficient=(1, 1, 1, 1),
shininess=100,
light_dir=(10, 5, -5),
ambient_light=(1, 1, 1, .25),
diffuse_light=(1, 1, 1, 0.7),
specular_light=(1, 1, 1, .25),
enabled=True):
self._shading = shading
self._ambient_coefficient = _as_rgba(ambient_coefficient)
self._diffuse_coefficient = _as_rgba(diffuse_coefficient)
self._specular_coefficient = _as_rgba(specular_coefficient)
self._shininess = shininess
self._light_dir = light_dir
self._ambient_light = _as_rgba(ambient_light)
self._diffuse_light = _as_rgba(diffuse_light)
self._specular_light = _as_rgba(specular_light)
self._enabled = enabled
vfunc = Function(shading_vertex_template)
ffunc = Function(shading_fragment_template)
self._normals = VertexBuffer(np.zeros((0, 3), dtype=np.float32))
vfunc['normal'] = self._normals
super().__init__(vcode=vfunc, fcode=ffunc)
def on_initialize(self, event):
self.rho = 0.0
# Build cube data
# --------------------------------------
self.checker = Program(cube_vertex, cube_fragment)
self.checker['texture'] = checkerboard()
self.checker['position'] = [(-1, -1), (-1, +1), (+1, -1), (+1, +1)]
self.checker['texcoord'] = [(0, 0), (0, 1), (1, 0), (1, 1)]
# sheet, indices = make_sheet((960, 1080))
# sheet_buffer = VertexBuffer(sheet)
left_eye = Texture2D((960, 1080, 3), interpolation='linear')
self.left_eye_buffer = FrameBuffer(left_eye, RenderBuffer((960, 1080)))
# Build program
# --------------------------------------
self.view = np.eye(4, dtype=np.float32)
self.program = Program(vertex, fragment)
distortion_buffer = VertexBuffer(make_distortion())
self.program.bind(distortion_buffer)
self.program['rotation'] = self.view
self.program['texture'] = left_eye
# 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 __init__(self):
app.Canvas.__init__(self)
self.position = 50, 50
self.size = 512, 512
self.program = Program(VS, FS)
self.tex = Texture2D(data1)
self.program['a_position'] = VertexBuffer(positions)
self.program['a_texcoord'] = VertexBuffer(texcoords)
self.program['u_tex'] = self.tex
self._timer = app.Timer(.01)
self._timer.connect(self.on_timer)
self._timer.start()
self.measure_fps(.05, callback=self.fps_callback)
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):
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 __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 __init__(self):
self.use_shaders = True
app.Canvas.__init__(self, size=(512, 512), keys='interactive')
# Note: read as bytes, then decode; py2.6 compat
with open(op.join(this_dir, 'vertex_vispy.glsl'), 'rb') as fid:
vert = fid.read().decode('ASCII')
with open(op.join(this_dir, 'fragment_seed.glsl'), 'rb') as f:
frag_seed = f.read().decode('ASCII')
with open(op.join(this_dir, 'fragment_flood.glsl'), 'rb') as f:
frag_flood = f.read().decode('ASCII')
with open(op.join(this_dir, 'fragment_display.glsl'), 'rb') as f:
frag_display = f.read().decode('ASCII')
self.programs = [
Program(vert, frag_seed),
Program(vert, frag_flood),
Program(vert, frag_display)
]
# Initialize variables
# using two FBs slightly faster than switching on one
self.fbo_to = [FrameBuffer(), FrameBuffer()]
self._setup_textures('shape1.tga')
vtype = np.dtype([('position', 'f4', 2), ('texcoord', 'f4', 2)])
vertices = np.zeros(4, dtype=vtype)
vertices['position'] = [[-1., -1.], [-1., 1.], [1., -1.], [1., 1.]]
vertices['texcoord'] = [[0., 0.], [0., 1.], [1., 0.], [1., 1.]]
vertices = VertexBuffer(vertices)
for program in self.programs:
program.bind(vertices)
self._timer = app.Timer('auto', self.update, start=True)
self.show()
def __init__(self):
app.Canvas.__init__(self, keys='interactive')
# This size is used for comparison with agg (via matplotlib)
self.size = 512, 512 + 2 * 32
self.title = "Markers demo [press space to change marker]"
self.vbo = VertexBuffer(data)
self.view = np.eye(4, dtype=np.float32)
self.model = np.eye(4, dtype=np.float32)
self.projection = ortho(0, self.size[0], 0, self.size[1], -1, 1)
self.programs = [
Program(markers.vert, markers.frag + markers.tailed_arrow),
Program(markers.vert, markers.frag + markers.disc),
Program(markers.vert, markers.frag + markers.diamond),
Program(markers.vert, markers.frag + markers.square),
Program(markers.vert, markers.frag + markers.cross),
Program(markers.vert, markers.frag + markers.arrow),
Program(markers.vert, markers.frag + markers.vbar),
Program(markers.vert, markers.frag + markers.hbar),
Program(markers.vert, markers.frag + markers.clobber),
Program(markers.vert, markers.frag + markers.ring)
]
for program in self.programs:
program.bind(self.vbo)
program["u_antialias"] = u_antialias,
program["u_size"] = 1
program["u_model"] = self.model
program["u_view"] = self.view
program["u_projection"] = self.projection
self.index = 0
self.program = self.programs[self.index]
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 clearPoints(self):
print("Clear Points")
verts = np.zeros(0, [('position', np.float32, 3),
('normal', np.float32, 3),
('color', np.float32, 3)]) #start empty...
self.program_points.bind(VertexBuffer(verts))
self.update()
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()
