public override void DrawLayer(BitmapCanvas canvas, Matrix3X3 parentMatrix, byte parentAlpha)
{
LottieLog.BeginSection("CompositionLayer.Draw");
canvas.GetClipBounds(out _originalClipRect);
RectExt.Set(ref _newClipRect, 0, 0, LayerModel.PreCompWidth, LayerModel.PreCompHeight);
parentMatrix.MapRect(ref _newClipRect);
for (var i = _layers.Count - 1; i >= 0; i--)
{
var nonEmptyClip = true;
if (!_newClipRect.IsEmpty)
{
nonEmptyClip = canvas.ClipRect(_newClipRect);
}
if (nonEmptyClip)
{
var layer = _layers[i];
layer.Draw(canvas, parentMatrix, parentAlpha);
}
}
if (!_originalClipRect.IsEmpty)
{
canvas.ClipReplaceRect(_originalClipRect);
}
LottieLog.EndSection("CompositionLayer.Draw");
}
public void TestReset()
{
BitmapCanvas canvas = new BitmapCanvas(360, 360, new BackgroundDrawer(360, 360, back_ground));
int wait_count = TestConvas(canvas, -180, 180, -180, 180);
Console.WriteLine("360 * 360, wait_count:\t" + wait_count.ToString());
canvas = new BitmapCanvas(361, 361, new BackgroundDrawer(361, 361, back_ground));
wait_count = TestConvas(canvas, -180, 181, -180, 181);
Console.WriteLine("361 * 361, wait_count:\t" + wait_count.ToString());
canvas = new BitmapCanvas(360, 361, new BackgroundDrawer(360, 361, back_ground));
wait_count = TestConvas(canvas, -180, 180, -180, 181);
Console.WriteLine("360 * 361, wait_count:\t" + wait_count.ToString());
canvas = new BitmapCanvas(720, 720, new BackgroundDrawer(720, 720, back_ground));
wait_count = TestConvas(canvas, -360, 360, -360, 360);
Console.WriteLine("720 * 720, wait_count:\t" + wait_count.ToString());
canvas = new BitmapCanvas(360, 720, new BackgroundDrawer(360, 720, back_ground));
wait_count = TestConvas(canvas, -180, 180, -360, 360);
Console.WriteLine("360 * 720, wait_count:\t" + wait_count.ToString());
}
public override IBrush Apply(BitmapCanvas dst, IBrush brush)
{
//var originalColor = Colors.White;
//if (brush is CompositionColorBrush compositionColorBrush)
// originalColor = compositionColorBrush.Color;
//TODO: passthrough the color filters for now.
return(brush);
}
public override Brush Apply(BitmapCanvas dst, Brush brush)
{
//var originalColor = Colors.White;
//if (brush is CompositionColorBrush compositionColorBrush)
// originalColor = compositionColorBrush.Color;
//TODO
return(brush);
}
private Rect DrawCharacterFromFont(char c, DocumentData documentData, BitmapCanvas canvas)
{
if (documentData.StrokeOverFill)
{
DrawCharacter(c, _fillPaint, canvas);
return(DrawCharacter(c, _strokePaint, canvas));
}
DrawCharacter(c, _strokePaint, canvas);
return(DrawCharacter(c, _fillPaint, canvas));
}
private Bitmap CreateBitmap()
{
// ouput size for QR bill only: 210 x 110mm
bill.Format.OutputSize = OutputSize.QrBillExtraSpace;
const int dpi = 192;
using BitmapCanvas canvas = new BitmapCanvas((int)Math.Round(210 / 25.4 * dpi),
(int)Math.Round(110 / 25.4 * dpi), dpi, "Arial");
QRBill.Draw(bill, canvas);
return(canvas.ToBitmap());
}
private Rect?DrawCharacter(char character, Paint paint, BitmapCanvas canvas)
{
if (paint.Color == Colors.Transparent)
{
return(null);
}
if (paint.Style == Paint.PaintStyle.Stroke && paint.StrokeWidth == 0)
{
return(null);
}
return(canvas.DrawText(character, paint));
}
private void DrawGlyph(Path path, Paint paint, BitmapCanvas canvas)
{
if (paint.Color == Colors.Transparent)
{
return;
}
if (paint.Style == Paint.PaintStyle.Stroke && paint.StrokeWidth == 0)
{
return;
}
canvas.DrawPath(path, paint);
}
private Rect?DrawCharacterFromFont(char c, DocumentData documentData, BitmapCanvas canvas)
{
Rect?ret;
if (documentData.StrokeOverFill)
{
ret = DrawCharacter(c, _fillPaint, canvas);
return(DrawCharacter(c, _strokePaint, canvas) ?? ret);
}
ret = DrawCharacter(c, _strokePaint, canvas);
return(DrawCharacter(c, _fillPaint, canvas) ?? ret);
}
private int TestConvas(BitmapCanvas canvas, int min_x, int sup_x, int min_y, int sup_y)
{
int wait_count = 0;
while (!canvas.IsReady)
{
wait_count++;
Thread.Yield();
}
for (int i = min_x; i < sup_x; i++)
{
Assert.AreEqual(back_ground, canvas[i, min_y]);
Assert.AreEqual(back_ground, canvas[i, sup_y - 1]);
Assert.AreEqual(default(Color), canvas[i, min_y - 1]);
Assert.AreEqual(default(Color), canvas[i, sup_y]);
}
for (int i = min_y; i < sup_y; i++)
{
Assert.AreEqual(back_ground, canvas[min_x, i]);
Assert.AreEqual(back_ground, canvas[sup_x - 1, i]);
Assert.AreEqual(default(Color), canvas[min_x - 1, i]);
Assert.AreEqual(default(Color), canvas[sup_x, i]);
}
for (int i = 0; i < CHANGE_TIMES; i++)
{
int x = rnd.Next(min_x, sup_x);
int y = rnd.Next(min_y, sup_y);
Color old = canvas[x, y];
Color new_color = old.Equals(back_ground) ? point : back_ground;
canvas[x, y] = new_color;
Assert.AreEqual(new_color, canvas[x, y]);
}
Bitmap out1 = canvas.Output();
while (!canvas.IsReady)
{
wait_count++;
Thread.Yield();
}
out1.Dispose();
for (int x = min_x; x < sup_x; x++)
{
for (int y = min_y; y < sup_y; y++)
{
Assert.AreEqual(canvas[x, y], back_ground);
}
}
return(wait_count);
}
public override void DrawLayer(BitmapCanvas canvas, Matrix3X3 parentMatrix, byte parentAlpha)
{
var bitmap = Bitmap;
if (bitmap == null)
{
return;
}
_paint.Alpha = parentAlpha;
canvas.Save();
canvas.Concat(parentMatrix);
RectExt.Set(ref _src, 0, 0, PixelWidth, PixelHeight);
RectExt.Set(ref _dst, 0, 0, (int)(PixelWidth * _density), (int)(PixelHeight * _density));
canvas.DrawBitmap(bitmap, _src, _dst, _paint);
canvas.Restore();
}
public override void DrawLayer(BitmapCanvas canvas, Matrix3X3 parentMatrix, byte parentAlpha)
{
canvas.Save();
if (!_lottieDrawable.UseTextGlyphs())
{
canvas.SetMatrix(parentMatrix);
}
var documentData = _textAnimation.Value;
if (!_composition.Fonts.TryGetValue(documentData.FontName, out var font))
{
// Something is wrong.
canvas.Restore();
return;
}
_fillPaint.Color = _colorAnimation?.Value ?? documentData.Color;
_strokePaint.Color = _strokeColorAnimation?.Value ?? documentData.StrokeColor;
var alpha = (byte)(Transform.Opacity.Value * 255 / 100f);
_fillPaint.Alpha = alpha;
_strokePaint.Alpha = alpha;
if (_strokeWidthAnimation?.Value != null)
{
_strokePaint.StrokeWidth = _strokeWidthAnimation.Value.Value;
}
else
{
var parentScale = Utils.Utils.GetScale(parentMatrix);
_strokePaint.StrokeWidth = documentData.StrokeWidth * Utils.Utils.DpScale() * parentScale;
}
if (_lottieDrawable.UseTextGlyphs())
{
DrawTextGlyphs(documentData, parentMatrix, font, canvas);
}
else
{
DrawTextWithFont(documentData, font, parentMatrix, canvas);
}
canvas.Restore();
}
public override void DrawLayer(BitmapCanvas canvas, Matrix3X3 parentMatrix, byte parentAlpha)
{
int backgroundAlpha = LayerModel.SolidColor.A;
if (backgroundAlpha == 0)
{
return;
}
var alpha = (byte)(parentAlpha / 255f * (backgroundAlpha / 255f * Transform.Opacity.Value / 100f) * 255);
_paint.Alpha = alpha;
if (alpha > 0)
{
UpdateRect(parentMatrix);
canvas.DrawRect(Rect, _paint);
}
}
public override void DrawLayer(BitmapCanvas canvas, Matrix3X3 parentMatrix, byte parentAlpha)
{
var bitmap = Bitmap;
if (bitmap == null)
{
return;
}
var density = Utils.Utils.DpScale();
_paint.Alpha = parentAlpha;
if (_colorFilterAnimation != null)
{
_paint.ColorFilter = _colorFilterAnimation.Value;
}
canvas.Save();
canvas.Concat(parentMatrix);
RectExt.Set(ref _src, 0, 0, PixelWidth, PixelHeight);
RectExt.Set(ref _dst, 0, 0, (int)(PixelWidth * density), (int)(PixelHeight * density));
canvas.DrawBitmap(bitmap, _src, _dst, _paint);
canvas.Restore();
}
public override void DrawLayer(BitmapCanvas canvas, Matrix3X3 parentMatrix, byte parentAlpha)
{
int backgroundAlpha = LayerModel.SolidColor.A;
if (backgroundAlpha == 0)
{
return;
}
var alpha = (byte)(parentAlpha / 255f * (backgroundAlpha / 255f * Transform.Opacity.Value / 100f) * 255);
_paint.Alpha = alpha;
if (_colorFilterAnimation != null)
{
_paint.ColorFilter = _colorFilterAnimation.Value;
}
if (alpha > 0)
{
_points[0] = new Vector2(0, 0);
_points[1] = new Vector2(LayerModel.SolidWidth, 0);
_points[2] = new Vector2(LayerModel.SolidWidth, LayerModel.SolidHeight);
_points[3] = new Vector2(0, LayerModel.SolidHeight);
// We can't map RectangleF here because if there is rotation on the transform then we aren't
// actually drawing a rect.
parentMatrix.MapPoints(ref _points);
_path.Reset();
_path.MoveTo(_points[0].X, _points[0].Y);
_path.LineTo(_points[1].X, _points[1].Y);
_path.LineTo(_points[2].X, _points[2].Y);
_path.LineTo(_points[3].X, _points[3].Y);
_path.LineTo(_points[0].X, _points[0].Y);
_path.Close();
canvas.DrawPath(_path, _paint);
}
}
public override IBrush Apply(BitmapCanvas dst, IBrush brush)
{
// TODO: Passthrough color filter for now
return(brush);
}
private void RefreshCanvas()
{
Bitmap bitmap = new Bitmap(BitmapCanvas.Width, BitmapCanvas.Height);
using (Graphics g = Graphics.FromImage(bitmap))
{
if (IsPolylineVisible)
{
Pen cyan = new Pen(Color.Cyan);
for (int i = 0; i < PointCount - 1; i++)
{
g.DrawLine(cyan, ControlPoints[i].Point, ControlPoints[i + 1].Point);
}
}
foreach (Point p in Bezier)
{
if (p.X < bitmap.Width && p.Y < bitmap.Height && p.X > 0 && p.Y > 0)
{
bitmap.SetPixel(p.X, p.Y, Color.Black);
}
}
foreach (Vertex v in ControlPoints)
{
SolidBrush b = new SolidBrush(v.Color);
g.FillEllipse(b, v.X - v.Size / 2, v.Y - v.Size / 2, v.Size, v.Size);
}
if (State == States.Playing)
{
if (Animation == Animations.MovingOnCurve)
{
if (Rotation == Rotations.Naive)
{
Bitmap rotated = IsGrayscale ? Algorithms.Rotate(Tan, grayscaleImage) : Algorithms.Rotate(Tan, image);
Point p = new Point(Bezier[currentPoint].X - rotated.Width / 2, Bezier[currentPoint].Y - rotated.Height / 2);
g.DrawImage(rotated, p);
}
else
{
Point p = new Point(Bezier[currentPoint].X - image.Width / 2, Bezier[currentPoint].Y - image.Height / 2);
if (IsGrayscale)
{
g.DrawImage(grayscaleImage, p);
}
else
{
g.DrawImage(image, p);
}
}
}
else if (Animation == Animations.Rotation)
{
if (Rotation == Rotations.Naive)
{
Bitmap rotated = IsGrayscale ? Algorithms.Rotate(Degree, grayscaleImage) : Algorithms.Rotate(Degree, image);
Point p = new Point(Bezier[currentPoint].X - rotated.Width / 2, Bezier[currentPoint].Y - rotated.Height / 2);
g.DrawImage(rotated, p);
}
}
}
Bitmap old = (Bitmap)BitmapCanvas.Image;
BitmapCanvas.Image = bitmap;
old.Dispose();
BitmapCanvas.Refresh();
}
}
public override void DrawLayer(BitmapCanvas canvas, Matrix3X3 parentMatrix, byte parentAlpha)
{
_contentGroup.Draw(canvas, parentMatrix, parentAlpha);
}
public override void DrawLayer(BitmapCanvas canvas, Matrix3X3 parentMatrix, byte parentAlpha)
{
// Do nothing.
}
private Rect DrawCharacter(char character, Paint paint, BitmapCanvas canvas)
{
return(canvas.DrawText(character, paint));
}
public abstract IBrush Apply(BitmapCanvas dst, IBrush brush);
private void DrawTextGlyphs(DocumentData documentData, Matrix3X3 parentMatrix, Font font, BitmapCanvas canvas)
{
var fontScale = (float)documentData.Size / 100;
var parentScale = Utils.Utils.GetScale(parentMatrix);
var text = documentData.Text;
for (var i = 0; i < text.Length; i++)
{
var c = text[i];
var characterHash = FontCharacter.HashFor(c, font.Family, font.Style);
if (!_composition.Characters.TryGetValue(characterHash, out var character))
{
// Something is wrong. Potentially, they didn't export the text as a glyph.
continue;
}
DrawCharacterAsGlyph(character, parentMatrix, fontScale, documentData, canvas);
var tx = (float)character.Width * fontScale * Utils.Utils.DpScale() * parentScale;
// Add tracking
var tracking = documentData.Tracking / 10f;
if (_trackingAnimation?.Value != null)
{
tracking += _trackingAnimation.Value.Value;
}
tx += tracking * parentScale;
canvas.Translate(tx, 0);
}
}
private void DrawCharacterAsGlyph(FontCharacter character, Matrix3X3 parentMatrix, float fontScale, DocumentData documentData, BitmapCanvas canvas)
{
var contentGroups = GetContentsForCharacter(character);
for (var j = 0; j < contentGroups.Count; j++)
{
var path = contentGroups[j].Path;
//path.ComputeBounds(out _rectF);
Matrix.Set(parentMatrix);
Matrix = MatrixExt.PreTranslate(Matrix, 0, (float)-documentData.BaselineShift * Utils.Utils.DpScale());
Matrix = MatrixExt.PreScale(Matrix, fontScale, fontScale);
path.Transform(Matrix);
if (documentData.StrokeOverFill)
{
DrawGlyph(path, _fillPaint, canvas);
DrawGlyph(path, _strokePaint, canvas);
}
else
{
DrawGlyph(path, _strokePaint, canvas);
DrawGlyph(path, _fillPaint, canvas);
}
}
}
private void DrawTextWithFont(DocumentData documentData, Font font, Matrix3X3 parentMatrix, BitmapCanvas canvas)
{
var parentScale = Utils.Utils.GetScale(parentMatrix);
var typeface = _lottieDrawable.GetTypeface(font.Family, font.Style);
if (typeface == null)
{
return;
}
var text = documentData.Text;
var textDelegate = _lottieDrawable.TextDelegate;
if (textDelegate != null)
{
text = textDelegate.GetTextInternal(text);
}
_fillPaint.Typeface = typeface;
_fillPaint.TextSize = (float)documentData.Size * Utils.Utils.DpScale();
_strokePaint.Typeface = _fillPaint.Typeface;
_strokePaint.TextSize = _fillPaint.TextSize;
for (var i = 0; i < text.Length; i++)
{
var character = text[i];
var size = DrawCharacterFromFont(character, documentData, canvas);
// Add tracking
var tracking = documentData.Tracking / 10f;
if (_trackingAnimation?.Value != null)
{
tracking += _trackingAnimation.Value.Value;
}
var tx = (float)(size?.Width ?? 0) + tracking * parentScale;
canvas.Translate(tx, 0);
}
}
