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); } }