protected override void OnDrawSample(SKCanvas canvas, int width, int height)
{
canvas.Translate(width / 2, height / 2);
var length = Math.Min(width / 6, height / 6);
var rect = new SKRect(-length, -length, length, length);
var side = rotation > 90 && rotation < 270;
canvas.Clear(SampleMedia.Colors.XamarinLightBlue);
var view = new SK3dView();
view.RotateYDegrees(rotation);
view.ApplyToCanvas(canvas);
var paint = new SKPaint
{
Color = side ? SampleMedia.Colors.XamarinPurple : SampleMedia.Colors.XamarinGreen,
Style = SKPaintStyle.Fill,
IsAntialias = true
};
canvas.DrawRoundRect(rect, 30, 30, paint);
var shadow = SKShader.CreateLinearGradient(
new SKPoint(0, 0), new SKPoint(0, length * 2),
new[] { paint.Color.WithAlpha(127), paint.Color.WithAlpha(0) },
null,
SKShaderTileMode.Clamp);
paint = new SKPaint
{
Shader = shadow,
Style = SKPaintStyle.Fill,
IsAntialias = true
};
rect.Offset(0, length * 2 + 5);
canvas.DrawRoundRect(rect, 30, 30, paint);
}
private void DrawBase(SKCanvas canvas, float radius)
{
canvas.Save();
_paint.Style = SKPaintStyle.Fill;
_paint.Shader = SKShader.CreateLinearGradient(new SKPoint(-radius.Scale(1.2f), radius.Scale(1.2f)),
new SKPoint(radius.Scale(1.2f), -radius.Scale(1.2f)),
BackgroundColor.ToBaseGradientColors(IsEnabled),
new float[] { 0f, 0.6f, 1f },
SKShaderTileMode.Clamp);
_paint.ImageFilter = null;
canvas.DrawCircle(0, 0, radius.Scale(0.95f), _paint);
DrawStroke(radius);
canvas.DrawCircle(0, 0, radius.Scale(0.95f), _paint);
canvas.Restore();
}
void OnCanvasViewPaintSurface(object sender, SKPaintSurfaceEventArgs args)
{
SKImageInfo info = args.Info;
SKSurface surface = args.Surface;
SKCanvas canvas = surface.Canvas;
canvas.Clear();
using (SKPaint paint = new SKPaint())
{
// Create 300-pixel square centered rectangle
float x = (info.Width - 300) / 2;
float y = (info.Height - 300) / 2;
SKRect rect = new SKRect(x, y, x + 300, y + 300);
// Create linear gradient from upper-left to lower-right
paint.Shader = SKShader.CreateLinearGradient(
new SKPoint(rect.Left, rect.Top),
new SKPoint(rect.Right, rect.Bottom),
new SKColor[] { SKColors.Red, SKColors.Blue },
new float[] { 0, 1 },
SKShaderTileMode.Repeat);
// Draw the gradient on the rectangle
canvas.DrawRect(rect, paint);
if (drawBackground)
{
// Draw the gradient on the whole canvas
canvas.DrawRect(info.Rect, paint);
// Outline the smaller rectangle
paint.Shader = null;
paint.Style = SKPaintStyle.Stroke;
paint.Color = SKColors.Black;
canvas.DrawRect(rect, paint);
}
}
}
private SKRect DrawBrokenClouds(SKCanvas canvas, int height, int width)
{
using (var paint = new SKPaint {
IsAntialias = true
})
{
var path = SKPath.ParseSvgPathData(
"M 180,170 H 25" +
"A 35,35 0 0 1 60,92" +
"A 40,35 0 0 1 155,90" +
"A 40,35 0 0 1 180,170");
SKRect bounds;
path.GetTightBounds(out bounds);
paint.Shader = SKShader.CreateLinearGradient(
new SKPoint(0f, bounds.Top), new SKPoint(0f, bounds.Bottom),
new SKColor[] { SKColors.LightGray, SKColors.Gray, SKColors.DarkGray },
new float[] { 0, 0.7f, 1 },
SKShaderTileMode.Clamp);
DrawPath(canvas, path, bounds, height, width, paint, 0.8f, 0.8f, 1.1f);
}
return(DrawScatteredClouds(canvas, height, width, 0.8f, 1.25f, 0.9f));
}
private SKRect DrawScatteredClouds(SKCanvas canvas, int height, int width, float scale = 1, float xTranslateFactor = 1, float yTranslateFactor = 1)
{
using (var paint = new SKPaint {
IsAntialias = true
})
{
var path = SKPath.ParseSvgPathData(
"M 180,170 H 25" +
"A 35,35 0 0 1 60,92" +
"A 40,35 0 0 1 155,90" +
"A 40,35 0 0 1 180,170");
SKRect bounds;
path.GetTightBounds(out bounds);
paint.Shader = SKShader.CreateLinearGradient(
new SKPoint(0f, bounds.Top), new SKPoint(0f, bounds.Bottom),
new SKColor[] { SKColors.White, SKColors.WhiteSmoke, SKColors.LightGray, SKColors.White },
new float[] { 0, 0.5f, 0.7f, 1 },
SKShaderTileMode.Clamp);
DrawPath(canvas, path, bounds, height, width, paint, scale, xTranslateFactor, yTranslateFactor);
return(bounds);
}
}
private void DrawShadow(object sender, SKPaintSurfaceEventArgs args)
{
var canvas = args.Surface.Canvas;
int surfaceWidth = args.Info.Width;
int surfaceHeight = args.Info.Height;
canvas.Clear();
using (SKPaint paint = new SKPaint())
{
SKRect rect = new SKRect(0, 0, surfaceWidth, surfaceHeight);
paint.Shader = SKShader.CreateLinearGradient(
new SKPoint(rect.Left, rect.Top),
new SKPoint(rect.Left, rect.Bottom),
new SKColor[] { Color.Gray.ToSKColor(), Color.FromHex("55D3D3D3").ToSKColor() },
new float[] { 0, 1 },
SKShaderTileMode.Repeat);
canvas.DrawRect(rect, paint);
}
}
private void CanvasViewPaintSurface(object sender, SKPaintSurfaceEventArgs e)
{
SKImageInfo info = e.Info;
SKSurface surface = e.Surface;
SKCanvas canvas = surface.Canvas;
canvas.Clear();
using (var paint = new SKPaint())
{
var rect = new SKRect(0, 0, info.Width, info.Size.Height);
paint.Shader = SKShader.CreateLinearGradient(
new SKPoint(rect.Left, rect.MidY),
new SKPoint(rect.Right, rect.MidY),
new SKColor[] { SKColor.Parse("#ada49e"), SKColor.Parse("#7b726c") },
new float[] { 0, 1 },
SKShaderTileMode.Repeat);
canvas.DrawRect(rect, paint);
}
}
private void SKCanvasView_PaintSurface(object sender, SkiaSharp.Views.Forms.SKPaintSurfaceEventArgs e)
{
var w = (float)e.Info.Width / 2;
var h = (float)e.Info.Height / 2;
var r = w < h ? w : h;
var angle = 3.14159 * sliderAngle.Value / 180.0;
var len = new SKPoint((float)Math.Cos(angle) * r, (float)Math.Sin(angle) * r);
e.Surface.Canvas.Clear(SKColors.White);
using (var p = new SKPaint())
using (var shader = SKShader.CreateLinearGradient(
new SKPoint(w + len.X, h + len.Y),
new SKPoint(w - len.X, h - len.Y),
new[] { SKColors.Red, SKColors.Lime },
new[] { 0.0f, 1.0f },
SKShaderTileMode.Clamp))
{
p.Shader = shader;
e.Surface.Canvas.DrawCircle(w, h, r, p);
}
}
public void Render(RenderContext context)
{
var info = context.Info;
var orderedStops = _gradient.Stops.OrderBy(x => x.RenderOffset).ToArray();
var lastOffset = orderedStops.LastOrDefault()?.RenderOffset ?? 1;
var colors = orderedStops.Select(x => x.Color.ToSKColor()).ToArray();
var colorPos = orderedStops.Select(x => x.RenderOffset / lastOffset).ToArray();
var(startPoint, endPoint) = GetGradientPoints(info.Width, info.Height, _gradient.Angle, lastOffset);
var shader = SKShader.CreateLinearGradient(
startPoint,
endPoint,
colors,
colorPos,
_gradient.IsRepeating ? SKShaderTileMode.Repeat : SKShaderTileMode.Clamp);
context.Paint.Shader = shader;
context.Canvas.DrawRect(context.Info.Rect, context.Paint);
}
public void OnCanvasViewPaintSurface(object sender, SKPaintSurfaceEventArgs args)
{
SKImageInfo info = args.Info;
SKSurface surface = args.Surface;
SKCanvas canvas = surface.Canvas;
canvas.Clear();
using (SKPaint paint = new SKPaint())
{
SKColor SpideyBlueBckGrnd;
SKColor.TryParse("#020f1f", out SpideyBlueBckGrnd);
SKColor SpideyLightBlueBckGrnd;
SKColor.TryParse("#001c41", out SpideyLightBlueBckGrnd);
paint.Shader = SKShader.CreateLinearGradient(
new SKPoint(info.Rect.Top, info.Rect.Top),
new SKPoint(info.Rect.Bottom, info.Rect.Bottom),
new SKColor[] { SpideyBlueBckGrnd, SpideyLightBlueBckGrnd },
new float[] { 0, 0.60f },
SKShaderTileMode.Mirror);
canvas.DrawRect(info.Rect, paint);
}
}
public SKShader CreateShader(ILinearGradient gradient, DrawContext context)
{
var rect = context.RenderRect;
var line = new LinearGradientGeometry();
line.CalculateOffsets(gradient, context.RenderRect.Width, context.RenderRect.Height);
line.CalculateGeometry(gradient, rect.ToRectF());
var renderStops = GetRenderStops(gradient);
var colors = renderStops.Select(x => x.Color.ToSKColor()).ToArray();
var colorPos = renderStops.Select(x => x.RenderOffset).ToArray();
var startPoint = line.Start;
var endPoint = line.End;
if (gradient.IsRepeating)
{
var firstOffset = renderStops.FirstOrDefault()?.RenderOffset ?? 0;
var lastOffset = renderStops.LastOrDefault()?.RenderOffset ?? 1;
startPoint = line.GetColorPointAt(firstOffset);
endPoint = line.GetColorPointAt(lastOffset);
for (var i = 0; i < colorPos.Length; i++)
{
colorPos[i] = line.ScaleWithBias(colorPos[i], firstOffset, lastOffset, 0, 1);
}
}
var shader = SKShader.CreateLinearGradient(
startPoint.ToSKPoint(),
endPoint.ToSKPoint(),
colors,
colorPos,
gradient.IsRepeating ? SKShaderTileMode.Repeat : SKShaderTileMode.Clamp);
return(shader);
}
private void PaintPortraitBackground(SKPaintSurfaceEventArgs args)
{
SKImageInfo info = args.Info;
SKSurface surface = args.Surface;
SKCanvas canvas = surface.Canvas;
canvas.Clear();
using (SKPath path = new SKPath())
{
path.MoveTo(0, 0);
path.LineTo(0, info.Height * 0.37f);
path.CubicTo(info.Width * 0.14f, info.Height * 0.34f,
info.Width * 0.24f, info.Height * 0.26f,
info.Width * 0.45f, info.Height * 0.26f);
path.CubicTo(info.Width * 0.68f, info.Height * 0.26f,
info.Width * 0.83f, info.Height * 0.37f,
info.Width, info.Height * 0.4f);
path.LineTo(info.Width, 0);
path.Close();
using (SKPaint paint = new SKPaint())
{
paint.IsAntialias = true;
paint.Style = SKPaintStyle.Fill;
paint.Color = SKColor.Parse("#9b1d75");
paint.Shader = SKShader.CreateLinearGradient(
new SKPoint(0, info.Height * 0.54f),
new SKPoint(info.Width, 0),
new SKColor[] { Color.FromHex("#511694").ToSKColor(), Color.FromHex("#9b1d75").ToSKColor() },
new float[] { 0.18f, 1 },
SKShaderTileMode.Clamp);
canvas.DrawPath(path, paint);
}
}
}
public static SKPaint ToSKPaint(this Brush brush)
{
if (brush is SolidBrush)
{
lock (brushcache)
if (!brushcache.ContainsKey(((SolidBrush)brush).Color))
{
brushcache[((SolidBrush)brush).Color] = new SKPaint
{
Color = ((SolidBrush)brush).Color.ToSKColor(), IsAntialias = true,
Style = SKPaintStyle.Fill
}
}
;
return(brushcache[((SolidBrush)brush).Color]);
}
if (brush is LinearGradientBrush)
{
var lgb = (LinearGradientBrush)brush;
return(new SKPaint
{
IsAntialias = true,
Style = SKPaintStyle.Fill,
Shader = SKShader.CreateLinearGradient(new SKPoint(lgb.Rectangle.X, lgb.Rectangle.Y),
new SKPoint(lgb.Rectangle.X, lgb.Rectangle.Bottom),
new[]
{
((LinearGradientBrush)brush).LinearColors[0].ToSKColor(),
((LinearGradientBrush)brush).LinearColors[1].ToSKColor()
}
, null, SKShaderTileMode.Clamp, SKMatrix.MakeIdentity())
});
}
return(new SKPaint());
}
}
void OnCanvasViewPaintSurface(object sender, SKPaintSurfaceEventArgs args)
{
SKImageInfo info = args.Info;
SKSurface surface = args.Surface;
SKCanvas canvas = surface.Canvas;
canvas.Clear();
var colors = new SKColor[] { StartColor.ToSKColor(), EndColor.ToSKColor() };
SKPoint startPoint = new SKPoint(0, 0);
SKPoint endPoint = Horizontal ? new SKPoint(info.Width, 0) : new SKPoint(0, info.Height);
var shader = SKShader.CreateLinearGradient(startPoint, endPoint, colors, null, SKShaderTileMode.Clamp);
SKPaint paint = new SKPaint
{
Style = SKPaintStyle.Fill,
Shader = shader
};
canvas.DrawRect(new SKRect(0, 0, info.Width, info.Height), paint);
}
protected override SKPaint CreatePaint()
{
var paint = new SKPaint();
SKShaderTileMode tileMode = SKShaderTileMode.Clamp;
switch (WrapMode)
{
case WrapMode.Clamp:
tileMode = SKShaderTileMode.Clamp;
break;
case WrapMode.Tile:
tileMode = SKShaderTileMode.Repeat;
break;
case WrapMode.TileFlipX:
case WrapMode.TileFlipXY:
case WrapMode.TileFlipY:
tileMode = SKShaderTileMode.Mirror;
break;
}
if (_shader != null)
{
_shader.Dispose();
}
if (InterpolationColors == null)
{
_shader = SKShader.CreateLinearGradient(new SKPoint(_start.X, _start.Y), new SKPoint(_end.X, _end.Y), new [] { _colorStart, _colorEnd }, null, tileMode);
}
else
{
_shader = SKShader.CreateLinearGradient(new SKPoint(_start.X, _start.Y), new SKPoint(_end.X, _end.Y), InterpolationColors.Colors.Select(c => new SKColor(c.R, c.G, c.B, c.A)).ToArray(), InterpolationColors.Positions, tileMode);
}
paint.Shader = _shader;
return(paint);
}
private void DrawInnerGradient(SKCanvas canvas)
{
// gamma correction
var colors = Enumerable
.Range(0, InnerGradientSize)
.Select(x => 1f - x / (float)InnerGradientSize)
.Select(x => Math.Pow(x, 2f))
.Select(x => (byte)(x * 255))
.Select(x => InnerGradientColor.WithAlpha(x))
.ToArray();
using var fogPaint = new SKPaint
{
Shader = SKShader.CreateLinearGradient(
new SKPoint(0, 0),
new SKPoint(0, InnerGradientSize),
colors,
SKShaderTileMode.Clamp)
};
canvas.DrawRect(0, 0, Width, InnerGradientSize, fogPaint);
}
public void Render(RenderContext context)
{
var info = context.Info;
var orderedStops = _gradient.Stops.OrderBy(x => x.Offset).ToArray();
float computedOffset;
if (!_gradient.IsRepeating || orderedStops.LastOrDefault()?.Offset == null)
{
computedOffset = 1;
}
else
{
// Here the Pythagorean Theorem + Trigonometry is applied
// to figure out the length of the gradient, which is needed to accurately calculate the endPoint for the gradient.
// https://en.wikibooks.org/wiki/Trigonometry/The_Pythagorean_Theorem
var angleRad = ToRad(_gradient.Angle);
var computedLength = Math.Sqrt(Math.Pow(info.Width * Math.Cos(angleRad), 2) + Math.Pow(info.Height * Math.Sin(angleRad), 2));
computedOffset = (float)(orderedStops.LastOrDefault().Offset / computedLength);
}
var lastOffset = orderedStops.LastOrDefault()?.Offset ?? 1;
var colors = orderedStops.Select(x => x.Color.ToSKColor()).ToArray();
var colorPos = orderedStops.Select(x => x.Offset / lastOffset).ToArray();
var(startPoint, endPoint) = GetGradientPoints(info.Width, info.Height, _gradient.Angle, computedOffset);
var shader = SKShader.CreateLinearGradient(
startPoint,
endPoint,
colors,
colorPos,
_gradient.IsRepeating ? SKShaderTileMode.Repeat : SKShaderTileMode.Clamp);
context.Paint.Shader = shader;
context.Canvas.DrawRect(context.Info.Rect, context.Paint);
}
void OnCanvasViewPaintSurface(object sender, SKPaintSurfaceEventArgs args)
{
SKImageInfo info = args.Info;
SKSurface surface = args.Surface;
SKCanvas canvas = surface.Canvas;
canvas.Clear();
using (SKPaint paint = new SKPaint())
{
paint.Shader = SKShader.CreateLinearGradient(
new SKPoint(0, 0),
info.Width < info.Height ? new SKPoint(info.Width, 0) :
new SKPoint(0, info.Height),
new SKColor[] { SKColors.White, SKColors.Black },
null,
SKShaderTileMode.Mirror,
SKMatrix.MakeRotation((float)angle, info.Rect.MidX, info.Rect.MidY));
canvas.DrawRect(info.Rect, paint);
}
}
/// <inheritdoc cref="IDrawableTask{TDrawingContext}.InitializeTask(TDrawingContext)" />
public override void InitializeTask(SkiaSharpDrawingContext drawingContext)
{
if (skiaPaint == null)
{
skiaPaint = new SKPaint();
}
var size = GetDrawRectangleSize(drawingContext);
var start = new SKPoint(size.Location.X + _startPoint.X * size.Width, size.Location.Y + _startPoint.Y * size.Height);
var end = new SKPoint(size.Location.X + _endPoint.X * size.Width, size.Location.Y + _endPoint.Y * size.Height);
skiaPaint.Shader = SKShader.CreateLinearGradient(
start,
end,
_gradientStops,
_colorPos,
_tileMode);
skiaPaint.IsAntialias = IsAntialias;
skiaPaint.IsStroke = true;
skiaPaint.StrokeWidth = StrokeThickness;
skiaPaint.Style = IsStroke ? SKPaintStyle.Stroke : SKPaintStyle.Fill;
if (PathEffect != null)
{
PathEffect.CreateEffect(drawingContext);
skiaPaint.PathEffect = PathEffect.SKPathEffect;
}
if (ClipRectangle != RectangleF.Empty)
{
_ = drawingContext.Canvas.Save();
drawingContext.Canvas.ClipRect(new SKRect(ClipRectangle.X, ClipRectangle.Y, ClipRectangle.Width, ClipRectangle.Height));
_drawingContext = drawingContext;
}
drawingContext.Paint = skiaPaint;
drawingContext.PaintTask = this;
}
private void SKCanvasView_PaintSurface_1(object sender, SKPaintSurfaceEventArgs args)
{
SKImageInfo info = args.Info;
SKSurface surface = args.Surface;
SKCanvas canvas = surface.Canvas;
canvas.Clear();
using (SKPaint paint = new SKPaint())
{
SKRect rect = new SKRect(0, 0, info.Width, info.Height);
paint.Shader = SKShader.CreateLinearGradient(
new SKPoint(0, info.Height / 2),
new SKPoint(info.Width, info.Height / 2),
new SKColor[] { Color.FromHex("#9b1d75").ToSKColor(), Color.FromHex("#511694").ToSKColor() },
new float[] { 0.15f, 1 },
SKShaderTileMode.Clamp);
canvas.DrawRect(rect, paint);
}
}
void MostlyEmptyQuadrant(SKCanvas canvas, SKPaint paint, SKRect rect)
{
using (new SKAutoCanvasRestore(canvas))
{
canvas.ClipRect(rect, SKClipOperation.Intersect);
// Fill in the lines on the upper-left and lower-right
paint.Shader = null;
paint.Color = SKColors.Silver;
canvas.DrawLine(rect.Left - tileSize, rect.Top + tileSize,
rect.Left + tileSize, rect.Top - tileSize, paint);
canvas.DrawLine(rect.Right - tileSize, rect.Bottom + tileSize,
rect.Right + tileSize, rect.Bottom - tileSize, paint);
// Fill in the line on the lower-left
paint.Shader = SKShader.CreateLinearGradient(new SKPoint(rect.MidX, rect.MidY),
new SKPoint(rect.Left - rect.Width / 2, rect.Bottom + rect.Height / 2),
shadeGradientColors,
shadeGradientOffsets,
SKShaderTileMode.Clamp);
canvas.DrawLine(rect.Left - tileSize, rect.Bottom - tileSize,
rect.Left + tileSize, rect.Bottom + tileSize, paint);
// Fill in the line on the upper-right
paint.Shader = SKShader.CreateLinearGradient(new SKPoint(rect.Right + rect.Width / 2, rect.Top - rect.Height / 2),
new SKPoint(rect.MidX, rect.MidY),
shadeGradientColors,
shadeGradientOffsets,
SKShaderTileMode.Clamp);
canvas.DrawLine(rect.Right - tileSize, rect.Top - tileSize,
rect.Right + tileSize, rect.Top + tileSize, paint);
}
}
/// <inheritdoc />
public override void Render(SKCanvas canvas, SKRect bounds, SKPaint paint)
{
float waveSize = Properties.WaveSize / 100f;
SKMatrix matrix = SKMatrix.Concat(
SKMatrix.CreateRotationDegrees(Properties.Rotation, bounds.MidX, bounds.MidY),
SKMatrix.CreateScale(waveSize, waveSize, bounds.MidX, bounds.MidY)
);
matrix = SKMatrix.Concat(
matrix,
SKMatrix.CreateTranslation(_scrollX * bounds.Width, _scrollY * bounds.Height)
);
// LinearGradientRepeatMode.Mirror is currently the only setting that requires a different tile mode
SKShaderTileMode tileMode = Properties.RepeatMode.CurrentValue == LinearGradientRepeatMode.Mirror
? SKShaderTileMode.Mirror
: SKShaderTileMode.Repeat;
// Render gradient
ColorGradient gradient = Properties.Colors;
paint.Shader = SKShader.CreateLinearGradient(
new SKPoint(bounds.Left, bounds.Top),
new SKPoint(
Properties.Orientation == LinearGradientOrientationMode.Horizontal ? bounds.Right : bounds.Left,
Properties.Orientation == LinearGradientOrientationMode.Horizontal ? bounds.Top : bounds.Bottom
),
gradient.GetColorsArray(0, Properties.RepeatMode.CurrentValue == LinearGradientRepeatMode.RepeatSeamless),
gradient.GetPositionsArray(0, Properties.RepeatMode.CurrentValue == LinearGradientRepeatMode.RepeatSeamless),
tileMode,
matrix
);
canvas.DrawRect(bounds, paint);
paint.Shader?.Dispose();
paint.Shader = null;
}
private void DrawBackground(SKCanvas canvas)
{
using (var paint = new SKPaint())
{
paint.Style = SKPaintStyle.Fill;
paint.IsAntialias = true;
var pancake = Element as PancakeView;
SKPath path;
if (pancake.Sides != 4)
{
path = DrawingExtensions.CreatePolygonPath(Control.Geometry.Width, Control.Geometry.Height,
pancake.Sides, pancake.CornerRadius.TopLeft, pancake.OffsetAngle);
}
else
{
var left = Control.Geometry.Left - _skCanvasView.Geometry.Left;
var top = Control.Geometry.Top - _skCanvasView.Geometry.Top;
path = DrawingExtensions.CreateRoundedRectPath(left, top, left + Control.Geometry.Width, top + Control.Geometry.Height, pancake.CornerRadius);
}
if (pancake.BackgroundGradientStops != null && pancake.BackgroundGradientStops.Any())
{
var orderedStops = pancake.BackgroundGradientStops.OrderBy(x => x.Offset).ToList();
var gradientColors = orderedStops.Select(x => x.Color.ToNative().ToSKColor()).ToArray();
var gradientColorPos = orderedStops.Select(x => x.Offset).ToArray();
var startPoint = new SKPoint((float)(pancake.BackgroundGradientStartPoint.X * Control.Geometry.Width), (float)(pancake.BackgroundGradientStartPoint.Y * Control.Geometry.Height));
var endPoint = new SKPoint((float)(pancake.BackgroundGradientEndPoint.X * Control.Geometry.Width), (float)(pancake.BackgroundGradientEndPoint.Y * Control.Geometry.Height));
paint.Shader = SKShader.CreateLinearGradient(startPoint, endPoint, gradientColors, gradientColorPos, SKShaderTileMode.Clamp);
}
else
{
paint.Color = pancake.BackgroundColor.ToNative().ToSKColor();
}
canvas.ClipPath(path, SKClipOperation.Intersect, true);
canvas.DrawPath(path, paint);
}
}
public static SKShader ToSkiaShader(IGradientBrush gradientBrush, IUIElement uiElement)
{
SKShaderTileMode tileMode = gradientBrush.SpreadMethod switch
{
GradientSpreadMethod.Pad => SKShaderTileMode.Clamp,
GradientSpreadMethod.Reflect => SKShaderTileMode.Mirror,
GradientSpreadMethod.Repeat => SKShaderTileMode.Repeat,
_ => throw new InvalidOperationException($"Unknown GradientSpreadMethod value {gradientBrush.SpreadMethod}")
};
List <SKColor> skColors = new List <SKColor>();
List <float> skiaColorPositions = new List <float>();
foreach (IGradientStop gradientStop in gradientBrush.GradientStops)
{
skColors.Add(ToSkiaColor(gradientStop.Color));
skiaColorPositions.Add((float)gradientStop.Offset);
}
if (gradientBrush is ILinearGradientBrush linearGradientBrush)
{
SKPoint skiaStartPoint = GradientBrushPointToSkiaPoint(linearGradientBrush.StartPoint, gradientBrush, uiElement);
SKPoint skiaEndPoint = GradientBrushPointToSkiaPoint(linearGradientBrush.EndPoint, gradientBrush, uiElement);
return(SKShader.CreateLinearGradient(skiaStartPoint, skiaEndPoint, skColors.ToArray(), skiaColorPositions.ToArray(), tileMode));
}
else if (gradientBrush is IRadialGradientBrush radialGradientBrush)
{
SKPoint skiaCenterPoint = GradientBrushPointToSkiaPoint(radialGradientBrush.Center, gradientBrush, uiElement);
float radius = (float)(radialGradientBrush.RadiusX * uiElement.Width);
return(SKShader.CreateRadialGradient(skiaCenterPoint, radius, skColors.ToArray(), skiaColorPositions.ToArray(), tileMode));
}
else
{
throw new InvalidOperationException($"GradientBrush type {gradientBrush.GetType()} is unknown");
}
}
public void DrawHeader(SKCanvas c)
{
c.DrawRect(new SKRect(0, 0, Width, Height), _headerPaint);
_headerPaint.Shader = SKShader.CreateRadialGradient(new SKPoint(Width / 2, _headerHeight / 2), Width / 5 * 4,
new[] { SKColors.SkyBlue.WithAlpha(50), SKColors.Blue.WithAlpha(50) }, SKShaderTileMode.Clamp);
c.DrawRect(new SKRect(0, 0, Width, Height), _headerPaint);
_headerPaint.Shader = SKShader.CreateLinearGradient(new SKPoint(Width / 2, _headerHeight), new SKPoint(Width / 2, 75),
new[] { SKColors.Black.WithAlpha(25), SKColors.Blue.WithAlpha(0) }, SKShaderTileMode.Clamp);
c.DrawRect(new SKRect(0, 75, Width, _headerHeight), _headerPaint);
_headerPaint.Shader = null;
_headerPaint.Color = SKColors.White;
while (_headerPaint.MeasureText(DisplayName) > Width)
{
_headerPaint.TextSize -= 1;
}
var shaper = new CustomSKShaper(_headerPaint.Typeface);
var shapedText = shaper.Shape(DisplayName, _headerPaint);
c.DrawShapedText(shaper, DisplayName, (Width - shapedText.Points[^ 1].X) / 2, _headerHeight / 2 + _headerPaint.TextSize / 2 - 10, _headerPaint);
private void SKCanvasView_OnPaintSurface(object sender, SKPaintSurfaceEventArgs e)
{
if (_backgroundBitmap == null)
{
return;
}
var info = e.Info;
var rect = info.Rect;
var surface = e.Surface;
var canvas = surface.Canvas;
using (var paint = new SKPaint())
{
paint.Shader = SKShader.CreateLinearGradient(new SKPoint(rect.Left, rect.Top),
new SKPoint(rect.Left, rect.Bottom),
new[] { SKColors.Empty, SKColors.Black },
new[] { 0.6F, 0.8F },
SKShaderTileMode.Repeat);
canvas.DrawBitmap(_backgroundBitmap.Value, rect);
canvas.DrawRect(rect, paint);
}
}
static SKPaint CreateHighlightSkPaint(SKCanvasView skCanvasView, HighlightSettings highlightSettings, HighlightPath highlightPath)
{
var skPaint = new SKPaint
{
Style = SKPaintStyle.Stroke,
Color = SKColors.Red,
StrokeWidth = (float)skCanvasView.FromPixels(new Point(0, highlightSettings.StrokeWidth)).Y
};
float firstDashIntervalOn = highlightPath.FirstDash.Intervals[0];
skPaint.Shader = SKShader.CreateLinearGradient(
start: new SKPoint(firstDashIntervalOn * 0.30f, 0),
end: new SKPoint(firstDashIntervalOn, 0),
colors: new SKColor[] {
highlightSettings.StrokeStartColor.ToSKColor(),
highlightSettings.StrokeEndColor.ToSKColor()
},
colorPos: new float[] { 0, 1 },
mode: SKShaderTileMode.Clamp);
return(skPaint);
}
private void PaintGradient(SKCanvas canvas, float canvasRadius, SKColor[] colors, SKPoint centerGradient)
{
SKPoint center = new SKPoint(canvasRadius, canvasRadius);
var polar = ToPolar(new SKPoint(center.X - centerGradient.X, center.Y - centerGradient.Y));
polar.Radius *= triangleHeight;
var p2 = FromPolar(polar);
p2.X += centerGradient.X;
p2.Y += centerGradient.Y;
var shader = SKShader.CreateLinearGradient(centerGradient, p2, colors, null, SKShaderTileMode.Clamp);
var paint = new SKPaint
{
IsAntialias = true,
Shader = shader,
Style = SKPaintStyle.Fill
};
canvas.DrawCircle(center, WheelSVRadius(canvasRadius), paint);
}
private void CreateShader()
{
var center = new SKPoint(Layer.Rectangle.MidX, Layer.Rectangle.MidY);
SKShader shader;
switch (Settings.GradientType)
{
case GradientType.Solid:
shader = SKShader.CreateColor(_testColors.First());
break;
case GradientType.LinearGradient:
shader = SKShader.CreateLinearGradient(new SKPoint(0, 0), new SKPoint(Layer.Rectangle.Width, 0), _testColors.ToArray(), SKShaderTileMode.Repeat);
break;
case GradientType.RadialGradient:
shader = SKShader.CreateRadialGradient(center, Math.Min(Layer.Rectangle.Width, Layer.Rectangle.Height), _testColors.ToArray(), SKShaderTileMode.Repeat);
break;
case GradientType.SweepGradient:
shader = SKShader.CreateSweepGradient(center, _testColors.ToArray(), null, SKShaderTileMode.Clamp, 0, 360);
break;
default:
throw new ArgumentOutOfRangeException();
}
var oldShader = _shader;
var oldPaint = _paint;
_shader = shader;
_paint = new SKPaint {
Shader = _shader, FilterQuality = SKFilterQuality.Low
};
oldShader?.Dispose();
oldPaint?.Dispose();
}
public static SKShader ToSkiaShader(this Brush brush, double width, double height)
{
if (brush == null)
{
return(null);
}
else if (brush is SolidColorBrush)
{
return(SKShader.CreateColor((brush as SolidColorBrush).Color.ToSKColor()));
}
else if (brush is LinearGradientBrush)
{
var b = brush as LinearGradientBrush;
return(SKShader.CreateLinearGradient(
new SKPoint((float)(b.StartPoint.X * width), (float)(b.StartPoint.Y * height)),
new SKPoint((float)(b.EndPoint.X * width), (float)(b.EndPoint.Y * height)),
b.GradientStops.Select(x => x.Color.ToSKColor()).ToArray(),
b.GradientStops.Select(x => (float)x.Offset).ToArray(),
SKShaderTileMode.Clamp));
}
else if (brush is RadialGradientBrush)
{
var b = brush as RadialGradientBrush;
return(SKShader.CreateRadialGradient(
new SKPoint((float)(b.Center.X * width), (float)(b.Center.Y * height)),
(float)b.RadiusX,
b.GradientStops.Select(x => x.Color.ToSKColor()).ToArray(),
b.GradientStops.Select(x => (float)x.Offset).ToArray(),
SKShaderTileMode.Clamp));
}
else
{
throw new NotSupportedException($"Unsupported brush type {brush.GetType().Name}.");
}
}
