internal CompositionLayer(LottieDrawable lottieDrawable, Layer layerModel, List <Layer> layerModels, LottieComposition composition) : base(lottieDrawable, layerModel) { var timeRemapping = layerModel.TimeRemapping; if (timeRemapping != null) { _timeRemapping = timeRemapping.CreateAnimation(); AddAnimation(_timeRemapping); _timeRemapping.ValueChanged += OnValueChanged; } else { _timeRemapping = null; } var layerMap = new Dictionary <long, BaseLayer>(composition.Layers.Count); BaseLayer mattedLayer = null; for (var i = layerModels.Count - 1; i >= 0; i--) { var lm = layerModels[i]; var layer = ForModel(lm, lottieDrawable, composition); if (layer == null) { continue; } layerMap.Add(layer.LayerModel.Id, layer); if (mattedLayer != null) { mattedLayer.MatteLayer = layer; mattedLayer = null; } else { _layers.Insert(0, layer); switch (lm.GetMatteType()) { case Layer.MatteType.Add: case Layer.MatteType.Invert: mattedLayer = layer; break; } } } foreach (var layer in layerMap) { var layerView = layer.Value; if (layerMap.TryGetValue(layerView.LayerModel.ParentId, out BaseLayer parentLayer)) { layerView.ParentLayer = parentLayer; } } }
internal EllipseContent(LottieDrawable lottieDrawable, BaseLayer layer, CircleShape circleShape) { Name = circleShape.Name; _lottieDrawable = lottieDrawable; _sizeAnimation = circleShape.Size.CreateAnimation(); _positionAnimation = circleShape.Position.CreateAnimation(); layer.AddAnimation(_sizeAnimation); layer.AddAnimation(_positionAnimation); _sizeAnimation.ValueChanged += OnValueChanged; _positionAnimation.ValueChanged += OnValueChanged; }
internal BaseStrokeContent(LottieDrawable lottieDrawable, BaseLayer layer, PenLineCap cap, PenLineJoin join, AnimatableIntegerValue opacity, AnimatableFloatValue width, IList <AnimatableFloatValue> dashPattern, AnimatableFloatValue offset) { _lottieDrawable = lottieDrawable; Paint.Style = Paint.PaintStyle.Stroke; Paint.StrokeCap = cap; Paint.StrokeJoin = join; _opacityAnimation = opacity.CreateAnimation(); _widthAnimation = width.CreateAnimation(); if (offset == null) { _dashPatternOffsetAnimation = null; } else { _dashPatternOffsetAnimation = offset.CreateAnimation(); } _dashPatternAnimations = new List <IBaseKeyframeAnimation <float?> >(dashPattern.Count); _dashPatternValues = new double[dashPattern.Count]; for (var i = 0; i < dashPattern.Count; i++) { _dashPatternAnimations.Add(dashPattern[i].CreateAnimation()); } layer.AddAnimation(_opacityAnimation); layer.AddAnimation(_widthAnimation); for (var i = 0; i < _dashPatternAnimations.Count; i++) { layer.AddAnimation(_dashPatternAnimations[i]); } if (_dashPatternOffsetAnimation != null) { layer.AddAnimation(_dashPatternOffsetAnimation); } _opacityAnimation.ValueChanged += OnValueChanged; _widthAnimation.ValueChanged += OnValueChanged; for (var i = 0; i < dashPattern.Count; i++) { _dashPatternAnimations[i].ValueChanged += OnValueChanged; } if (_dashPatternOffsetAnimation != null) { _dashPatternOffsetAnimation.ValueChanged += OnValueChanged; } }
private static List <IContent> ContentsFromModels(LottieDrawable drawable, BaseLayer layer, List <IContentModel> contentModels) { var contents = new List <IContent>(contentModels.Count); for (var i = 0; i < contentModels.Count; i++) { var content = contentModels[i].ToContent(drawable, layer); if (content != null) { contents.Add(content); } } return(contents); }
internal RectangleContent(LottieDrawable lottieDrawable, BaseLayer layer, RectangleShape rectShape) { Name = rectShape.Name; _lottieDrawable = lottieDrawable; _positionAnimation = rectShape.Position.CreateAnimation(); _sizeAnimation = rectShape.Size.CreateAnimation(); _cornerRadiusAnimation = rectShape.CornerRadius.CreateAnimation(); layer.AddAnimation(_positionAnimation); layer.AddAnimation(_sizeAnimation); layer.AddAnimation(_cornerRadiusAnimation); _positionAnimation.ValueChanged += OnValueChanged; _sizeAnimation.ValueChanged += OnValueChanged; _cornerRadiusAnimation.ValueChanged += OnValueChanged; }
internal RepeaterContent(LottieDrawable lottieDrawable, BaseLayer layer, Repeater repeater) { _lottieDrawable = lottieDrawable; _layer = layer; Name = repeater.Name; _copies = repeater.Copies.CreateAnimation(); layer.AddAnimation(_copies); _copies.ValueChanged += OnValueChanged; _offset = repeater.Offset.CreateAnimation(); layer.AddAnimation(_offset); _offset.ValueChanged += OnValueChanged; _transform = repeater.Transform.CreateAnimation(); _transform.AddAnimationsToLayer(layer); _transform.ValueChanged += OnValueChanged; }
internal GradientStrokeContent(LottieDrawable lottieDrawable, BaseLayer layer, GradientStroke stroke) : base(lottieDrawable, layer, ShapeStroke.LineCapTypeToPaintCap(stroke.CapType), ShapeStroke.LineJoinTypeToPaintLineJoin(stroke.JoinType), stroke.Opacity, stroke.Width, stroke.LineDashPattern, stroke.DashOffset) { Name = stroke.Name; _type = stroke.GradientType; _cacheSteps = (int)(lottieDrawable.Composition.Duration / CacheStepsMs); _colorAnimation = (KeyframeAnimation <GradientColor>)stroke.GradientColor.CreateAnimation(); _colorAnimation.ValueChanged += OnValueChanged; layer.AddAnimation(_colorAnimation); _startPointAnimation = (KeyframeAnimation <PointF>)stroke.StartPoint.CreateAnimation(); _startPointAnimation.ValueChanged += OnValueChanged; layer.AddAnimation(_startPointAnimation); _endPointAnimation = (KeyframeAnimation <PointF>)stroke.EndPoint.CreateAnimation(); _endPointAnimation.ValueChanged += OnValueChanged; layer.AddAnimation(_endPointAnimation); }
internal PolystarContent(LottieDrawable lottieDrawable, BaseLayer layer, PolystarShape polystarShape) { _lottieDrawable = lottieDrawable; Name = polystarShape.Name; _type = polystarShape.GetType(); _pointsAnimation = polystarShape.Points.CreateAnimation(); _positionAnimation = polystarShape.Position.CreateAnimation(); _rotationAnimation = polystarShape.Rotation.CreateAnimation(); _outerRadiusAnimation = polystarShape.OuterRadius.CreateAnimation(); _outerRoundednessAnimation = polystarShape.OuterRoundedness.CreateAnimation(); if (_type == PolystarShape.Type.Star) { _innerRadiusAnimation = polystarShape.InnerRadius.CreateAnimation(); _innerRoundednessAnimation = polystarShape.InnerRoundedness.CreateAnimation(); } else { _innerRadiusAnimation = null; _innerRoundednessAnimation = null; } layer.AddAnimation(_pointsAnimation); layer.AddAnimation(_positionAnimation); layer.AddAnimation(_rotationAnimation); layer.AddAnimation(_outerRadiusAnimation); layer.AddAnimation(_outerRoundednessAnimation); if (_type == PolystarShape.Type.Star) { layer.AddAnimation(_innerRadiusAnimation); layer.AddAnimation(_innerRoundednessAnimation); } _pointsAnimation.ValueChanged += OnValueChanged; _positionAnimation.ValueChanged += OnValueChanged; _rotationAnimation.ValueChanged += OnValueChanged; _outerRadiusAnimation.ValueChanged += OnValueChanged; _outerRoundednessAnimation.ValueChanged += OnValueChanged; if (_type == PolystarShape.Type.Star) { _outerRadiusAnimation.ValueChanged += OnValueChanged; _outerRoundednessAnimation.ValueChanged += OnValueChanged; } }
internal TextLayer(LottieDrawable lottieDrawable, Layer layerModel) : base(lottieDrawable, layerModel) { _lottieDrawable = lottieDrawable; _composition = layerModel.Composition; _textAnimation = layerModel.Text.CreateAnimation(); _textAnimation.ValueChanged += OnValueChanged; AddAnimation(_textAnimation); var textProperties = layerModel.TextProperties; if (textProperties?._color != null) { _colorAnimation = textProperties._color.CreateAnimation(); _colorAnimation.ValueChanged += OnValueChanged; AddAnimation(_colorAnimation); } if (textProperties?._stroke != null) { _strokeAnimation = textProperties._stroke.CreateAnimation(); _strokeAnimation.ValueChanged += OnValueChanged; AddAnimation(_strokeAnimation); } if (textProperties?._strokeWidth != null) { _strokeWidthAnimation = textProperties._strokeWidth.CreateAnimation(); _strokeWidthAnimation.ValueChanged += OnValueChanged; AddAnimation(_strokeWidthAnimation); } if (textProperties?._tracking != null) { _trackingAnimation = textProperties._tracking.CreateAnimation(); _trackingAnimation.ValueChanged += OnValueChanged; AddAnimation(_trackingAnimation); } }
internal GradientFillContent(LottieDrawable lottieDrawable, BaseLayer layer, GradientFill fill) { Name = fill.Name; _lottieDrawable = lottieDrawable; _type = fill.GradientType; _path.FillType = fill.FillType; _cacheSteps = (int)(lottieDrawable.Composition.Duration / CacheStepsMs); _colorAnimation = (KeyframeAnimation <GradientColor>)fill.GradientColor.CreateAnimation(); _colorAnimation.ValueChanged += OnValueChanged; layer.AddAnimation(_colorAnimation); _opacityAnimation = (KeyframeAnimation <int?>)fill.Opacity.CreateAnimation(); _opacityAnimation.ValueChanged += OnValueChanged; layer.AddAnimation(_opacityAnimation); _startPointAnimation = (KeyframeAnimation <PointF>)fill.StartPoint.CreateAnimation(); _startPointAnimation.ValueChanged += OnValueChanged; layer.AddAnimation(_startPointAnimation); _endPointAnimation = (KeyframeAnimation <PointF>)fill.EndPoint.CreateAnimation(); _endPointAnimation.ValueChanged += OnValueChanged; layer.AddAnimation(_endPointAnimation); }
internal BaseLayer(LottieDrawable lottieDrawable, Layer layerModel) { LottieDrawable = lottieDrawable; LayerModel = layerModel; _drawTraceName = layerModel.Name + ".Draw"; _clearPaint.Xfermode = new PorterDuffXfermode(PorterDuff.Mode.Clear); _maskPaint.Xfermode = new PorterDuffXfermode(PorterDuff.Mode.DstIn); if (layerModel.GetMatteType() == Layer.MatteType.Invert) { _mattePaint.Xfermode = new PorterDuffXfermode(PorterDuff.Mode.DstOut); } else { _mattePaint.Xfermode = new PorterDuffXfermode(PorterDuff.Mode.DstIn); } Transform = layerModel.Transform.CreateAnimation(); Transform.ValueChanged += OnValueChanged; Transform.AddAnimationsToLayer(this); if (layerModel.Masks != null && layerModel.Masks.Count > 0) { _mask = new MaskKeyframeAnimation(layerModel.Masks); foreach (var animation in _mask.MaskAnimations) { AddAnimation(animation); animation.ValueChanged += OnValueChanged; } foreach (var animation in _mask.OpacityAnimations) { AddAnimation(animation); animation.ValueChanged += OnValueChanged; } } SetupInOutAnimations(); }
public IContent ToContent(LottieDrawable drawable, BaseLayer layer) { return(new TrimPathContent(layer, this)); }
public IContent ToContent(LottieDrawable drawable, BaseLayer layer) { return(new StrokeContent(drawable, layer, this)); }
internal ImageLayer(LottieDrawable lottieDrawable, Layer layerModel, float density) : base(lottieDrawable, layerModel) { _density = density; }
/// <summary> /// This normally needs to be able to invalidate the view/drawable but not for the test. /// </summary> internal TextDelegate() { _animationView = null; _drawable = null; }
public TextDelegate(LottieAnimationView animationView) { _animationView = animationView; _drawable = null; }
public IContent ToContent(LottieDrawable drawable, BaseLayer layer) { return(new GradientFillContent(drawable, layer, this)); }
public TextDelegate(LottieDrawable drawable) { _drawable = drawable; _animationView = null; }
internal ContentGroup(LottieDrawable lottieDrawable, BaseLayer layer, ShapeGroup shapeGroup) : this(lottieDrawable, layer, shapeGroup.Name, ContentsFromModels(lottieDrawable, layer, shapeGroup.Items), FindTransform(shapeGroup.Items)) { }
public IContent ToContent(LottieDrawable drawable, BaseLayer layer) { return(null); }
internal NullLayer(LottieDrawable lottieDrawable, Layer layerModel) : base(lottieDrawable, layerModel) { }
public IContent ToContent(LottieDrawable drawable, BaseLayer layer) { return(new ContentGroup(drawable, layer, this)); }
internal ContentGroup(LottieDrawable lottieDrawable, BaseLayer layer, ShapeGroup shapeGroup) { Name = shapeGroup.Name; var items = shapeGroup.Items; if (items.Count == 0) { return; } if (items[items.Count - 1] is AnimatableTransform animatableTransform) { _transformAnimation = animatableTransform.CreateAnimation(); _transformAnimation.AddAnimationsToLayer(layer); _transformAnimation.ValueChanged += (sender, args) => { lottieDrawable.InvalidateSelf(); }; } for (var i = 0; i < items.Count; i++) { var item = items[i]; if (item is ShapeFill) { _contents.Add(new FillContent(lottieDrawable, layer, (ShapeFill)item)); } else if (item is GradientFill) { _contents.Add(new GradientFillContent(lottieDrawable, layer, (GradientFill)item)); } else if (item is ShapeStroke) { _contents.Add(new StrokeContent(lottieDrawable, layer, (ShapeStroke)item)); } else if (item is GradientStroke) { _contents.Add(new GradientStrokeContent(lottieDrawable, layer, (GradientStroke)item)); } else if (item is ShapeGroup) { _contents.Add(new ContentGroup(lottieDrawable, layer, (ShapeGroup)item)); } else if (item is RectangleShape) { _contents.Add(new RectangleContent(lottieDrawable, layer, (RectangleShape)item)); } else if (item is CircleShape) { _contents.Add(new EllipseContent(lottieDrawable, layer, (CircleShape)item)); } else if (item is ShapePath) { _contents.Add(new ShapeContent(lottieDrawable, layer, (ShapePath)item)); } else if (item is PolystarShape) { _contents.Add(new PolystarContent(lottieDrawable, layer, (PolystarShape)item)); } else if (item is ShapeTrimPath) { _contents.Add(new TrimPathContent(layer, (ShapeTrimPath)item)); } else { if (item is MergePaths mergePaths) { if (lottieDrawable.EnableMergePathsForKitKatAndAbove()) { _contents.Add(new MergePathsContent(mergePaths)); } else { Debug.WriteLine("Animation contains merge paths but they are disabled.", Tag); } } } } IList <IContent> contentsToRemove = new List <IContent>(); MergePathsContent currentMergePathsContent = null; for (var i = _contents.Count - 1; i >= 0; i--) { var content = _contents[i]; if (content is MergePathsContent mergePathsContent) { currentMergePathsContent = mergePathsContent; } if (currentMergePathsContent != null && content != currentMergePathsContent) { currentMergePathsContent.AddContentIfNeeded(content); contentsToRemove.Add(content); } } for (var i = _contents.Count - 1; i >= 0; i--) { if (contentsToRemove.Contains(_contents[i])) { _contents.RemoveAt(i); } } }