/// <summary>
/// Draws a polygon.
/// </summary>
/// <param name="bounds">The bounds.</param>
/// <param name="points">The points.</param>
/// <param name="style">The style.</param>
public void DrawPolygon(Rect bounds, Point[] points, DrawingStyle style)
{
_canvas.ApplyTransform(style.Transform, style.TransformOrigin, bounds);
var pp = points.Select(x => x.ToSKPoint()).ToArray();
SKPath path = new SKPath();
path.AddPoly(pp, true);
path.Offset(bounds.Left.ToFloat(), bounds.Top.ToFloat());
if (style.HasFill)
{
SKPaint paintFill = new SKPaint();
paintFill.ApplyFill(bounds, style);
_canvas.DrawPath(path, paintFill);
}
if (style.HasStroke)
{
SKPaint paintStroke = new SKPaint();
paintStroke.ApplyStroke(bounds, style);
_canvas.DrawPath(path, paintStroke);
}
_canvas.ResetMatrix();
}
private void drawBiomes(SKCanvas canvas)
{
var chains = map5Biomes.Paths;
var paint = new SKPaint()
{
IsAntialias = true
};
paint.Style = SKPaintStyle.Fill;
chains.forEach((d, i) =>
{
if (d == null)
{
return;
}
paint.Color = biomesData.color[i].ToColor().SK();
//d.forEach(pp => canvas.DrawPath(curvePath(pp), paint));
var path = new SKPath();
d.forEach(pp => path.AddPoly(pp));
canvas.DrawPath(path, paint);
});
}
public override SKPath Render(SKCanvas g, Rectangle r, NodeStyle o)
{
var skPath = new SKPath();
var skPoints = new SKPoint[]
{
r.CenterTop().ToSKPoint(),
r.CenterRight().ToSKPoint(),
r.CenterBottom().ToSKPoint(),
r.CenterLeft().ToSKPoint()
};
skPath.AddPoly(skPoints);
using (var p = new SKPaint()
{
IsAntialias = true
})
{
p.Color = new Pen(o.BackBrush).Color.ToSKColor();
g.DrawPath(skPath, p);
p.IsStroke = true;
p.Color = o.BorderPen.Color.ToSKColor();
p.StrokeWidth = o.BorderPen.Width;
g.DrawPath(skPath, p);
}
return(skPath);
}
public override void FillPolygon(Brush brush, Point[] points, FillMode fillMode)
{
var path = new SKPath();
path.AddPoly(points.Select(a => new SKPoint(a.X, a.Y)).ToArray());
_image.DrawPath(path, brush.SKPaint());
}
public void DrawPolygon(Pen penn, PointF[] list)
{
var path = new SKPath();
path.AddPoly(list.Select(a => new SKPoint(a.X, a.Y)).ToArray());
_image.DrawPath(path, penn.SKPaint());
}
public void JoinPoints()
{
if (Related == null)
{
return;
}
using (var path = new SKPath())
{
path.AddPoly(new SKPoint[] { Related.Value, Value });
var currentColors = new SKColor[]
{
Related.Paint.Color,
Paint.Color
};
var paint = new SKPaint
{
Style = SKPaintStyle.Stroke,
StrokeWidth = 5,
Shader = SKShader.CreateLinearGradient(Related.Value, Value,
currentColors,
null, SKShaderTileMode.Clamp),
MaskFilter = Paint.MaskFilter
};
canvas.DrawPath(path, paint);
}
}
public SKPath GetPath()
{
var path = new SKPath();//FillMode.Alternate
path.AddPoly(GetPoints());
return(path);
}
private void OnPaintSurface(object sender, SKPaintSurfaceEventArgs e)
{
var canvas = e.Surface.Canvas;
canvas.Clear();
foreach (var gline in _lastLines)
{
var paint = new SKPaint
{
Color = _colorCache[gline.Color],
IsStroke = true,
};
var p0 = new SKPoint(gline.Point1.X, gline.Point1.Y);
var p1 = new SKPoint(gline.Point2.X, gline.Point2.Y);
canvas.DrawLine(p0, p1, paint);
}
foreach (var gpoly in _lastPolygons)
{
var paint = new SKPaint
{
Color = _colorCache[gpoly.Color],
IsStroke = true,
};
var path = new SKPath();
path.AddPoly(gpoly.Points.Select(p => new SKPoint(p.X, p.Y)).ToArray());
canvas.DrawPath(path, paint);
}
}
protected override void OnSizeAllocated(double width, double height)
{
if (width > 0)
{
width = height;
WidthRequest = height;
//Add points to paths
path.Reset();
path.AddPoly(mPoints, false);
//Move to centre origin to make rotations correct
var rect_inital = GetRectangle(path.Points);
(var xshft, var yshft) = GetMinimumPoint(path.Points);
path.Offset(-xshft, -yshft);
path.Offset(-rect_inital.Width / 2, -rect_inital.Height / 2);
//Rotate by 45 degrees
path.Transform(SKMatrix.MakeRotationDegrees(OffsetAngle));
//Offset to zero
//Scale to fill
var rect_scale = GetRectangle(path.Points);
(xshft, yshft) = GetMinimumPoint(path.Points);
path.Offset(-rect_scale.Left, -rect_scale.Top);
var xscale = (float)Width * Scale / rect_scale.Width;
var yscale = (float)Height * Scale / rect_scale.Height;
path.Transform(SKMatrix.MakeScale(xscale, yscale));
path.Offset((float)Width * Scale / 2, (float)Height * Scale / 2);
base.OnSizeAllocated(width, height);
}
}
static void RenderQuads(VoxelData voxelData, int size, SKCanvas canvas, MeshSettings settings)
{
var matrix = GetMatrix(voxelData, size);
settings.MeshType = MeshType.Quads;
var quads = new MeshBuilder(voxelData, settings);
var vertices = quads.Vertices
.Select(v => matrix.MapScalars(v.X, v.Z, -v.Y, 1f))
.Select(v => new SKPoint(v[0], v[1]))
.ToArray();
var indices = quads.Faces;
for (var i = 0; i < indices.Length; i += 4)
{
using (var path = new SKPath()) {
var quad = Enumerable.Range(0, 4)
.Select(n => vertices[indices[i + n]])
.ToArray();
path.AddPoly(quad, close: true);
var color = quads.Colors[quads.Faces[i]]; // Take 1st vertex color for face
using (var fill = new SKPaint()
{
Color = ToSKColor(color)
}) {
canvas.DrawPath(path, fill);
}
}
}
}
public void FillPolygon(Brush brushh, PointF[] list)
{
var path = new SKPath();
path.AddPoly(list.Select(a => new SKPoint(a.X, a.Y)).ToArray());
_image.DrawPath(path, brushh.SKPaint());
}
private static void DrawAxisX(SKCanvas cr, float lineWidth)
{
var linePaint = new SKPaint()
{
Color = SKColors.Black,
StrokeWidth = lineWidth,
Style = SKPaintStyle.StrokeAndFill,
IsAntialias = true
};
float width = cr.LocalClipBounds.Width;
SKPoint[] arrowPoints = new SKPoint[]
{
new SKPoint(width, 0),
new SKPoint(width - 6 * lineWidth, -3 * lineWidth),
new SKPoint(width - 6 * lineWidth, 3 * lineWidth),
};
SKPath arrowPath = new SKPath();
arrowPath.AddPoly(arrowPoints, true);
cr.DrawLine(0, 0, width - 6f * linePaint.StrokeWidth, 0, linePaint);
cr.DrawPath(arrowPath, linePaint);
}
public override void DrawPolygon(Pen pen, PointF[] points)
{
var path = new SKPath();
path.AddPoly(points.Select(a => new SKPoint(a.X, a.Y)).ToArray());
_image.DrawPath(path, pen.SKPaint());
}
void PaintRedBar(object sender, SKPaintSurfaceEventArgs args)
{
SKImageInfo info = args.Info;
SKSurface surface = args.Surface;
SKCanvas canvas = surface.Canvas;
canvas.Clear();
SKPath path = new SKPath
{
FillType = SKPathFillType.EvenOdd
};
path.AddPoly(new SKPoint[] { new SKPoint(0, 0), new SKPoint(info.Width, 8), new SKPoint(0, 8) });
SKPaint paint = new SKPaint()
{
Style = SKPaintStyle.Fill,
Color = new SKColor(0xFF922610)
};
canvas.DrawPath(path, paint);
paint.Dispose();
path.Dispose();
//paint.Style = SKPaintStyle.Stroke;
//paint.StrokeWidth = 2;
//paint.Color = SKColors.Black;
//canvas.DrawPath(path, paint);
}
public override void MoveTo(SKRect newBox)
{
var oldBox = Box;
if (oldBox.Width != newBox.Width ||
oldBox.Height != newBox.Height)
{
Appearance.Normal[null] = null;
}
//base.MoveTo(newBox);
var dif = SKMatrix.MakeIdentity();
SKMatrix.PreConcat(ref dif, SKMatrix.MakeTranslation(newBox.MidX, newBox.MidY));
SKMatrix.PreConcat(ref dif, SKMatrix.MakeScale(newBox.Width / oldBox.Width, newBox.Height / oldBox.Height));
SKMatrix.PreConcat(ref dif, SKMatrix.MakeTranslation(-oldBox.MidX, -oldBox.MidY));
var oldPaths = Paths;
var newPaths = new List <SKPath>();
foreach (var path in oldPaths)
{
var vertices = path.Points;
for (int i = 0; i < vertices.Length; i++)
{
vertices[i] = dif.MapPoint(vertices[i]);
}
var newPath = new SKPath();
newPath.AddPoly(vertices, false);
newPaths.Add(newPath);
}
Paths = newPaths;
foreach (var oldPath in oldPaths)
{
oldPath.Dispose();
}
}
void OnCanvasViewPaintSurface(object sender, SKPaintSurfaceEventArgs args)
{
SKImageInfo info = args.Info;
SKSurface surface = args.Surface;
SKCanvas canvas = surface.Canvas;
canvas.Clear(SKColors.Black);
// Width and height of catenary
int width = info.Width;
float height = info.Height - linkRadius;
// Find the optimum 'a' for this width and height
float optA = FindOptimumA(width, height);
// Calculate the vertical offset for that value of 'a'
float yOffset = catenary(optA, -width / 2);
// Create a path for the catenary
SKPoint[] points = new SKPoint[width];
for (int x = 0; x < width; x++)
{
points[x] = new SKPoint(x, yOffset - catenary(optA, x - width / 2));
}
using (SKPath path = new SKPath())
{
path.AddPoly(points, false);
// And render that path with the linksPaint object
canvas.DrawPath(path, linksPaint);
}
}
public void SetClip(GraphicsPath path)
{
var skpath = new SKPath();
skpath.AddPoly(path.PathPoints.Select(a => new SKPoint(a.X, a.Y)).ToArray());
_image.ClipPath(skpath);
}
private void OnCropImage(object sender, EventArgs e)
{
using var cropPath = new SKPath();
cropPath.AddPoly(cropPoints.ToArray());
// add a little padding all round
var bounds = SKRectI.Ceiling(cropPath.TightBounds);
bounds.Inflate(4, 4);
var info = new SKImageInfo(bounds.Width, bounds.Height);
using var surface = SKSurface.Create(info);
var canvas = surface.Canvas;
canvas.Clear(SKColors.Transparent);
canvas.Translate(-bounds.Left, -bounds.Top);
canvas.ClipPath(cropPath);
canvas.DrawImage(pickedImage, 0, 0);
var image = surface.Snapshot();
Navigation.PushAsync(new PreviewPage(image));
}
public static SKPath linePoly(IEnumerable <SKPoint> pp, bool close)
{
var d = new SKPath();
d.AddPoly(pp.ToArray(), close);
return(d);
}
public void DrawPolygon(IPolygon polygon)
{
SKPath skPath = new SKPath();
skPath.FillType = FillRuleToSkiaPathFillType(polygon.FillRule);
skPath.AddPoly(PointsToSkiaPoints(polygon.Points), close: true);
DrawShapePath(skPath, polygon);
}
public override void CalculateRenderProperties()
{
var path = new SKPath();
path.AddPoly(RenderPoints.ToArray());
RenderPath = path;
RenderRectangle = path.GetRect();
}
public void DrawPolyline(IPolyline polyline)
{
SKPath skPath = new SKPath();
skPath.FillType = FillRuleToSkiaPathFillType(polyline.FillRule);
skPath.AddPoly(PointsToSkiaPoints(polyline.Points), close: false);
DrawShapePath(skPath, polyline);
}
private void AddPathSegmentToSkiaPath(SKPath skPath, IPathSegment pathSegment)
{
if (pathSegment is IBezierSegment bezierSegment)
{
skPath.CubicTo(
(float)bezierSegment.Point1.X, (float)bezierSegment.Point1.Y,
(float)bezierSegment.Point2.X, (float)bezierSegment.Point2.Y,
(float)bezierSegment.Point3.X, (float)bezierSegment.Point3.Y);
}
else if (pathSegment is IPolyBezierSegment polyBezierSegment)
{
List <Point> points = new List <Point>();
foreach (Point point in polyBezierSegment.Points)
{
points.Add(point);
}
if (points.Count % 3 != 0)
{
throw new InvalidOperationException($"IPolyBezerSegment contains {points.Count} points, which isn't a multiple of 3");
}
for (int i = 0; i < points.Count;)
{
var point1 = points[i + 0];
var point2 = points[i + 1];
var point3 = points[i + 2];
skPath.CubicTo(
(float)point1.X, (float)point1.Y,
(float)point2.X, (float)point2.Y,
(float)point3.X, (float)point3.Y);
i += 3;
}
}
else if (pathSegment is ILineSegment lineSegment)
{
skPath.LineTo((float)lineSegment.Point.X, (float)lineSegment.Point.Y);
}
else if (pathSegment is IQuadraticBezierSegment quadraticBezierSegment)
{
skPath.QuadTo(
(float)quadraticBezierSegment.Point1.X, (float)quadraticBezierSegment.Point1.Y,
(float)quadraticBezierSegment.Point2.X, (float)quadraticBezierSegment.Point2.Y);
}
else if (pathSegment is IPolyLineSegment polyLineSegment)
{
var skiaPoints = new List <SKPoint>();
AddSkiaPoints(polyLineSegment.Points, skiaPoints);
skPath.AddPoly(skiaPoints.ToArray());
}
else
{
throw new InvalidOperationException($"IPathSegment type {pathSegment.GetType()} not yet implemented");
}
}
public void FillPolygon(Brush brushh, PointF[] list)
{
var path = new SKPath();
path.AddPoly(list.Select(a => new SKPoint(a.X, a.Y)).ToArray());
if (path.Bounds.Width == 0 || path.Bounds.Height == 0)
{
return;
}
_image.DrawPath(path, brushh.ToSKPaint());
}
public void FillPolygon(Brush brush, Point[] points, FillMode fillMode)
{
var path = new SKPath();
path.AddPoly(points.Select(a => new SKPoint(a.X, a.Y)).ToArray());
if (path.Bounds.Width == 0 || path.Bounds.Height == 0)
{
return;
}
_image.DrawPath(path, brush.ToSKPaint());
}
public void DrawPolygon(Pen pen, PointF[] points)
{
var path = new SKPath();
path.AddPoly(points.Select(a => new SKPoint(a.X, a.Y)).ToArray());
if (path.Bounds.Width == 0 || path.Bounds.Height == 0)
{
return;
}
_image.DrawPath(path, pen.ToSKPaint());
}
public void DrawPolyline(IPolyline polyline)
{
#if LATER
SKPath skPath = new SKPath();
skPath.FillType = FillRuleToSkiaPathFillType(polyline.FillRule);
skPath.AddPoly(PointsToSkiaPoints(polyline.Points), close: false);
DrawShapePath(skPath, polyline);
#endif
throw new NotImplementedException("TODO: Implement DrawPolyline for WinUI");
}
private (string, SKPath) LabelPath(float scale, SKSize dimension)
{
var txt = SIPrefix.ToString(Value);
(var pt1, var pt2) = LabelLine(scale, dimension, txt);
var pts = new SKPoint[] { pt1, pt2 };
var pth = new SKPath();
pth.AddPoly(pts, false);
return(txt, pth);
}
public void draw(SKCanvas canvas)
{
this.paint.TextAlign = this.alignment;
if (this.textPath == null)
{
textPath = new SKPath();
textPath.AddPoly(new SKPoint[] { new SKPoint(0, this.fontMetrics.CapHeight), new SKPoint(this.width, this.fontMetrics.CapHeight) }, false);
}
canvas.DrawTextOnPath(source, textPath, 0, 0, this.paint);
}
private static void DrawCollisionLayer(SKCanvas canvas, TmxLayer tmxLayer, SKColor polyColor, SKColor lineColor)
{
LayerClipper.TransformPointFunc xfFunc = (x, y) => new ClipperLib.IntPoint(x, y);
LayerClipper.ProgressFunc progFunc = (prog) => { }; // do nothing
ClipperLib.PolyTree solution = LayerClipper.ExecuteClipper(tmxLayer.TmxMap, tmxLayer, xfFunc, progFunc);
using (SKPaint paint = new SKPaint())
{
// Draw all closed polygons
// First, add them to the path
// (But are we using convex polygons are complex polygons?
using (SKPath path = new SKPath())
{
var polygons = tmxLayer.IsExportingConvexPolygons() ? LayerClipper.SolutionPolygons_Simple(solution) : LayerClipper.SolutionPolygons_Complex(solution);
foreach (var pointfArray in polygons)
{
var pts = pointfArray.ToSkPointArray();
path.AddPoly(pts, true);
}
// Then, fill and draw the path full of polygons
if (path.PointCount > 0)
{
paint.Style = SKPaintStyle.Fill;
paint.Color = polyColor;
canvas.DrawPath(path, paint);
paint.Style = SKPaintStyle.Stroke;
paint.StrokeWidth = StrokeWidthThick;
paint.Color = lineColor;
canvas.DrawPath(path, paint);
}
}
// Draw all lines (open polygons)
using (SKPath path = new SKPath())
{
foreach (var points in ClipperLib.Clipper.OpenPathsFromPolyTree(solution))
{
var pts = points.Select(pt => new SKPoint(pt.X, pt.Y)).ToArray();
path.AddPoly(pts, false);
}
if (path.PointCount > 0)
{
paint.Style = SKPaintStyle.Stroke;
paint.StrokeWidth = StrokeWidthThick;
paint.Color = lineColor;
canvas.DrawPath(path, paint);
}
}
}
}
