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), ]