class SifLinear(SifAstComplex):
_tag = "linear"
_nodes = [
XmlAnimatable("slope", "vector", NVector(0, 0)),
XmlAnimatable("offset", "vector", NVector(0, 0)),
]
def _check_layer_group(self, layer):
self.assertIsInstance(layer, api.GroupLayer)
self.assert_strong_equal(layer.type, "group")
self.assert_strong_equal(layer.desc, "Group")
self.assert_strong_equal(layer.origin.value, NVector(0., 0.))
self.assert_strong_equal(layer.time_dilation.value, 1.)
self.assert_strong_equal(layer.time_offset.value, api.FrameTime(0, api.FrameTime.Unit.Seconds))
self.assert_strong_equal(layer.children_lock, False)
self.assert_strong_equal(layer.outline_grow.value, 0.)
self.assert_strong_equal(layer.z_range, False)
self.assert_strong_equal(layer.z_range_position.value, 0.)
self.assert_strong_equal(layer.z_range_depth.value, 0.)
self.assert_strong_equal(layer.z_range_blur.value, 0.)
trans = layer.transformation
self.assertIsInstance(trans, api.SifTransform)
self.assert_strong_equal(trans.offset.value, NVector(0, 0))
self.assert_strong_equal(trans.angle.value, -89.798615)
self.assert_strong_equal(trans.skew_angle.value, 0.)
self.assert_strong_equal(trans.scale.value, NVector(1, 1))
canvas = layer.layers
self.assertEqual(len(canvas), 3)
self._check_layer_circle(canvas[0])
self._check_layer_rectangle(canvas[1])
self._check_layer_star(canvas[2])
def test_group_rotate_anchor(self):
lot = objects.Animation()
ref_sl = lot.add_layer(objects.ShapeLayer())
ref_rect = ref_sl.add_shape(objects.Rect())
ref_rect.position.value = NVector(128, 128)
ref_rect.size.value = NVector(256, 256)
ref_sl.add_shape(objects.Fill(Color(1, 0, 0)))
ref_sl.transform.opacity.value = 80
sl = lot.add_layer(objects.ShapeLayer())
rect = sl.add_shape(objects.Rect())
rect.position.value = NVector(128, 128)
rect.size.value = NVector(256, 256)
sl.add_shape(objects.Fill(Color(1, 1, 0)))
sl.transform.rotation.value = 20
sl.transform.position.value = NVector(128, 128)
sl.transform.anchor_point.value = NVector(128, 128)
sif = builder.to_sif(lot)
self.assertEqual(len(sif.layers), 2)
self.assertIsInstance(sif.layers[0], api.GroupLayer)
self.assertIsInstance(sif.layers[1], api.GroupLayer)
self.assertAlmostEqual(sif.layers[0].amount.value, 1)
self.assertAlmostEqual(sif.layers[1].amount.value, 0.8)
self.assertAlmostEqual(sif.layers[0].transformation.angle.value, 20)
self.assertAlmostEqual(sif.layers[1].transformation.angle.value, 0)
self.assert_nvector_equal(sif.layers[0].transformation.offset.value, NVector(128, 128))
self.assert_nvector_equal(sif.layers[0].origin.value, NVector(128, 128))
self.assert_nvector_equal(sif.layers[1].transformation.offset.value, NVector(0, 0))
self.assert_nvector_equal(sif.layers[1].origin.value, NVector(0, 0))
def _check_layer_circle_outline(self, layer):
self.assertIsInstance(layer, api.OutlineLayer)
self.assert_strong_equal(layer.type, "outline")
self.assert_strong_equal(layer.desc, "Circle017 Outline")
self.assert_strong_equal(layer.origin.value, NVector(-2.7097899914, 2.6285450459))
self.assertIsInstance(layer.bline, api.Bline)
self.assertEqual(len(layer.bline.points), 4)
self.assert_strong_equal(layer.bline.loop, True)
guid = "735D9D04C276A32CAE9D9F045DFF318B"
self.assert_strong_equal(layer.origin.value, self.canvas.get_object(guid))
self.assertIs(layer.origin.value, self.canvas.get_object(guid))
point = layer.bline.points[0]
self.assertIsInstance(point, api.BlinePoint)
self.assert_strong_equal(point.point.value, NVector(0.5332824588, 0))
self.assert_strong_equal(point.width.value, 1.)
self.assert_strong_equal(point.origin.value, 0.5)
self.assert_strong_equal(point.split.value, False)
self.assert_strong_equal(point.split_radius.value, True)
self.assert_strong_equal(point.split_angle.value, False)
self.assert_strong_equal(point.t1.radius.value, 0.8835712761)
self.assert_strong_equal(point.t1.theta.value, 90.)
self.assert_strong_equal(point.t2.radius.value, 0.8835712761)
self.assert_strong_equal(point.t2.theta.value, 90.)
def test_animated_real(self):
lot = objects.Animation()
ref_sl = lot.add_layer(objects.ShapeLayer())
ref_rect = ref_sl.add_shape(objects.Rect())
ref_rect.position.value = NVector(128, 128)
ref_rect.size.value = NVector(256, 256)
ref_sl.add_shape(objects.Fill(Color(1, 0, 0)))
ref_sl.transform.opacity.add_keyframe(0, 100)
ref_sl.transform.opacity.add_keyframe(30, 0)
ref_sl.transform.opacity.add_keyframe(60, 100)
sif = builder.to_sif(lot)
self.assertEqual(len(sif.layers), 1)
self.assertIsInstance(sif.layers[0], api.GroupLayer)
amount = sif.layers[0].amount
self.assertAlmostEqual(amount.keyframes[0].value, 1)
self.assertAlmostEqual(amount.keyframes[1].value, 0)
self.assertAlmostEqual(amount.keyframes[2].value, 1)
self.assertEqual(amount.keyframes[0].time, api.FrameTime.frame(0))
self.assertEqual(amount.keyframes[1].time, api.FrameTime.frame(30))
self.assertEqual(amount.keyframes[2].time, api.FrameTime.frame(60))
def test_keyframes(self):
md = objects.MultiDimensional(NVector(0, 0))
md.add_keyframe(0, NVector(1, 2))
md.add_keyframe(3, NVector(4, 5))
self.assertDictEqual(
md.to_dict(), {
"a":
1,
"k": [{
"t": 0,
"s": [1, 2],
"e": [4, 5],
"i": {
"x": [1],
"y": [1]
},
"o": {
"x": [0],
"y": [0]
},
}, {
"t": 3,
"s": [4, 5],
}]
})
def _check_layer_polygon(self, layer):
self.assertIsInstance(layer, api.PolygonLayer)
self.assert_strong_equal(layer.type, "polygon")
self.assert_strong_equal(layer.desc, "Polygon008")
self.assert_strong_equal(layer.active, True)
self.assert_strong_equal(layer.exclude_from_rendering, False)
self.assert_strong_equal(layer.version, "0.1")
self.assert_strong_equal(layer.z_depth.value, 0.)
self.assert_strong_equal(layer.amount.value, 1.)
self.assert_strong_equal(layer.blend_method, api.BlendMethod.Composite)
self.assert_strong_equal(layer.origin.value, NVector(0., 0.))
self.assert_strong_equal(layer.color.value, NVector(1., 1., 1., 1.))
self.assert_strong_equal(layer.origin.value, NVector(0, 0))
self.assert_strong_equal(layer.invert.value, False)
self.assert_strong_equal(layer.antialias.value, True)
self.assert_strong_equal(layer.feather.value, 0.)
self.assert_strong_equal(layer.blurtype.value, api.BlurType.FastGaussian)
self.assert_strong_equal(layer.winding_style.value, api.WindingStyle.NonZero)
self.assertIsInstance(layer.points, list)
self.assertEqual(len(layer.points), 5)
self.assert_strong_equal(layer.points[0].value, NVector(-3.4468984604, 0.6007212400))
self.assert_strong_equal(layer.points[4].value, NVector(-2.7399964333, -0.2140279114))
def test_get_value_inconsistent(self):
md = objects.MultiDimensional(NVector(0, 0))
md.value = NVector(1, 2)
md.animated = True
self.assertEqual(md.get_value(), None)
self.assertEqual(md.get_value(0), None)
self.assertEqual(md.get_value(3), None)
self.assertEqual(md.get_value(4), None)
def test_repeater(self):
lot = objects.Animation()
sl = lot.add_layer(objects.ShapeLayer())
group = sl.add_shape(objects.Group())
star = group.add_shape(objects.Star())
star.inner_radius.value = 16
star.outer_radius.value = 32
star.position.value = NVector(256, 40)
group.add_shape(objects.Fill(Color(1, 1, 0)))
group.add_shape(objects.Stroke(Color(0, 0, 0), 3))
group.name = "Star"
rep = sl.add_shape(objects.Repeater(4))
rep.name = "Repeater"
rep.transform.position.value = NVector(20, 80)
rep.transform.end_opacity.value = 20
sif = builder.to_sif(lot)
self.assertEqual(len(sif.layers), 1)
self.assertIsInstance(sif.layers[0], api.GroupLayer)
self.assertEqual(len(sif.layers[0].layers), 1)
self.assertIsInstance(sif.layers[0].layers[0], api.GroupLayer)
self.assertEqual(sif.layers[0].layers[0].desc, "Repeater")
self.assertEqual(len(sif.layers[0].layers[0].layers), 2)
duplicate_lay = sif.layers[0].layers[0].layers[1]
self.assertIsInstance(duplicate_lay, api.DuplicateLayer)
self.assertEqual(duplicate_lay.desc, "Repeater")
duplicate = sif.get_object(duplicate_lay.index.id)
self.assertIsInstance(duplicate, api.Duplicate)
self.assertEqual(duplicate.from_.value, 3)
self.assertEqual(duplicate.to.value, 0)
self.assertEqual(duplicate.step.value, -1)
dup_trans = sif.layers[0].layers[0].layers[0]
self.assertIsInstance(dup_trans, api.GroupLayer)
self.assertEqual(dup_trans.desc, "Transformation for Repeater")
dup_origin = sif.get_object(dup_trans.origin.id)
self.assert_nvector_equal(dup_origin.value.value, NVector(0, 0))
trans = dup_trans.transformation
self.assertIsInstance(trans.offset, ast.SifAdd)
self.assertEqual(trans.offset.rhs.value.id, dup_origin.id)
self.assertIsInstance(trans.offset.lhs, ast.SifScale)
self.assert_nvector_equal(trans.offset.lhs.link.value, NVector(20, 80))
self.assertEqual(trans.offset.lhs.scalar.value.id, duplicate.id)
self.assertIsInstance(trans.angle, ast.SifScale)
self.assertEqual(trans.angle.link.value, 0)
self.assertEqual(trans.angle.scalar.value.id, duplicate.id)
self.assertIsInstance(dup_trans.amount, ast.SifSubtract)
self.assertEqual(dup_trans.amount.lhs.value, 1)
self.assertIsInstance(dup_trans.amount.rhs, ast.SifScale)
self.assertAlmostEqual(dup_trans.amount.rhs.link.value, 0.266666666)
self.assertEqual(dup_trans.amount.rhs.scalar.value.id, duplicate.id)
self.assertEqual(len(dup_trans.layers), 1)
self.assertEqual(dup_trans.layers[0].desc, "Star")
def _check_layer_circle(self, layer):
self.assertIsInstance(layer, api.CircleLayer)
self.assert_strong_equal(layer.type, "circle")
self.assert_strong_equal(layer.radius.value, 0.5332824707)
self.assert_strong_equal(layer.feather.value, 0.)
self.assert_strong_equal(layer.origin.value, NVector(-2.7097899914, 2.6285450459))
self.assert_strong_equal(layer.color.value, NVector(1., 0., 0., 1.))
guid = "735D9D04C276A32CAE9D9F045DFF318B"
self.assert_strong_equal(layer.origin.value, self.canvas.get_object(guid))
self.assertIs(layer.origin.value, self.canvas.get_object(guid))
def _check_layer_gradient(self, layer):
self.assert_strong_equal(layer.desc, "Gradient Group")
gradient = layer.layers[0]
self.assertIsInstance(gradient, api.RadialGradient)
self.assertEqual(len(gradient.gradient.value), 2)
self.assert_strong_equal(gradient.gradient.value[0].pos, 0.)
self.assert_strong_equal(gradient.gradient.value[0].color, NVector(1, 1, 1, 1))
self.assert_strong_equal(gradient.gradient.value[1].pos, 1.)
self.assert_strong_equal(gradient.gradient.value[1].color, NVector(0, 0, 0, 1))
self.assert_strong_equal(layer.layers[1].blend_method, api.BlendMethod.Alpha)
def _check_layer_rectangle(self, layer):
self.assertIsInstance(layer, api.RectangleLayer)
self.assert_strong_equal(layer.type, "rectangle")
self.assert_strong_equal(layer.color.value, NVector(1., 1., 1., 1.))
self.assert_strong_equal(layer.point1.value, NVector(-1.4219197035, 2.7379217148))
self.assert_strong_equal(layer.point2.value, NVector(-0.2791198790, 1.7953078747))
self.assert_strong_equal(layer.expand.value, 0.)
self.assert_strong_equal(layer.feather_x.value, 0.)
self.assert_strong_equal(layer.feather_y.value, 0.)
self.assert_strong_equal(layer.bevel.value, 0.1666666797)
self.assert_strong_equal(layer.bevCircle.value, True)
def test_single_lower(self):
anim = self.parse_svg_path("""
M 10, 10 L 10, 20, 20, 20 z
""")
path = anim.find("path")
bezier = path.shapes[0].shape.value
self.assertListEqual(bezier.vertices, [
NVector(10, 10),
NVector(10, 20),
NVector(20, 20),
])
self.assertTrue(bezier.closed)
def test_zero_values(self):
self.assert_path(
"M 10,10 L 90,90 0,0",
[NVector(10, 10), NVector(90, 90),
NVector(0, 0)],
[NVector(0, 0), NVector(0, 0),
NVector(0, 0)],
[NVector(0, 0), NVector(0, 0),
NVector(0, 0)],
)
def _check_layer_region(self, layer):
self.assertIsInstance(layer, api.RegionLayer)
self.assert_strong_equal(layer.type, "region")
self.assertIsInstance(layer.bline, api.Bline)
self.assertEqual(len(layer.bline.points), 3)
self.assert_strong_equal(layer.bline.loop, True)
point = layer.bline.points[0]
self.assertIsInstance(point, api.BlinePoint)
self.assert_strong_equal(point.point.value, NVector(-0.7645721436, 0.4090138674))
self.assert_strong_equal(point.width.value, 1.)
self.assert_strong_equal(point.origin.value, 0.5)
self.assert_strong_equal(point.split.value, False)
self.assert_strong_equal(point.split_radius.value, False)
self.assert_strong_equal(point.split_angle.value, False)
self.assert_strong_equal(point.t1.radius.value, 1.7138580473)
self.assert_strong_equal(point.t1.theta.value, 53.468349)
self.assert_strong_equal(point.t2.radius.value, 1.7138580473)
self.assert_strong_equal(point.t2.theta.value, 53.468349)
point = layer.bline.points[1]
self.assertIsInstance(point, api.BlinePoint)
self.assert_strong_equal(point.point.value, NVector(0.7732625604, -0.0648742691))
self.assertIsInstance(point.t1.radius, ast.SifAnimated)
self.assertEqual(len(point.t1.radius.keyframes), 2)
kf = point.t1.radius.keyframes[0]
self.assertIsInstance(kf, api.SifKeyframe)
self.assert_strong_equal(kf.time, api.FrameTime(0, api.FrameTime.Unit.Seconds))
self.assert_strong_equal(kf.before, ast.Interpolation.Clamped)
self.assert_strong_equal(kf.after, ast.Interpolation.Clamped)
self.assert_strong_equal(kf.value, 2.2314351749)
kf = point.t1.radius.keyframes[1]
self.assertIsInstance(kf, api.SifKeyframe)
self.assert_strong_equal(kf.time, api.FrameTime(2, api.FrameTime.Unit.Seconds))
self.assert_strong_equal(kf.before, ast.Interpolation.Clamped)
self.assert_strong_equal(kf.after, ast.Interpolation.Clamped)
self.assert_strong_equal(kf.value, 2.6981012388)
kf = point.t1.theta.keyframes[0]
self.assertIsInstance(kf, api.SifKeyframe)
self.assert_strong_equal(kf.time, api.FrameTime(0, api.FrameTime.Unit.Seconds))
self.assert_strong_equal(kf.before, ast.Interpolation.Clamped)
self.assert_strong_equal(kf.after, ast.Interpolation.Clamped)
self.assert_strong_equal(kf.value, 19.593754)
kf = point.t1.theta.keyframes[1]
self.assertIsInstance(kf, api.SifKeyframe)
self.assert_strong_equal(kf.time, api.FrameTime(2, api.FrameTime.Unit.Seconds))
self.assert_strong_equal(kf.before, ast.Interpolation.Clamped)
self.assert_strong_equal(kf.after, ast.Interpolation.Clamped)
self.assert_strong_equal(kf.value, -57.534264)
def test_group_opacity(self):
lot = objects.Animation()
ref_sl = lot.add_layer(objects.ShapeLayer())
ref_rect = ref_sl.add_shape(objects.Rect())
ref_rect.position.value = NVector(128, 128)
ref_rect.size.value = NVector(256, 256)
ref_sl.add_shape(objects.Fill(Color(1, 0, 0)))
ref_sl.transform.opacity.value = 80
sif = builder.to_sif(lot)
self.assertEqual(len(sif.layers), 1)
self.assertIsInstance(sif.layers[0], api.GroupLayer)
self.assertAlmostEqual(sif.layers[0].amount.value, 0.8)
def _check_layer_text(self, layer):
self.assertIsInstance(layer, api.TextLayer)
self.assert_strong_equal(layer.type, "text")
self.assert_strong_equal(layer.desc, "Foobar")
self.assert_strong_equal(layer.text.value, "Foobar")
self.assert_strong_equal(layer.family.value, "Sans Serif")
self.assert_strong_equal(layer.style.value, api.FontStyle.Normal)
self.assert_strong_equal(layer.weight.value, 400)
self.assert_strong_equal(layer.compress.value, 1.)
self.assert_strong_equal(layer.size.value, NVector(1., 1.))
self.assert_strong_equal(layer.orient.value, NVector(.5, .5))
self.assert_strong_equal(layer.origin.value, NVector(0.9813190699, -2.9089243412))
self.assert_strong_equal(layer.use_kerning.value, True)
self.assert_strong_equal(layer.grid_fit.value, False)
def test_star_hidden(self):
lot = objects.Animation()
sl = lot.add_layer(objects.ShapeLayer())
star = sl.add_shape(objects.Star())
star.hidden = True
star.name = "Star"
star.rotation.value = 20
star.inner_radius.value = 64
star.outer_radius.value = 128
star.position.value = NVector(256, 256)
sl.add_shape(objects.Fill(Color(1, 1, 0)))
sif = builder.to_sif(lot)
self.assertEqual(len(sif.layers), 1)
self.assertIsInstance(sif.layers[0], api.GroupLayer)
grp = sif.layers[0]
self.assertEqual(len(grp.layers), 1)
self.assertIsInstance(grp.layers[0], api.RegionLayer)
self.assertTrue(grp.active)
rgl = grp.layers[0]
self.assertEqual(rgl.desc, "Star")
self.assertEqual(len(rgl.bline.points), 10)
self.assert_nvector_equal(rgl.origin.value, star.position.value)
self.assert_nvector_equal(rgl.color.value, sif.make_color(1, 1, 0, 1))
self.assertFalse(rgl.active)
class SifAstBoneInfluence(SifAstComplex):
_tag = "boneinfluence"
_nodes = [
# TODO bone_weight_list
XmlAnimatable("link", "vector", NVector(0, 0)),
]
def value_from_xml_string(xml_str, type, registry):
if type in (bool_str, bool):
return str_to_bool(xml_str)
elif type is NVector:
return NVector(*map(float, xml_str.split()))
if type is FrameTime:
return FrameTime.parse_string(xml_str, registry)
return type(xml_str)
def test_bezier(self):
lot = objects.Animation()
sl = lot.add_layer(objects.ShapeLayer())
shape = sl.add_shape(objects.Path())
sl.add_shape(objects.Fill(Color(0, .25, 1)))
shape.shape.value.closed = True
shape.shape.value.add_point(NVector(256, 0))
shape.shape.value.add_point(NVector(256+128, 256), NVector(0, 0), NVector(64, 128))
shape.shape.value.add_smooth_point(NVector(256, 512), NVector(128, 0))
shape.shape.value.add_point(NVector(256-128, 256), NVector(-64, 128), NVector(0, 0))
sif = builder.to_sif(lot)
self.assertEqual(len(sif.layers), 1)
self.assertIsInstance(sif.layers[0], api.GroupLayer)
grp = sif.layers[0]
self.assertEqual(len(grp.layers), 1)
self.assertIsInstance(grp.layers[0], api.RegionLayer)
self.assertTrue(grp.active)
rgl = grp.layers[0]
self.assertEqual(len(rgl.bline.points), 4)
self.assert_nvector_equal(rgl.color.value, sif.make_color(0, .25, 1))
self.assertTrue(rgl.active)
self.assertTrue(rgl.bline.loop)
for i in range(len(rgl.bline.points)):
sp = rgl.bline.points[i]
lp = shape.shape.value.vertices[i] - NVector(256, 256)
self.assert_nvector_equal(
sp.point.value, lp,
msg="Point %s mismatch %s != %s" % (i, sp.point.value, lp)
)
lt1 = shape.shape.value.in_tangents[i] * -3
self.assert_nvector_equal(
sp.t1.value, lt1,
msg="In Tangent %s mismatch %s != %s" % (i, sp.t1.value, lt1)
)
lt2 = shape.shape.value.out_tangents[i] * 3
self.assert_nvector_equal(
sp.t2.value, lt2,
msg="Out Tangent %s mismatch %s != %s" % (i, sp.t2.value, lt2)
)
def test_load_noanim(self):
md = objects.MultiDimensional.load({
"a": 0,
"k": [1, 2],
})
self.assertIs(md.animated, False)
self.assertIsNone(md.keyframes)
self.assertEqual(md.value, NVector(1, 2))
class SifDynamic(SifAstComplex):
_tag = "dynamic"
_nodes = [
XmlAnimatable("tip_static", "vector", NVector(0, 0)),
XmlAnimatable("origin", "vector", NVector(0, 0)),
XmlAnimatable("force", "vector", NVector(0, 0)),
XmlAnimatable("torque", "real", 0.),
XmlAnimatable("damping", "real", 0.4),
XmlAnimatable("friction", "real", 0.4),
XmlAnimatable("spring", "real", 30.),
XmlAnimatable("torsion", "real", 30.),
XmlAnimatable("mass", "real", 0.3),
XmlAnimatable("inertia", "real", 0.3),
XmlAnimatable("spring_rigid", "bool", False),
XmlAnimatable("torsion_rigid", "bool", False),
XmlAnimatable("origin_drags_tip", "bool", True),
]
def value_from_xml_element(self, xml: minidom.Element, registry: ObjectRegistry):
if xml.tagName != self.tag_name:
raise ValueError("Wrong value type (%s instead of %s)" % (xml.tagName, self.tag_name))
guid = xml.getAttribute("guid")
if guid and guid in registry.registry:
value = registry.registry[guid]
elif self.typename == "vector":
value = NVector(
float(xml_text(xml.getElementsByTagName("x")[0])),
float(xml_text(xml.getElementsByTagName("y")[0]))
)
if xml.getAttribute("guid"):
value.guid = xml.getAttribute("guid")
registry.register(value)
elif self.typename == "color":
value = NVector(
float(xml_text(xml.getElementsByTagName("r")[0])),
float(xml_text(xml.getElementsByTagName("g")[0])),
float(xml_text(xml.getElementsByTagName("b")[0])),
float(xml_text(xml.getElementsByTagName("a")[0]))
)
elif self.typename == "gradient":
value = [
GradientPoint.from_dom(sub, registry)
for sub in xml_child_elements(xml, GradientPoint.type.typename)
]
elif self.typename == "real" or self.typename == "angle":
value = float(xml.getAttribute("value"))
elif self.typename == "integer":
value = int(xml.getAttribute("value"))
elif self.typename == "time":
value = FrameTime.parse_string(xml.getAttribute("value"), registry)
elif self.typename == "bool":
value = str_to_bool(xml.getAttribute("value"))
elif self.typename == "string":
return xml_text(xml)
elif self.typename == "bone_object":
# Already done above but this forces the guid to be present
return registry.get_object(xml.getAttribute("guid"))
else:
raise ValueError("Unsupported type %s" % self.typename)
return self.type_wrapper(value)
def test_cubic_rel(self):
self.assert_path(
"""
M 10,90
c 20,0 15,-80 40,-80
s 20,80 40,80
""",
[NVector(10, 90),
NVector(50, 10),
NVector(90, 90)],
[NVector(0, 0), NVector(-25, 0),
NVector(-20, 0)],
[NVector(20, 0), NVector(25, 0),
NVector(0, 0)],
)
def test_cubic_abs(self):
self.assert_path(
"""
M 10,90
C 30,90 25,10 50,10
S 70,90 90,90
""",
[NVector(10, 90),
NVector(50, 10),
NVector(90, 90)],
[NVector(0, 0), NVector(-25, 0),
NVector(-20, 0)],
[NVector(20, 0), NVector(25, 0),
NVector(0, 0)],
)
def test_get_value_anim(self):
md = objects.MultiDimensional(NVector(0, 0))
md.add_keyframe(0, NVector(1, 2))
md.add_keyframe(3, NVector(4, 5))
self.assertEqual(md.get_value(), NVector(1, 2))
self.assertEqual(md.get_value(0), NVector(1, 2))
self.assertEqual(md.get_value(3), NVector(4, 5))
self.assertEqual(md.get_value(4), NVector(4, 5))
def test_get_value_anim_nonestart(self):
md = objects.MultiDimensional(NVector(0, 0))
md.add_keyframe(0, NVector(1, 2))
md.add_keyframe(3, NVector(4, 5))
md.keyframes[-1].start = None # bodymovin exports them like this
self.assertEqual(md.get_value(), NVector(1, 2))
self.assertEqual(md.get_value(0), NVector(1, 2))
self.assertEqual(md.get_value(3), NVector(4, 5))
self.assertEqual(md.get_value(4), NVector(4, 5))
def _check_canvas(self, canvas):
self.assertIsInstance(canvas, api.Canvas)
self.assertEqual(len(canvas.layers), 8)
self.assert_strong_equal(canvas.version, "1.2")
self.assert_strong_equal(canvas.width, 512.)
self.assert_strong_equal(canvas.height, 512.)
self.assert_strong_equal(canvas.xres, 2834.645752)
self.assert_strong_equal(canvas.yres, 2834.645752)
self.assert_strong_equal(canvas.gamma_r, 2.2)
self.assert_strong_equal(canvas.gamma_g, 2.2)
self.assert_strong_equal(canvas.gamma_b, 2.2)
self.assert_strong_equal(canvas.view_box, NVector(-4.266667, 4.266667, 4.266667, -4.266667))
self.assert_strong_equal(canvas.antialias, True)
self.assert_strong_equal(canvas.fps, 60.)
self.assert_strong_equal(canvas.begin_time, api.FrameTime(0, api.FrameTime.Unit.Frame))
self.assert_strong_equal(canvas.end_time, api.FrameTime(3., api.FrameTime.Unit.Seconds))
self.assert_strong_equal(canvas.bgcolor, NVector(.5, .5, .5, 1.))
self.assertEqual(len(canvas.keyframes), 1)
kf = canvas.keyframes[0]
self.assert_strong_equal(kf.time, api.FrameTime.frame(0))
self.assert_strong_equal(kf.active, True)
class SifAstBoneLink(SifAstComplex):
_tag = "bone_link"
_nodes = [
XmlBoneReference("bone"),
XmlAnimatable("base_value", "vector", NVector(0, 0)),
XmlAnimatable("translate", "bool", True),
XmlAnimatable("rotate", "bool", True),
XmlAnimatable("skew", "bool", True),
XmlAnimatable("scale_x", "bool", True),
XmlAnimatable("scale_y", "bool", True),
]
