def add_teeth(self, center, num_teeth):
for tooth in self.teeth:
self.remove(tooth)
self.teeth = []
self.add(self.color)
self.add(PushMatrix())
self.add(Translate(center))
# use this Rotate to animate rotation for the whole flower
self.rot = Rotate(angle=0, origin=self.storage_pos)
self.add(self.rot)
# make petals ellipses with these width and height:
self.middle_size = self.size / 2
w = self.size / 5
h = self.size / 5
# how much to rotate each petal.
d_theta = 360. / num_teeth
for n in range(num_teeth):
self.add(Rotate(angle=d_theta, origin=center))
self.add(Translate(self.middle_size, 0))
rect = CRectangle(cpos=center, csize=(h, w))
self.teeth.append(rect)
self.add(rect)
self.add(Translate(-self.middle_size, 0))
self.add(PopMatrix())
def __init__(self, pos, texture, size_x=1.0, size_y=1.0, intensity=1.0, Tr=1.0):
super(BillboardDisplay, self).__init__()
self.intensity = intensity
self.Tr = Tr
self.translate = Translate()
self.rotate_azi = Rotate(origin=(0,0,0), axis=(0,1,0))
self.rotate_ele = Rotate(origin=(0,0,0), axis=(1,0,0))
self.scale = Scale()
self.color_instruction = InstructionGroup()
self.mesh = Mesh(
texture=texture,
vertices=rectangle_nurb.vertices,
indices=rectangle_nurb.indices,
fmt=rectangle_nurb.vertex_format,
mode='triangles'
)
self.add(PushMatrix())
self.add(self.translate)
self.add(self.rotate_azi)
self.add(self.rotate_ele)
self.add(self.scale)
self.add(self.color_instruction)
self.add(self.mesh)
self.add(PopMatrix())
self.set_color(intensity=intensity, Tr=Tr)
self.set_size(size_x, size_y)
self.set_pos(pos)
self.set_texture(texture)
def draw_object(self, obj_id):
m = self._scene.objects[obj_id]
self.obj_rot_z = Rotate(self.obj_rotation[2], 0, 0, 1)
self.obj_rot_y = Rotate(self.obj_rotation[1], 0, 1, 0)
self.obj_rot_x = Rotate(self.obj_rotation[0], 1, 0, 0)
self.obj_translate = Translate(xyz=self.obj_translation)
if len(m.indices) > 2**16:
print '%s too big! %s indices' % (obj_id, len(m.indices))
if m.texture:
print "loading texture %s " % m.texture
img = Image(
source=resource_find(join(dirname(self.scene), m.texture)))
texture = img.texture
if texture:
texture.wrap = 'repeat'
else:
texture = None
vertex_lenght = sum(x[1] for x in m.vertex_format)
if len(m.vertices) % vertex_lenght:
print(('warning: vertices lenght (%s)'
'is not a multiple of vertex_format lenght(%s)') %
(len(m.vertices), vertex_lenght))
Mesh(vertices=m.vertices,
indices=m.indices,
fmt=m.vertex_format,
texture=texture,
mode=self.mode)
def _draw_sprite(state, canvas, view_pos, view_scale, sprite_name, texture, pos, scale, rotate, origin_xy):
"""
TODO
"""
rectangles_rotates_dict = state[globals.IDX_STATE_SPRITES][IDX_SPRITES_RECTS_ROTS]
col = int(pos[0])
row = int(pos[1])
scaled_tile_size = tiles.get_tile_size(state) * view_scale
tile_x = col * scaled_tile_size
tile_y = row * scaled_tile_size
draw_x = tile_x - view_pos[0] * scaled_tile_size
draw_y = tile_y - view_pos[1] * scaled_tile_size
draw_pos = (draw_x, draw_y)
offset = (pos[0] - col, pos[1] - row,)
offset_pos = (int(draw_pos[0] + scaled_tile_size * offset[0] + origin_xy[0]),
int(draw_pos[1] + scaled_tile_size * offset[1] + origin_xy[1]))
if rectangles_rotates_dict.has_key(sprite_name):
rect, rot = rectangles_rotates_dict[sprite_name]
if not rect.texture is texture:
rect.texture = texture
pos_changed = (abs(rect.pos[0] - offset_pos[0]) > 1) or (abs(rect.pos[1] - offset_pos[1]) > 1)
rot_changed = abs(rot.angle - rotate) > 1
if pos_changed or rot_changed:
rect.pos = offset_pos
rot.angle = rotate
x = offset_pos[0]
y = offset_pos[1]
w = texture.size[0] * view_scale * scale[0]
h = texture.size[1] * view_scale * scale[1]
rot.origin = (x + w/2, y + h/2)
else:
with canvas:
PushMatrix()
x = offset_pos[0]
y = offset_pos[1]
w = texture.size[0] * view_scale * scale[0]
h = texture.size[1] * view_scale * scale[1]
rot = Rotate()
rot.angle = rotate
rot.axis = (0, 0, 1)
rot.origin = (x + w/2, y + h/2)
rect = Rectangle(
texture=texture,
pos=offset_pos,
size=(w, h)
)
rectangles_rotates_dict[sprite_name] = (rect, rot,)
PopMatrix()
def draw_tile(tile, rotated = False): if rotated: Rotate(90, 0, 0, 1) # no idea why pos isn't 80 or 120 Rectangle(pos=(0,-100), size=(80, 95), source=tilelist[tile / 4]) Rotate(-90, 0, 0, 1) Translate(120, 0, 0) else: Rectangle(pos=(0,0), size=(80, 95), source=tilelist[tile / 4]) Translate(80, 0, 0)
def reinit_before(self, base_angle=None):
"""Initialize the “before” canvas, i.e., whatever's below the MazeBoard
"""
cell_size = self.board.cell_size
if base_angle is None:
base_angle = 180 if self.current_solver else 0
self.canvas.before.clear()
with self.canvas.before:
for player, rotation in enumerate((90, 270)):
# Win/lose messages at end of game
if self.round_number < NUM_ROUNDS:
text = ''
elif player ^ (self.times[0] < self.times[1]):
text = 'Winner!'
else:
text = 'Second place'
PushMatrix()
Translate(
self.board.window_width / 2,
self.board.window_height / 2,
0,
)
Rotate(rotation, 0, 0, 1)
l = Label(
text=text,
pos=(
-self.board.window_height / 2,
-self.board.window_width / 2 + cell_size,
),
size=(self.board.window_height, cell_size * 4),
bold=True,
font_size=cell_size * 2,
color=(1, 1, 0),
)
PopMatrix()
PushMatrix()
Translate(
self.board.window_width / 2,
self.board.window_height / 2,
0,
)
# Instructions for animating the board
self.scale_instruction = Scale(1)
self.rotate_instruction = Rotate(base_angle, 0, 0, 1)
Translate(
-self.board.window_width / 2,
-self.board.window_height / 2,
0,
)
def draw_quad(self, star_list):
star_tex = Image('star1.png').texture
with self.canvas:
for star in star_list:
size = .5 * star[2]
PushMatrix()
t = Translate()
r = Rotate()
r.angle = star[3]
Quad(texture=star_tex,
points=(-size, -size, size, -size, size, size, -size,
size))
t.xy = star[0], star[1]
PopMatrix()
def draw_quad(self, star_list):
star_tex = Image('star1.png').texture
with self.canvas:
for star in star_list:
size = .5*star[2]
PushMatrix()
t = Translate()
r = Rotate()
r.angle = star[3]
Quad(texture = star_tex, points = (-size,
-size, size, -size,
size, size, -size, size))
t.xy = star[0], star[1]
PopMatrix()
def __init__(self, norm, pos, tempo, clock, tempo_map, touch_points,
block_handler):
super(TempoCursor, self).__init__()
self.norm = norm
self.pos = pos
self.size = self.norm.nt((70, 70))
self.cursor = CEllipse(cpos=pos, csize=self.size)
self.add(Color(1, 1, 1))
self.add(self.cursor)
self.tempo = tempo
self.clock = clock
self.tempo_map = tempo_map
self.sched = Scheduler(self.clock, self.tempo_map)
self.block_handler = block_handler
# 0..15, for 16th note granularity
self.touch_points = touch_points
self.index = 0
# add touch markers
self.add(PushMatrix())
self.add(Translate(*pos))
for touch_point in self.touch_points:
self.add(Rotate(angle=-360 * touch_point / 16))
self.add(Color(159 / 255, 187 / 255, 208 / 255)) # blue
self.add(Line(points=(0, 0, 0, self.norm.nv(25)), width=2))
self.add(Rotate(angle=360 * touch_point / 16))
self.add(PopMatrix())
# add current time marker
self.add(PushMatrix())
self.add(Translate(*pos))
self.time_marker = Line(points=(0, 0, 0, self.norm.nv(30)), width=3)
self.rotate = Rotate(angle=0)
self.add(self.rotate)
self.add(Color(0, 0, 0))
self.add(self.time_marker)
self.add(PopMatrix())
self.on_update(0)
cur_tick = self.sched.get_tick()
next_tick = quantize_tick_up(cur_tick, kTicksPerQuarter * 4)
next_tick += self.calculate_tick_interval(0, self.touch_points[0])
self.sched.post_at_tick(self.touch_down, next_tick)
def draw(self):
self.canvas.clear()
with self.canvas:
Color(self.color.r, self.color.g, self.color.b)
# half-circle
Ellipse(pos=(self.position.x - TankWidget.tank_size / 2,
self.position.y - TankWidget.tank_size / 2),
size=(TankWidget.tank_size, TankWidget.tank_size),
angle_start=-90,
angle_end=90,
segments=30)
# base
Rectangle(pos=(self.position.x - TankWidget.tank_size / 2,
self.position.y - TankWidget.tank_size / 4),
size=(TankWidget.tank_size, TankWidget.tank_size / 4))
# barrel
PushMatrix()
self.rot = Rotate()
self.rot.angle = self.barrel_rotation
self.rot.origin = (self.position.x, self.position.y)
Rectangle(pos=(self.position.x - TankWidget.tank_barrel_size.x / 2,
self.position.y),
size=(TankWidget.tank_barrel_size.x,
TankWidget.tank_size / 2 +
TankWidget.tank_barrel_size.y))
PopMatrix()
def __init__(self, color, pos):
super(SingularKaleidoscope, self).__init__()
offset = Window.width * 0.05
self.height = Window.height / 3
self.add(PushMatrix())
self.background = CRectangle(
pos=pos,
size=(0, 0),
texture=Image('res/kaleidoscope/bw-circle.png').texture)
self.add(self.background)
self.rotate = Rotate(angle=0, origin=pos)
self.add(self.rotate)
self.star = CRectangle(
pos=pos,
size=(0, 0),
texture=Image('res/kaleidoscope/bw-inner-star.png').texture)
self.add(self.star)
self.add(PopMatrix())
self.circle = CEllipse(cpos=pos, csize=(0, 0))
self.color = Color(*color)
self.color.a = 0.5
self.add(self.color)
self.add(self.circle)
self.size_grow = None
def _render(self):
if self.num_particles == 0:
return
for i in range(self.num_particles):
particle = self.particles[i]
size = (self.texture.size[0] * particle.scale,
self.texture.size[1] * particle.scale)
if particle not in self.particles_dict:
self.particles_dict[particle] = dict()
color = particle.color[:]
with self.canvas:
PushMatrix()
self.particles_dict[particle]['color'] = Color(
color[0], color[1], color[2], color[3])
self.particles_dict[particle]['translate'] = Translate()
self.particles_dict[particle]['rotate'] = Rotate()
self.particles_dict[particle]['rotate'].set(
particle.rotation, 0, 0, 1)
self.particles_dict[particle]['rect'] = Quad(
texture=self.texture,
points=(-size[0] * 0.5, -size[1] * 0.5, size[0] * 0.5,
-size[1] * 0.5, size[0] * 0.5, size[1] * 0.5,
-size[0] * 0.5, size[1] * 0.5))
self.particles_dict[particle]['translate'].xy = (
particle.x, particle.y)
PopMatrix()
else:
self.particles_dict[particle][
'rotate'].angle = particle.rotation
self.particles_dict[particle]['translate'].xy = (particle.x,
particle.y)
self.particles_dict[particle]['color'].rgba = particle.color
def countdown(self, num):
"""The countdown for the solving player
For positive `num`, shows the number near the maze entrance, animates
it, and schedules a call to countdown(num-1) for one second.
For num == 0, display 'Go!', animate it, and grow the ball source.
"""
label = Label(
text=str(num) if num else 'Go!',
font_size=24,
color=(0, 0, 1, 1),
)
with label.canvas.before:
PushMatrix()
Translate(
self.window_width - self.cell_size * 1,
self.window_height - self.cell_size * 5,
0,
)
Rotate(90, 0, 0, 1)
with label.canvas.after:
PopMatrix()
animation = Animation(font_size=256,
color=(0, 0, 1, 0),
t='in_cubic',
duration=1.5)
animation.start(label)
self.add_widget(label)
if num > 0:
Clock.schedule_once(lambda dt: self.countdown(num - 1), 1)
else:
self.ball_source.grow(self.cell_size * 3)
if self.parent:
self.parent.set_message(True,
u'Take a ball from the blue corner.')
def add_screen(self, screen):
self.screen_in.pos = self.screen_out.pos
self.screen_in.size = self.screen_out.size
self.manager.real_remove_widget(self.screen_out)
self.fbo_in = self.make_screen_fbo(self.screen_in)
self.fbo_out = self.make_screen_fbo(self.screen_out)
self.manager.canvas.add(self.fbo_in)
self.manager.canvas.add(self.fbo_out)
screen_rotation = Config.getfloat('graphics', 'rotation')
pos = (0, 1)
if screen_rotation == 90:
pos = (0, 0)
elif screen_rotation == 180:
pos = (-1, 0)
elif screen_rotation == 270:
pos = (-1, 1)
self.render_ctx = RenderContext(fs=self.fs, vs=self.vs)
with self.render_ctx:
BindTexture(texture=self.fbo_out.texture, index=1)
BindTexture(texture=self.fbo_in.texture, index=2)
Rotate(screen_rotation, 0, 0, 1)
Rectangle(size=(1, -1), pos=pos)
self.render_ctx['projection_mat'] = Matrix().\
view_clip(0, 1, 0, 1, 0, 1, 0)
self.render_ctx['tex_out'] = 1
self.render_ctx['tex_in'] = 2
self.manager.canvas.add(self.render_ctx)
def __init__(self, cpos, dim, shape):
super().__init__()
self.shape = shape
tex_file = 'res/background/%s%d.png' % (self.shape, randint(1, 4))
self.buffer = dim[1] / 2
self.dim = np.array(dim, dtype=np.float)
self.cpos = cpos
self.pos = np.array([cpos[0] - 0.5 * dim[0], cpos[1] - 0.5 * dim[1]])
self.vel = np.array((choice([-1, 1]) * randint(50, 200), choice([-1, 1]) * randint(50, 200)), dtype=np.float)
self.add(PushMatrix())
self.rotate = Rotate(origin=self.pos, angle=randint(0, 359))
self.add(self.rotate)
self.shape = Rectangle(size=dim, texture=Image(tex_file).texture, pos=self.pos)
self.add(self.shape)
self.add(PopMatrix())
self.time = 0
self.on_update(0)
def __init__(self, **kwargs):
super(Cannon, self).__init__(**kwargs)
self.velocity = 0
self.velocity_clock = 0
self.velocity_x = 0
self.velocity_y = 0
self.angle = 0
self.x_collide = False
self.y_collide = False
self.x_rand = 0
self.y_rand = 0
random.seed()
with self.canvas:
self.sky = Rectangle(size=(2000, 1000), source="Back_Drop.png")
self.grass = Rectangle(size=(2000, 100), source="Grass.png")
self.target = Rectangle(size=(35, 35), pos=(400, 0), source="python_discord_logo.png")
self.wheel = Rectangle(size=(35, 35), pos=(20, 0), source="Wheel.png")
# Draws the cannon and binds rotation object to it for changing in set_angle()
self.canvas.before
context_instructions.PushMatrix()
self.rotate = Rotate(origin=(42.5, 12.5), angle=self.angle)
self.cannon = Rectangle(size=(50, 15), pos=(35, 10), source="cannon.png")
context_instructions.PopMatrix()
self.canvas.after
self.cannonball = Rectangle(pos=(1000, 1000), size=(10, 10), source="Cannon_Ball.png")
def __init__(self, filepath):
super(Picture, self).__init__()
im = Image.open(filepath).convert("RGBA")
self.image = im.copy()
self.temp = im.copy()
self.filepath = filepath
# Save states
self.history = [(im, im.size[0], im.size[1])] # includes current state
self.history_pos = 0
# Size and graphics
width, height = self.image.size
pos = (Window.width - width) // 2, (Window.height - height) // 2
size = (width, height)
# allow rotation:
self.add(PushMatrix())
self.rotate = Rotate(angle=0)
self.add(self.rotate)
# create rectangle to hold image
self.rectangle = Rectangle(pos=pos, size=size)
self.add(PopMatrix())
self.on_update()
self.add(self.rectangle)
def _get_fbo(self,widget):
'''get frame buffer object of widget.
Args:
widget: subclass of kivy.uix.widget.
Returns:
kivy.graphics.fbo
'''
if widget.parent is not None:
canvas_parent_index = widget.parent.canvas.indexof(self.canvas)
if canvas_parent_index > -1:
widget.parent.canvas.remove(widget.canvas)
fbo = Fbo(size=widget.size, with_stencilbuffer=True)
with fbo:
PushMatrix()
ClearColor(0, 0, 0, 0)
ClearBuffers()
Scale(1, -1, 1)
Translate(-widget.x, -widget.y - widget.height, 0)
Rotate(origin=widget.center,
axis=(widget.center_x,0,0),
angle=-180)
return fbo
def _set_canvas(self):
with self.canvas.before:
PushMatrix()
self.rotation = Rotate(angle=self.start_angle, origin=self.center)
with self.canvas.after:
PopMatrix()
def draw_setpoint(self, *args):
# draw a setpoint
if self.setpoint_canvas:
self.canvas.after.remove(self.setpoint_canvas)
self.setpoint_canvas = None
if math.isnan(self.setpoint_value):
return
v = self.value_to_angle(self.setpoint_value)
length = self.dial_diameter / 2.0 - self.tic_length if not self.setpoint_length else self.setpoint_length
self.setpoint_canvas = InstructionGroup()
self.setpoint_canvas.add(PushMatrix())
self.setpoint_canvas.add(Color(*self.setpoint_color))
self.setpoint_canvas.add(
Rotate(angle=v, axis=(0, 0, -1), origin=self.dial_center))
self.setpoint_canvas.add(
Translate(self.dial_center[0], self.dial_center[1]))
self.setpoint_canvas.add(
Line(points=[0, 0, 0, length],
width=self.setpoint_thickness,
cap='none'))
#self.setpoint_canvas.add(SmoothLine(points=[0, 0, 0, length], width=self.setpoint_thickness))
self.setpoint_canvas.add(PopMatrix())
self.canvas.after.add(self.setpoint_canvas)
def draw_ticks(self):
scangle = self.angle_stop - self.angle_start
inc = scangle / (
(self.scale_max - self.scale_min) / self.scale_increment)
inc /= self.tic_frequency
cnt = 0
# create an instruction group so we can remove it and recall draw_ticks to update when pos or size changes
self.ticks = InstructionGroup()
self.ticks.add(Color(*self.tic_color))
labi = self.scale_min
x = -180.0 + self.angle_start + self.angle_offset # start
while x <= self.angle_stop - 180 + self.angle_offset:
a = x if (x < 0.0) else x + 360.0
need_label = True
ticlen = self.tic_length
if (cnt % self.tic_frequency != 0):
ticlen = self.tic_length / 2
need_label = False
cnt += 1
self.ticks.add(PushMatrix())
self.ticks.add(
Rotate(angle=a,
axis=(0, 0, -1),
origin=(self.dial_center[0], self.dial_center[1])))
self.ticks.add(Translate(0, self.tic_radius - ticlen))
self.ticks.add(
Line(points=[
self.dial_center[0], self.dial_center[1],
self.dial_center[0], self.dial_center[1] + ticlen
],
width=self.tic_width,
cap='none',
joint='none'))
if need_label:
#print("label: " + str(labi))
#kw['font_size'] = self.tic_length * 2
label = CoreLabel(text=str(int(round(labi))),
font_size=self.scale_font_size)
label.refresh()
texture = label.texture
self.ticks.add(
Translate(-texture.size[0] / 2, -texture.size[1] - 2))
self.ticks.add(
Rectangle(texture=texture,
pos=self.dial_center,
size=texture.size))
labi += self.scale_increment
self.ticks.add(PopMatrix())
x += inc
self.canvas.add(self.ticks)
def __init__(self, pos, tick):
super(Trail, self).__init__()
self.pos = pos
self.tick = tick
self.x = NOW_X + DRAW_CALIBRATION + tick * PIXELS_PER_TICK
self.y = 360 - 240 + 480 * (pos)
self.is_hit = False
self.color = Color(rgb=[0.9, 0.9, 1.0], a=0.9)
self.width = 40 * PIXELS_PER_TICK
self.height = 20
self.flare_color = Color(rgb=[0.5, 0.5, 0.6])
self.flare_color.a = 0
self.hit_flare = Rectangle(pos=(self.x, self.y - 40), size=(20, 80))
self.add(self.flare_color)
self.add(self.hit_flare)
self.add(self.color)
self.shape = Rectangle(pos=(-10, -10), size=(20, 20))
self.add(PushMatrix())
self.add(Translate(self.x, self.y))
self.add(Rotate(angle=45))
self.add(self.shape)
self.add(PopMatrix())
def __init__(self, pos, color, angle):
super(Note, self).__init__()
self.pos = np.array(pos, dtype=np.float)
self.pos[0] += 25
self.pos[1] += 10
self.color = Color(*color)
self.add(self.color)
# adds a translation and rotation and another translation to the note
self.add(PushMatrix())
self.translate = Translate(*self.pos)
self.add(self.translate)
self._angle = Rotate(angle=angle)
self.add(self._angle)
self.translate2 = Translate(0, 40)
self.add(self.translate2)
self.note = Rectangle(texture=Image("particle/texture.png").texture,
pos=(-15, -15),
size=(30, 30))
self.add(self.note)
self.add(PopMatrix())
self.vel = np.array((0, 60), dtype=np.float)
self.color.a = 1
def __init__(self,
start_pos=(Window.width / 2, Window.height / 2),
start_ind=0,
colors=((0, 1, 0), (0, 0, 1)),
num_dots=8,
dot_rad=30,
ring_rad=60):
super(DotRing, self).__init__()
self.start_ind = start_ind
self.colors = colors
self.dot_rad = dot_rad
self.start_pos = start_pos
self.add(PushMatrix())
self.add(Translate(*start_pos))
# Each dot needs another rotation
d_theta = 360. / num_dots
# Rotates the whole ring
self._angle = Rotate(angle=0)
self.add(self._angle)
# Scales the whole ring
self._scale = Scale(origin=self.start_pos, xy=(1, 1))
self.add(self._scale)
# Translates the whole ring
self._translate = Translate()
self.add(self._translate)
# Increment rotation to place each petal
for n in range(num_dots):
self.add(Rotate(angle=d_theta))
self.add(Translate(ring_rad, 0))
c = colors[(self.start_ind + n) % len(
colors
)] # Iterate through the list of colors so each dot is new color
self.add(Color(*c))
self.add(CEllipse(cpos=(0, 0), csize=(self.dot_rad, self.dot_rad)))
self.add(Translate(-ring_rad, 0))
self.add(PopMatrix())
self.progress = 1
self.is_alive = True
def setup_canvas(self):
"""Populate the canvas with the initial instructions.
"""
self._selecting_nnodes = False
self.G = Graph.Star(self.nnodes, mode="out")
self._unscaled_layout = Layout([(0.0, 0.0),
*circle_points(self.nnodes - 1)])
self.scale = INIT_SCALE
self.offset_x, self.offset_y = INIT_OFFSET
self._selected_edge = self._selected_node = None
self._source_node = self._target_edge = None
self.canvas.clear()
with self.canvas.before:
self.background_color = Color(*BACKGROUND_COLOR)
self._background = Rectangle(size=self.size, pos=self.pos)
with self.canvas:
self.animated_edge_color = Color(*HIGHLIGHTED_EDGE)
self.animated_edge_color.a = 0
self.animated_edge = Line(width=1.1)
# Edge instructions before Node instructions so they're drawn underneath nodes.
self._edge_instructions = CanvasBase()
with self._edge_instructions:
self.edges = {
edge.tuple: Edge(edge.tuple, self)
for edge in self.G.es
}
self.canvas.add(self._edge_instructions)
# Animated node drawn above edges but below other nodes.
with self.canvas:
PushMatrix()
self.rotation_instruction = Rotate()
self.animated_node_color = Color(*ANIMATED_NODE_COLOR)
self.animated_node_color.a = 0
self.animated_node = Rectangle(size=(ANIMATION_WIDTH,
ANIMATION_HEIGHT),
source=ANIMATED_NODE_SOURCE)
PopMatrix()
self._node_instructions = CanvasBase()
with self._node_instructions:
self.nodes = [Node(vertex.index, self) for vertex in self.G.vs]
self.canvas.add(self._node_instructions)
# TODO: Refactor so we only need to do this once
self.bind(size=self._delayed_resize, pos=self._delayed_resize)
Window.bind(mouse_pos=self.on_mouse_pos)
self.step_layout()
self.layout_stepper()
self._mouse_pos_disabled = False
def setup_scene(self):
Color(1, 1, 1, 0)
PushMatrix()
self.cam_translate = Translate(self.cam_translation)
# Rotate(0, 1, 0, 0)
self.cam_rot_x = Rotate(self.cam_rotation[0], 1, 0, 0)
self.cam_rot_y = Rotate(self.cam_rotation[1], 0, 1, 0)
self.cam_rot_z = Rotate(self.cam_rotation[2], 0, 0, 1)
self.scale = Scale(self.obj_scale)
UpdateNormalMatrix()
if self.display_all:
for i in self._scene.objects:
self.draw_object(i)
else:
self.draw_object(self.obj_id)
PopMatrix()
def rotate(self, angle):
self.canvas.clear()
self.angle += angle
with self.canvas:
Rotate(origin=self.center, angle=self.angle)
Color(rgba=self.wheelColor)
Rectangle(pos=self.pos, size=self.size, source=self.source)
def setup_scene(self):
Color(.5, .5, .5, 0)
PushMatrix()
Translate(0, -3, -5)
# This Kivy native Rotation is used just for
# enabling rotation scene like trackball
self.rotx = Rotate(0, 1, 0, 0)
# here just rotate scene for best view
self.roty = Rotate(180, 0, 1, 0)
self.scale = Scale(1)
UpdateNormalMatrix()
self.draw_elements()
PopMatrix()
def _setup_scene(self):
for mi, m in enumerate(self.scene.objects.values()):
Color(1, 1, 1, 1)
PushMatrix()
Translate(0, -0.3, -1.8)
setattr(self, 'mesh%03d_rotx' % mi, Rotate(180, 1, 0, 0))
setattr(self, 'mesh%03d_roty' % mi, Rotate(0, 0, 1, 0))
setattr(self, 'mesh%03d_scale' % mi, Scale(1))
UpdateNormalMatrix()
mesh = Mesh(
vertices=m.vertices,
indices=m.indices,
fmt=m.vertex_format,
mode='triangles',
)
setattr(self, 'mesh%03d' % mi, mesh)
PopMatrix()
def __init__(self, angle=0, **kwargs):
super(IconButton, self).__init__(**kwargs)
self.rotate = Rotate(angle = angle)
self.canvas.before.add(PushMatrix())
self.canvas.before.add(self.rotate)
self.canvas.after.add(PopMatrix())
self.bind(pos=self.update_canvas)
self.bind(size=self.update_canvas)
self.guess = None
def ctclcwiseRot(self, instance):
self.angle += 10
with self.imageLayout.canvas:
newText = self.imageLayout.rect.texture
newSize = self.imageLayout.rect.size
newPos = self.imageLayout.rect.pos
self.imageLayout.canvas.clear()
Rotate(origin=self.imageLayout.center, angle=self.angle)
self.imageLayout.rect = Rectangle(texture=newText, size=newSize)
self.imageLayout.rect.pos = newPos