def testDivide(self):
vectorA = m.Vector([1, 2, 3, 4])
vectorB = m.Vector([1, 2, 3, 4])
result = [1, 1, 1, 1]
vectorC = vectorA / vectorB
self.assertEqual(vectorC.values, result)
vectorD = vectorA.divide(vectorB)
self.assertEqual(vectorD.values, result)
def testMultiply(self):
vectorA = m.Vector([1, 2, 3, 4])
vectorB = m.Vector([1, 2, 3, 4])
result = [1, 4, 9, 16]
vectorC = vectorA * vectorB
self.assertEqual(vectorC.values, result)
vectorD = vectorA.multiply(vectorB)
self.assertEqual(vectorD.values, result)
def testAdd(self):
vectorA = m.Vector([1, 2, 3, 4])
vectorB = m.Vector([1, 2, 3, 4])
result = [2, 4, 6, 8]
vectorC = vectorA + vectorB
self.assertEqual(vectorC.values, result)
vectorD = vectorA.add(vectorB)
self.assertEqual(vectorD.values, result)
def testSubtract(self):
vectorA = m.Vector([1, 2, 3, 4])
vectorB = m.Vector([0, 1, 0, 2])
result = [1, 1, 3, 2]
vectorC = vectorA - vectorB
self.assertEqual(vectorC.values, result)
vectorD = vectorA.subtract(vectorB)
self.assertEqual(vectorD.values, result)
def event(self, event):
if event.type == KEYDOWN:
if event.key == K_q:
pygame.quit()
return False
elif event.key == K_n:
self.skeleton.add_bone()
elif event.key == K_d:
self.skeleton.delete_bones()
elif event.type == MOUSEMOTION:
# event.pos lags horribly so get the mouse pos directly
p = pygame.mouse.get_pos()
# Left mouse button
if event.buttons[0]:
self.skeleton.drag(matrix.Vector(p[0], p[1]))
self.animation.drag(matrix.Vector(p[0], p[1]))
elif self.menu and event.buttons[2]:
self.menu.hilight(matrix.Vector(p[0], p[1]))
elif self.animation.hilight(matrix.Vector(p[0], p[1])):
pass
else:
self.skeleton.hilight(matrix.Vector(p[0], p[1]))
elif event.type == MOUSEBUTTONDOWN:
p = pygame.mouse.get_pos()
# Any mouse button will select/deselect the skeleton
self.animation.select(matrix.Vector(p[0], p[1]))
self.skeleton.select(matrix.Vector(p[0], p[1]))
if event.button == 3: # RMB
if self.animation.selected:
self.menu = self.keyframe_menu
elif self.skeleton.selected:
if isinstance(self.skeleton.selected, UISkeleton.UIBone):
self.menu = self.bone_menu
elif isinstance(self.skeleton.selected,
UISkeleton.UIJoint):
self.menu = self.joint_menu
elif isinstance(self.skeleton.selected,
UISkeleton.UIImage):
self.menu = self.image_menu
else:
self.menu = self.main_menu
self.menu.position = matrix.Vector(p[0], p[1])
elif event.button == 1:
if self.animation.select(matrix.Vector(p[0], p[1])):
key = self.animation.selected.keyframe
self.skeleton.set_bones(key.root)
elif event.type == MOUSEBUTTONUP:
p = pygame.mouse.get_pos()
if event.button == 3: # RMB
if self.menu:
self.menu.select(matrix.Vector(p[0], p[1]))
self.menu = False
return self.run
def testNegate(self):
vectorA = m.Vector([1, -2, 3, -4])
result = [-1, 2, -3, -4]
vectorC = -vectorA
self.assertEqual(vectorC.values, result)
vectorD = vectorA.negate()
self.assertEqual(vectorD.values, result)
def draw(self, screen):
rot = self.image.bone.end.get_rotation()
rot += self.image.rotation
rot *= (180.0 / pi)
rotated_image = pygame.transform.rotate(self.surface, rot)
size = rotated_image.get_size()
pos = self.image.bone.center()
trans = self.to_screen_pos(
matrix.Vector(-size[0] / 2, size[1] / 2) + pos)
screen.blit(rotated_image, [int(trans[0]), int(trans[1])])
handle_colour = (150, 150, 150)
selector_colour = (0, 0, 255)
selector_size = 3
selector_width = 0
if self.hilighted:
handle_colour = (100, 200, 100)
selector_size = 5
selector_width = 1
if self.selected:
handle_colour = (100, 200, 100)
selector_colour = (0, 255, 0)
start = self.to_screen_pos(pos)
end = self.handle_pos()
pygame.draw.line(screen, handle_colour,
[int(start[0]), int(start[1])],
[int(end[0]), int(end[1])])
pygame.draw.circle(screen, selector_colour,
[int(end[0]), int(end[1])], selector_size,
selector_width)
class Joint:
origin = matrix.Vector(0, 0)
# Joints hold position and transformation relative to the root
# This is considered ABSOLUTE
def __init__(self, bone_in):
self.bone_in = bone_in
self.bones_out = []
self.transform = matrix.Identity()
def __repr__(self):
return "Joint:\n\tPos: " + str(self.get_position()) + \
"\n\tTransform:\n" + str(self.transform) + \
"\n----------------------------"
def calc_skeleton(self):
for bone in self.bones_out:
bone.calc_transform()
bone.end.transform = bone.transform * self.transform
bone.end.calc_skeleton()
def get_position(self):
return matrix.Vector(self.transform[0][2], self.transform[1][2])
def get_rotation(self):
# Since we are only using rotates an translates
# all the info we need is in the matrix
return atan2(self.transform[1][0], self.transform[0][0])
def __init__(self, size=(640, 480)):
self.skeleton = UISkeleton.UISkeleton()
self.size = matrix.Vector(size[0], size[1])
self.run = True
self.skeleton.position = matrix.Vector(self.size[0] / 2,
self.size[1] / 2)
self.main_menu = self.make_main_menu()
self.joint_menu = self.make_joint_menu()
self.bone_menu = self.make_bone_menu()
self.image_menu = self.make_image_menu()
self.keyframe_menu = self.make_keyframe_menu()
self.menu = False
self.animation = UITweens.UIAnimation()
def add_item(self, text, callback, \
bg_filename = None, \
bg_hilight_filename = None):
# load the hilighted and normal backgrounds
if bg_filename:
bg = pygame.image.load(bg_filename)
else:
bg = pygame.Surface(self.item_size.to_coord_tuple())
if bg_hilight_filename:
bg_hl = pygame.image.load(bg_hilight_filename)
else:
bg_hl = pygame.Surface(self.item_size.to_coord_tuple())
# Render the text to a foreground surface
fg = self.font.render(text, True, (150, 150, 150))
fg_hl = self.font.render(text, True, (0, 0, 255))
# Blit the text onto the background
bg.blit(fg, (0, 0))
bg_hl.blit(fg_hl, (0, 0))
# Calculate the position of the new item
item = UIButton(self, bg, bg_hl,
matrix.Vector(0, -len(self.items) * self.item_size[1] \
if self.pop_upwards else \
len(self.items) * self.item_size[1]))
#if self.pop_upwards: item.position[1] = -item.position[1]
item.callback = callback
self.items.append(item)
def __init__(self, names_and_callbacks=(), pop_upwards=False):
UIItemManager.__init__(self)
self.position = matrix.Vector(0, 0)
self.font = pygame.font.Font(None, 14)
self.item_size = matrix.Vector(0, 0)
self.pop_upwards = pop_upwards
for name in names_and_callbacks:
size = self.font.size(name[0])
self.item_size[0] = size[0] if size[0] > self.item_size[0] \
else self.item_size[0]
self.item_size[1] = size[1] if size[1] > self.item_size[1] \
else self.item_size[1]
for name in names_and_callbacks:
self.add_item(name[0], name[1])
def draw(self, screen):
x = self.manager.ignore_x_pixels / 2
if self.manager.animation.total_time() > 0.0:
x += (screen.get_width() - self.manager.ignore_x_pixels) * \
self.keyframe.time / self.manager.animation.total_time()
y = screen.get_height()
# Recalculate position while we have the screen size
self.position = matrix.Vector(x, y)
pygame.draw.line(screen, (0, 255, 0) if self.selected else
(255, 255, 255), (x, y), (x, y - self.manager.height),
3 if self.hilighted else 1)
if self.hilighted:
secs = self.font.render(str(self.keyframe.time), True,
(150, 150, 255))
screen.blit(secs, (x - secs.get_width() / 2,
y - self.manager.height - secs.get_height()))
def testAbs(self):
vectorA = m.Vector([1, -2, 3, 4])
result = [math.fabs(x) for x in vectorA.values]
self.assertEqual(vectorA.abs(), result)
def calc_transform(self):
self.transform = \
matrix.Translation(matrix.Vector(0, self.length)) * \
matrix.Rotation(self.rotation)
def testFactorial(self):
vectorA = m.Vector([1, 2, 3, 4])
result = [math.factorial(x) for x in vectorA.values]
self.assertEqual(vectorA.factorial(), result)
def testACosh(self):
vectorA = m.Vector([1, 2, 3, 4])
result = [math.acosh(x) for x in vectorA.values]
self.assertEqual(vectorA.acosh(), result)
def get_position(self):
return matrix.Vector(self.transform[0][2], self.transform[1][2])
def testInit1(self):
vectorA = m.Vector()
vectorA.ones(4)
self.assertEqual(vectorA.values, [1, 1, 1, 1])
def testASinh(self):
vectorA = m.Vector([0.1, 0.2, 0.3, 0.4])
result = [math.asinh(x) for x in vectorA.values]
self.assertEqual(vectorA.asinh(), result)
def testExp(self):
vectorA = m.Vector([1, 2, 3, 4])
result = [math.exp(x) for x in vectorA.values]
self.assertEqual(vectorA.exp(), result)
def testPow(self):
vectorA = m.Vector([1, 2, 3, 4])
result = [float(x)**4 for x in vectorA.values]
self.assertEqual(vectorA.pow(4), result)
def testDegrees(self):
vectorA = m.Vector([1, 2, 3, 4])
result = [math.degrees(x) for x in vectorA.values]
self.assertEqual(vectorA.degrees(), result)
def testLog_2(self):
vectorA = m.Vector([1, 2, 3, 4])
result = [math.log(x, 2) for x in vectorA.values]
self.assertEqual(vectorA.log(2), result)
def testRadians(self):
vectorA = m.Vector([10, 20, 30, 40])
result = [math.radians(x) for x in vectorA.values]
self.assertEqual(vectorA.radians(), result)
def testSum(self):
vectorA = m.Vector([1, 2, 3, 4])
self.assertEqual(vectorA.factorial(), math.fsum(vectorA.values))
def testSetitem(self):
vectorA = m.Vector([1, 2, 3, 4])
self.assertEqual(vectorA.values, [1, 2, 3, 4])
vectorA[1] = 10
self.assertEqual(vectorA.values, [1, 10, 3, 4])
def testRoot3(self):
vectorA = m.Vector([1, 2, 3, 4])
result = [float(x)**(1.0 / 3) for x in vectorA.values]
self.assertEqual(vectorA.root(3), result)
def testTan(self):
vectorA = m.Vector([1, 2, 3, 4])
result = [math.tan(x) for x in vectorA.values]
self.assertEqual(vectorA.tan(), result)
def Recenter():
self.skeleton.position = matrix.Vector(self.size[0] / 2,
self.size[1] / 2)
def testGetItem(self):
vectorA = m.Vector([1, 2, 3, 4])
self.assertEqual(vectorA.values, [1, 2, 3, 4])
vectorA[1] = 10
self.assertEqual(vectorA[1], 10)
self.assertEqual(vectorA[10], None)
