void OnCanvasViewPaintSurface(object sender, SKPaintSurfaceEventArgs args)
{
SKImageInfo info = args.Info;
SKSurface surface = args.Surface;
SKCanvas canvas = surface.Canvas;
canvas.Clear();
SKShaderTileMode tileMode =
(SKShaderTileMode)(tileModePicker.SelectedIndex == -1 ?
0 : tileModePicker.SelectedItem);
using (SKPaint paint = new SKPaint())
{
paint.Shader = SKShader.CreateRadialGradient(
new SKPoint(info.Rect.MidX, info.Rect.MidY),
100,
new SKColor[] { SKColors.Black, SKColors.White },
null,
tileMode);
canvas.DrawRect(info.Rect, paint);
}
}
protected void DrawPointAreas(SKCanvas canvas, SKPoint[] points, float origin)
{
if (points.Length > 0 && this.PointAreaAlpha > 0)
{
for (int i = 0; i < points.Length; i++)
{
var entry = this.Entries.ElementAt(i);
var point = points[i];
var y = Math.Min(origin, point.Y);
using (var shader = SKShader.CreateLinearGradient(new SKPoint(0, origin), new SKPoint(0, point.Y), new[] { entry.Color.WithAlpha(this.PointAreaAlpha), entry.Color.WithAlpha((byte)(this.PointAreaAlpha / 3)) }, null, SKShaderTileMode.Clamp))
using (var paint = new SKPaint
{
Style = SKPaintStyle.Fill,
Color = entry.Color.WithAlpha(this.PointAreaAlpha),
})
{
paint.Shader = shader;
var height = Math.Max(2, Math.Abs(origin - point.Y));
canvas.DrawRect(SKRect.Create(point.X - (this.PointSize / 2), y, this.PointSize, height), paint);
}
}
}
}
public IDisposable Apply(SKCanvas canvas, SKPaint paint, SKRect frame)
{
SKPoint end;
var x = this.Direction.X > 0 ? frame.Left : frame.Right;
var y = this.Direction.Y > 0 ? frame.Top : frame.Bottom;
var start = new SKPoint(x, y);
if (Math.Abs(this.Direction.X) > Math.Abs(this.Direction.Y))
{
var w = frame.Height * (this.Direction.X / this.Direction.Y);
var h = frame.Height * Math.Sign(this.Direction.Y);
end = new SKPoint(x + w, y + h);
}
else
{
var h = frame.Height * (this.Direction.Y / this.Direction.X);
var w = frame.Width * Math.Sign(this.Direction.X);
end = new SKPoint(x + w, y + h);
}
paint.Shader = SKShader.CreateLinearGradient(start, end, this.Colors, this.Points, SKShaderTileMode.Clamp);
return(paint.Shader);
}
public void DrawBoard(SKCanvas thisCanvas, float Width, float Height) // i think when drawing the board, it needs to recalculate so it can draw the pads as well.
{
SKRect bounds = SKRect.Create(0, 0, Width, Height);
SKPaint ThisPaint = new SKPaint();
ThisPaint.IsAntialias = true;
ThisPaint.FilterQuality = SKFilterQuality.High;
SKPoint FirstPoint;
SKPoint SecondPoint;
FirstPoint = new SKPoint(0, 0);
SecondPoint = new SKPoint(0, Height);
SKColor[] Colors;
Colors = new SKColor[2];
SKColor FirstColor;
SKColor SecondColor;
FirstColor = SKColors.LightBlue;
SecondColor = SKColors.DarkBlue;
Colors[0] = FirstColor;
Colors[1] = SecondColor;
ThisPaint.Shader = SKShader.CreateLinearGradient(FirstPoint, SecondPoint, Colors, null, SKShaderTileMode.Clamp);
thisCanvas.DrawRect(bounds, ThisPaint);
}
protected 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.TryParse("#ECE9E6", out SpideyBlueBckGrnd);
SKColor SpideyLightBlueBckGrnd;
SKColor.TryParse("#FFFFFF", out 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, 10.80f },
SKShaderTileMode.Mirror);
canvas.DrawRect(info.Rect, paint);
}
}
protected override void OnPaintSurface(SKPaintSurfaceEventArgs e)
{
var info = e.Info;
var canvas = e.Surface.Canvas;
canvas.Clear();
canvas.Save();
_path.MoveTo(0, 0);
_path.LineTo(info.Width, 0);
_path.LineTo(info.Width, info.Height / 2.5f);
_path.LineTo(0, info.Height);
_path.Close();
_paint.Style = SKPaintStyle.Fill;
_paint.Shader = SKShader.CreateLinearGradient(new SKPoint(0, 0),
new SKPoint(info.Width, ((float)info.Height).Scale(0.5f)),
new SKColor[]
{
BackgroundColor.ToBaseGradientColors(IsEnabled)[0],
BackgroundColor.ToBaseGradientColors(IsEnabled)[1],
}, SKShaderTileMode.Clamp);
_paint.ImageFilter = SKImageFilter.CreateDropShadow(0, 1f, 3f, 3f, SKColors.Black);
canvas.DrawPath(_path, _paint);
canvas.Restore();
}
public static void UpdateBackgroundCanvas(SKCanvas canvas, int width, int height)
{
try
{
#if !(GTK || CLI)
var colors = new SKColor[] { Theme.PrimaryColor.Color.ToSKColor(), Theme.SecondaryColor.Color.ToSKColor() };
var positions = new float[] { 0.0f, 1.0f };
using (var gradient = SKShader.CreateLinearGradient(new SKPoint(0, height / 2), new SKPoint(width, height / 2), colors, positions, SKShaderTileMode.Mirror))
{
using (var paint = new SKPaint {
Shader = gradient, IsAntialias = true
})
{
canvas.DrawPaint(paint);
}
}
#endif
}
catch (Exception ex)
{
Log.IgnoreException(ex);
}
}
public void BorderAndLayout()
{
const string file = "..\\..\\..\\AssertionImages\\border.png";
var bord = new Border
{
Foreground = new SKPaint {
Color = SKColors.White, IsAntialias = true
},
BorderBrush = new SKPaint {
Color = SKColors.Gray.WithAlpha(255), IsStroke = true, IsAntialias = true
},
Background = new SKPaint
{
Color = SKColors.White,
IsStroke = false,
IsAntialias = true,
Shader = SKShader.CreateLinearGradient(new SKPoint(0, 250), new SKPoint(0, 280),
new[] { new SKColor(70, 70, 70), SKColors.Black },
new[] { 0f, 1f }, SKShaderTileMode.Clamp)
},
CornerRadius = new CornerRadius(10),
Thickness = new Thickness(1, 5),
HorizAlign = HorizAlign.Left,
VertAlign = VertAlign.Top,
Width = 100,
Height = 50,
Margin = new Thickness(20),
Content = "Hello World"
};
var visualContext = new VisualContext(_app.MainWindow);
visualContext.AddVisual(bord);
visualContext.Render();
visualContext.SaveToImage(file);
Process.Start("mspaint.exe", Path.Combine(Environment.CurrentDirectory, file));
}
void CreateTickMarks(SKCanvas canvas, SKImageInfo info)
{
var numTicks = 15;
var distance = (info.Width - sidePadding * 2) / numTicks;
var tickHeight = 60;
for (int i = 1; i < numTicks; i++)
{
var start = new SKPoint(i * distance + sidePadding, info.Height - bottomPadding);
var end = new SKPoint(i * distance + sidePadding, info.Height - bottomPadding - (tickHeight));
tickBrush.Shader = SKShader.CreateLinearGradient(
start,
end,
new SKColor[] { new SKColor(255, 255, 255, 200), new SKColor(255, 255, 255, 0) },
new float[] { 0, 1 },
SKShaderTileMode.Clamp);
canvas.DrawLine(start, end, tickBrush);
}
}
public void DrawConnector(SKCanvas canvas, float _radX, float _radY)
{
float totalFlow = 0;
float totalSpO2 = 0;
float totalSpO2To = 0;
float totalSpO2From = 0;
float currentVolume = 0;
float radius = 0;
scale = _radX * scaleRelative;
radius = _radX / 2.5f;
if (_radX > _radY)
{
scale = _radY * scaleRelative;
radius = _radY / 2.5f;
}
float left = (float)Math.Sin(270 * 0.0174532925) * RadiusXOffset * radius;
float right = (float)Math.Sin(90 * 0.0174532925) * RadiusXOffset * radius;
float top = (float)Math.Cos(180 * 0.0174532925) * RadiusYOffset * radius;
float bottom = (float)Math.Cos(0 * 0.0174532925) * RadiusYOffset * radius;
// calculate the total volume and average spO2 if lumping is the case
foreach (ValveConnector c in connectors)
{
totalFlow += (float)c.CurrentFlow * Speed;
if (totalFlow >= 0)
{
totalSpO2 += (float)c.Comp1.TO2;
if (NoLoss)
{
totalSpO2From += (float)c.Comp1.TO2;
totalSpO2To += (float)c.Comp1.TO2;
}
else
{
totalSpO2From += (float)c.Comp1.TO2;
totalSpO2To += (float)c.Comp2.TO2;
}
}
else
{
totalSpO2 += (float)c.Comp2.TO2;
if (NoLoss)
{
totalSpO2From += (float)c.Comp2.TO2;
totalSpO2To += (float)c.Comp2.TO2;
}
else
{
totalSpO2From += (float)c.Comp2.TO2;
totalSpO2To += (float)c.Comp1.TO2;
}
}
Title = "";
}
tempAverageFlow += totalFlow;
if (averageCounter > 100)
{
AverageFlow = Math.Abs(tempAverageFlow) / averageCounter;
tempAverageFlow = 0;
averageCounter = 0;
}
averageCounter++;
//paint.Color = CalculateColor(totalSpO2 / connectors.Count);
colorTo = AnimatedElementHelper.CalculateBloodColor(totalSpO2To / connectors.Count);
colorFrom = AnimatedElementHelper.CalculateBloodColor(totalSpO2From / connectors.Count);
currentAngle += totalFlow * Direction;
if (Math.Abs(currentAngle) > Math.Abs(StartAngle - EndAngle))
{
currentAngle = 0;
}
if (sizeCompartment != null)
{
currentVolume = (float)sizeCompartment.VolCurrent;
circleOut.StrokeWidth = AnimatedElementHelper.RadiusCalculator(currentVolume, scale);
}
else
{
StrokeWidth = AverageFlow * Width;
if (StrokeWidth > 30)
{
StrokeWidth = 30;
}
if (StrokeWidth < 2)
{
StrokeWidth = 2;
}
strokeStepsize = (StrokeWidth - currentStrokeWidth) / 10;
currentStrokeWidth += strokeStepsize;
if (Math.Abs(currentStrokeWidth - StrokeWidth) < Math.Abs(strokeStepsize))
{
strokeStepsize = 0;
currentStrokeWidth = StrokeWidth;
}
circleOut.StrokeWidth = currentStrokeWidth;
}
// calculate position
locationOrigen = AnimatedElementHelper.GetPosition(StartAngle, radius, RadiusXOffset, RadiusYOffset);
locationTarget = AnimatedElementHelper.GetPosition(EndAngle, radius, RadiusXOffset, RadiusYOffset);
SKRect mainRect = new SKRect(left, top, right, bottom);
circleOut.Shader = SKShader.CreateSweepGradient(
new SKPoint(0f, 0f),
new SKColor[] { colorFrom, colorTo },
new float[] { StartAngle / 360f, EndAngle / 360f }
);
using (SKPath path = new SKPath())
{
path.AddArc(mainRect, StartAngle, Math.Abs(StartAngle - EndAngle));
canvas.DrawPath(path, circleOut);
}
location1 = AnimatedElementHelper.GetPosition(StartAngle + currentAngle, radius, RadiusXOffset, RadiusYOffset);
canvas.DrawCircle(location1.X + XOffset, location1.Y + YOffset, 7, paint);
}
protected override void OnPaintSurface(SKPaintSurfaceEventArgs e)
{
base.OnPaintSurface(e);
var canvas = e.Surface.Canvas;
canvas.Clear();
int width = e.Info.Width;
int height = e.Info.Height;
SKPaint backPaint = new SKPaint
{
Style = SKPaintStyle.Fill,
Color = SKColors.WhiteSmoke,
};
canvas.DrawRect(new SKRect(0, 0, width, height), backPaint);
canvas.Save();
canvas.Translate(width / 2, height / 2);
canvas.Scale(Math.Min(width / 210f, height / 520f));
var rect = new SKRect(-100, -100, 100, 100);
// Add a buffer for the rectangle
rect.Inflate(-10, -10);
var bgColorPaint = new SKPaint
{
Color = BGColor.ToSKColor(),
IsAntialias = true,
Style = SKPaintStyle.Fill,
StrokeWidth = 0
};
var barColorPaint = new SKPaint
{
Color = BarColor.ToSKColor(),
IsAntialias = true,
Style = SKPaintStyle.Fill,
StrokeWidth = 0
};
var frameColorPaint = new SKPaint
{
Color = FrameColor.ToSKColor(),
IsAntialias = true,
Style = SKPaintStyle.Stroke,
StrokeWidth = 2
};
var skrect = new SKRect(0, 0, PGWidth, PGHeight);
var skRoundRect = new SKRoundRect(skrect, PGHeight / 2, PGHeight / 2);
canvas.DrawRoundRect(0, 0, PGWidth, PGHeight, PGHeight / 2, PGHeight / 2, bgColorPaint);
canvas.DrawRoundRect(skRoundRect, frameColorPaint);
canvas.ClipRoundRect(skRoundRect, SKClipOperation.Intersect);
if (StartColor != Color.Default && EndColor != Color.Default)
{
barColorPaint.Shader = SKShader.CreateLinearGradient(
new SKPoint(skrect.Left, skrect.Bottom),
new SKPoint(skrect.Right, skrect.Top),
new SKColor[] { StartColor.ToSKColor(), EndColor.ToSKColor() },
new float[] { 0, 1 },
SKShaderTileMode.Repeat);
}
canvas.DrawRoundRect(0, 0, PGWidth * Progress / 100, PGHeight, PGWidth / 2, 0, barColorPaint);
canvas.Restore();
}
private SKBitmap BuildThumbCollageBitmap(string[] paths, int width, int height)
{
var bitmap = new SKBitmap(width, height);
using (var canvas = new SKCanvas(bitmap))
{
canvas.Clear(SKColors.Black);
// determine sizes for each image that will composited into the final image
var iSlice = Convert.ToInt32(width * 0.23475);
int iTrans = Convert.ToInt32(height * .25);
int iHeight = Convert.ToInt32(height * .70);
var horizontalImagePadding = Convert.ToInt32(width * 0.0125);
var verticalSpacing = Convert.ToInt32(height * 0.01111111111111111111111111111111);
int imageIndex = 0;
for (int i = 0; i < 4; i++)
{
SKCodecOrigin origin;
using (var currentBitmap = SkiaEncoder.Decode(paths[imageIndex], false, out origin))
{
// resize to the same aspect as the original
int iWidth = (int)Math.Abs(iHeight * currentBitmap.Width / currentBitmap.Height);
using (var resizeBitmap = new SKBitmap(iWidth, iHeight, currentBitmap.ColorType, currentBitmap.AlphaType))
{
currentBitmap.Resize(resizeBitmap, SKBitmapResizeMethod.Lanczos3);
// determine how much to crop
int ix = (int)Math.Abs((iWidth - iSlice) / 2);
using (var image = SKImage.FromBitmap(resizeBitmap))
{
// crop image
using (var subset = image.Subset(SKRectI.Create(ix, 0, iSlice, iHeight)))
{
// draw image onto canvas
canvas.DrawImage(subset, (horizontalImagePadding * (i + 1)) + (iSlice * i), verticalSpacing);
using (var croppedBitmap = SKBitmap.FromImage(subset))
{
// create reflection of image below the drawn image
using (var reflectionBitmap = new SKBitmap(croppedBitmap.Width, croppedBitmap.Height / 2, croppedBitmap.ColorType, croppedBitmap.AlphaType))
{
// resize to half height
croppedBitmap.Resize(reflectionBitmap, SKBitmapResizeMethod.Lanczos3);
using (var flippedBitmap = new SKBitmap(reflectionBitmap.Width, reflectionBitmap.Height, reflectionBitmap.ColorType, reflectionBitmap.AlphaType))
{
using (var flippedCanvas = new SKCanvas(flippedBitmap))
{
// flip image vertically
var matrix = SKMatrix.MakeScale(1, -1);
matrix.SetScaleTranslate(1, -1, 0, flippedBitmap.Height);
flippedCanvas.SetMatrix(matrix);
flippedCanvas.DrawBitmap(reflectionBitmap, 0, 0);
flippedCanvas.ResetMatrix();
// create gradient to make image appear as a reflection
var remainingHeight = height - (iHeight + (2 * verticalSpacing));
flippedCanvas.ClipRect(SKRect.Create(reflectionBitmap.Width, remainingHeight));
using (var gradient = new SKPaint())
{
gradient.IsAntialias = true;
gradient.BlendMode = SKBlendMode.SrcOver;
gradient.Shader = SKShader.CreateLinearGradient(new SKPoint(0, 0), new SKPoint(0, remainingHeight), new[] { new SKColor(0, 0, 0, 128), new SKColor(0, 0, 0, 208), new SKColor(0, 0, 0, 240), new SKColor(0, 0, 0, 255) }, null, SKShaderTileMode.Clamp);
flippedCanvas.DrawPaint(gradient);
}
// finally draw reflection onto canvas
canvas.DrawBitmap(flippedBitmap, (horizontalImagePadding * (i + 1)) + (iSlice * i), iHeight + (2 * verticalSpacing));
}
}
}
}
}
}
}
}
imageIndex++;
if (imageIndex >= paths.Length)
{
imageIndex = 0;
}
}
}
return(bitmap);
}
public SKShader GetShader()
{
return(SKShader.CreatePicture(GetPicture(), SKShaderTileMode.Repeat, SKShaderTileMode.Repeat, SKMatrix, Box));
}
protected override void OnDrawSample(SKCanvas canvas, int width, int height)
{
var modes = Enum.GetValues(typeof(SKXferMode)).Cast <SKXferMode>().ToArray();
var cols = width < height ? 3 : 5;
var rows = (modes.Length - 1) / cols + 1;
var w = (float)width / cols;
var h = (float)height / rows;
var rect = SKRect.Create(w, h);
var srcPoints = new[] {
new SKPoint(0.0f, 0.0f),
new SKPoint(w, 0.0f)
};
var srcColors = new[] {
SKColors.Magenta.WithAlpha(0),
SKColors.Magenta
};
var dstPoints = new[] {
new SKPoint(0.0f, 0.0f),
new SKPoint(0.0f, h)
};
var dstColors = new[] {
SKColors.Cyan.WithAlpha(0),
SKColors.Cyan
};
using (var text = new SKPaint())
using (var stroke = new SKPaint())
using (var src = new SKPaint())
using (var dst = new SKPaint())
using (var srcShader = SKShader.CreateLinearGradient(srcPoints[0], srcPoints[1], srcColors, null, SKShaderTileMode.Clamp))
using (var dstShader = SKShader.CreateLinearGradient(dstPoints[0], dstPoints[1], dstColors, null, SKShaderTileMode.Clamp))
{
text.TextSize = 12.0f;
text.IsAntialias = true;
text.TextAlign = SKTextAlign.Center;
stroke.IsStroke = true;
src.Shader = srcShader;
dst.Shader = dstShader;
canvas.Clear(SKColors.White);
for (var i = 0; i < modes.Length; ++i)
{
using (new SKAutoCanvasRestore(canvas, true))
{
canvas.Translate(w * (i / rows), h * (i % rows));
canvas.ClipRect(rect);
canvas.DrawColor(SKColors.LightGray);
canvas.SaveLayer(null);
canvas.Clear(SKColors.Transparent);
canvas.DrawPaint(dst);
src.XferMode = modes[i];
canvas.DrawPaint(src);
canvas.DrawRect(rect, stroke);
var desc = modes[i].ToString();
canvas.DrawText(desc, w / 2f, h / 2f, text);
}
}
}
}
protected override void OnPaintSurface(SKPaintSurfaceEventArgs eventArgs)
{
var givenCanvas = eventArgs.Surface.Canvas;
givenCanvas.Clear();
int canvasWidth = eventArgs.Info.Width;
int canvasHeight = eventArgs.Info.Height;
float rectRadius = ((canvasHeight - 20) / 4);
float rectRadiusInner = ButtonRadius - 10;
if (rectRadiusInner < 0)
{
rectRadiusInner = ButtonRadius;
}
this.roundRectButton = new SKRoundRect(new SKRect(0, 0, canvasWidth, canvasHeight - 20), ButtonRadius, ButtonRadius);
this.paintButton = new SKPaint()
{
Color = this.ColorPrimary.ToSKColor(),
IsAntialias = true
};
if (HasShadow)
{
paintButton.ImageFilter = SKImageFilter.CreateDropShadow(
0,
8,
0,
5,
Color.FromRgba(0, 0, 0, 0.4).ToSKColor(),
SKDropShadowImageFilterShadowMode.DrawShadowAndForeground
);
}
if (this.IsGradient)
{
this.paintButton.Shader = SKShader.CreateLinearGradient(
new SKPoint(this.roundRectButton.Rect.Left, this.roundRectButton.Rect.Top),
new SKPoint(this.roundRectButton.Rect.Right, this.roundRectButton.Rect.Bottom),
new SKColor[] {
this.ColorPrimary.ToSKColor(),
this.ColorSecondary.ToSKColor()
},
new float[] {
this.buttonGradientOffset,
1
},
SKShaderTileMode.Repeat
);
}
givenCanvas.DrawRoundRect(this.roundRectButton, this.paintButton);
this.roundRectButtonInner = new SKRoundRect(new SKRect(10, 10, canvasWidth - 10, canvasHeight - 30), rectRadiusInner, rectRadiusInner);
this.paintButtonInner = new SKPaint()
{
IsAntialias = true,
Color = SKColors.Transparent,
Style = SKPaintStyle.Fill,
BlendMode = SKBlendMode.SrcOut
};
givenCanvas.DrawRoundRect(this.roundRectButtonInner, this.paintButtonInner);
SKPaint paintButtonTitle = new SKPaint()
{
Color = this.ColorText.ToSKColor(),
TextSize = FontSize * coreSettings.ScalingFactor,
IsAntialias = true,
TextAlign = TextAlign,
Typeface = TextFont
};
if (this.IsGradient)
{
paintButtonTitle.Shader = SKShader.CreateLinearGradient(
new SKPoint(this.roundRectButton.Rect.Left, this.roundRectButton.Rect.Top),
new SKPoint(this.roundRectButton.Rect.Right, this.roundRectButton.Rect.Bottom),
new SKColor[] {
this.ColorPrimary.ToSKColor(),
this.ColorSecondary.ToSKColor()
},
new float[] {
this.buttonGradientOffset,
1
},
SKShaderTileMode.Repeat
);
}
givenCanvas.DrawText(this.ButtonTitle, canvasWidth / 2, ((canvasHeight - 30) / 2 + 25), paintButtonTitle);
}
internal PaintWrapper CreatePaint(IBrush brush, Size targetSize)
{
SKPaint paint = new SKPaint();
var rv = new PaintWrapper(paint);
paint.IsStroke = false;
double opacity = brush.Opacity * _currentOpacity;
paint.IsAntialias = true;
var solid = brush as ISolidColorBrush;
if (solid != null)
{
paint.Color = new SKColor(solid.Color.R, solid.Color.G, solid.Color.B, (byte)(solid.Color.A * opacity));
return(rv);
}
paint.Color = (new SKColor(255, 255, 255, (byte)(255 * opacity)));
var gradient = brush as IGradientBrush;
if (gradient != null)
{
var tileMode = gradient.SpreadMethod.ToSKShaderTileMode();
var stopColors = gradient.GradientStops.Select(s => s.Color.ToSKColor()).ToArray();
var stopOffsets = gradient.GradientStops.Select(s => (float)s.Offset).ToArray();
var linearGradient = brush as ILinearGradientBrush;
if (linearGradient != null)
{
var start = linearGradient.StartPoint.ToPixels(targetSize).ToSKPoint();
var end = linearGradient.EndPoint.ToPixels(targetSize).ToSKPoint();
// would be nice to cache these shaders possibly?
using (var shader = SKShader.CreateLinearGradient(start, end, stopColors, stopOffsets, tileMode))
paint.Shader = shader;
}
else
{
var radialGradient = brush as IRadialGradientBrush;
if (radialGradient != null)
{
var center = radialGradient.Center.ToPixels(targetSize).ToSKPoint();
var radius = (float)radialGradient.Radius;
// TODO: There is no SetAlpha in SkiaSharp
//paint.setAlpha(128);
// would be nice to cache these shaders possibly?
using (var shader = SKShader.CreateRadialGradient(center, radius, stopColors, stopOffsets, tileMode))
paint.Shader = shader;
}
}
return(rv);
}
var tileBrush = brush as ITileBrush;
var visualBrush = brush as IVisualBrush;
var tileBrushImage = default(BitmapImpl);
if (visualBrush != null)
{
if (_visualBrushRenderer != null)
{
var intermediateSize = _visualBrushRenderer.GetRenderTargetSize(visualBrush);
if (intermediateSize.Width >= 1 && intermediateSize.Height >= 1)
{
var intermediate = new BitmapImpl((int)intermediateSize.Width, (int)intermediateSize.Height);
using (var ctx = intermediate.CreateDrawingContext(_visualBrushRenderer))
{
ctx.Clear(Colors.Transparent);
_visualBrushRenderer.RenderVisualBrush(ctx, visualBrush);
}
rv.AddDisposable(tileBrushImage);
tileBrushImage = intermediate;
}
}
else
{
throw new NotSupportedException("No IVisualBrushRenderer was supplied to DrawingContextImpl.");
}
}
else
{
tileBrushImage = (BitmapImpl)((tileBrush as IImageBrush)?.Source?.PlatformImpl);
}
if (tileBrush != null && tileBrushImage != null)
{
var calc = new TileBrushCalculator(tileBrush, new Size(tileBrushImage.PixelWidth, tileBrushImage.PixelHeight), targetSize);
var bitmap = new BitmapImpl((int)calc.IntermediateSize.Width, (int)calc.IntermediateSize.Height);
rv.AddDisposable(bitmap);
using (var context = bitmap.CreateDrawingContext(null))
{
var rect = new Rect(0, 0, tileBrushImage.PixelWidth, tileBrushImage.PixelHeight);
context.Clear(Colors.Transparent);
context.PushClip(calc.IntermediateClip);
context.Transform = calc.IntermediateTransform;
context.DrawImage(tileBrushImage, 1, rect, rect);
context.PopClip();
}
SKMatrix translation = SKMatrix.MakeTranslation(-(float)calc.DestinationRect.X, -(float)calc.DestinationRect.Y);
SKShaderTileMode tileX =
tileBrush.TileMode == TileMode.None
? SKShaderTileMode.Clamp
: tileBrush.TileMode == TileMode.FlipX || tileBrush.TileMode == TileMode.FlipXY
? SKShaderTileMode.Mirror
: SKShaderTileMode.Repeat;
SKShaderTileMode tileY =
tileBrush.TileMode == TileMode.None
? SKShaderTileMode.Clamp
: tileBrush.TileMode == TileMode.FlipY || tileBrush.TileMode == TileMode.FlipXY
? SKShaderTileMode.Mirror
: SKShaderTileMode.Repeat;
using (var shader = SKShader.CreateBitmap(bitmap.Bitmap, tileX, tileY, translation))
paint.Shader = shader;
}
return(rv);
}
public PaintState(SKPaint paint, SKColor color, SKShader shader)
{
_paint = paint;
_color = color;
_shader = shader;
}
public override void Render(IStateOwner pOwner, SKCanvas pRenderTarget, ShowHighScoresState Source, GameStateSkiaDrawParameters Element)
{
if (Source.BG == null)
{
StandardImageBackgroundSkia sk = StandardImageBackgroundSkia.GetMenuBackgroundDrawer();
sk.Data.Movement = new SKPoint(3, 3);
Source.BG = sk;
}
var Bounds = Element.Bounds;
var g = pRenderTarget;
float StartY = (Bounds.Height * 0.175f);
var CurrentY = StartY;
float MiddleX = Bounds.Width / 2;
DrawBackground(Source, pOwner, g, Bounds);
float TextSize = Bounds.Height / 30f;
var ScoreFont = TetrisGame.RetroFontSK; //point size 24.
SKPaint MainScoreFont = new SKPaint()
{
Typeface = ScoreFont, TextSize = (float)(24 * pOwner.ScaleFactor), Color = SKColors.Black
};
SKPaint ShadowScoreFont = new SKPaint()
{
Typeface = ScoreFont, TextSize = (float)(24 * pOwner.ScaleFactor), Color = SKColors.White
};
SKPaint ListingFont = new SKPaint()
{
Typeface = ScoreFont, TextSize = (float)(18 * pOwner.ScaleFactor), Color = SKColors.Black
};
float PercentThroughSecond = (float)DateTime.Now.Millisecond / 1000f;
SKPaint ListingFontRainbow = new SKPaint()
{
Typeface = ScoreFont, TextSize = (float)(18 * pOwner.ScaleFactor), Color = SKColor.FromHsl(PercentThroughSecond * 240, 240, 120)
};
SKPaint ListingFontShadow = new SKPaint()
{
Typeface = ScoreFont, TextSize = (float)(18 * pOwner.ScaleFactor), Color = SKColors.White
};
SKPaint ListingFontArrow = new SKPaint()
{
Typeface = TetrisGame.ArialFontSK, TextSize = (float)(18 * pOwner.ScaleFactor), Color = SKColor.FromHsl(PercentThroughSecond * 240, 240, 120)
};
SKPaint ListingFontArrowShadow = new SKPaint()
{
Typeface = TetrisGame.ArialFontSK, TextSize = (float)(18 * pOwner.ScaleFactor), Color = SKColors.White
};
SKRect resultitem = new SKRect();
float LineHeight = MainScoreFont.MeasureText("#", ref resultitem);
var useShader = SKShader.CreateLinearGradient(new SKPoint(0, 0), new SKPoint(0, Bounds.Height), new SKColor[] { SKColors.Red, SKColors.Orange, SKColors.Yellow, SKColors.Green, SKColors.Blue, SKColors.Indigo, SKColors.Violet }, null, SKShaderTileMode.Mirror);
SKPaint LinePaint = new SKPaint()
{
BlendMode = SKBlendMode.ColorBurn, StrokeWidth = 24, Shader = useShader
};
g.DrawRect(new SKRect(0, 0, Bounds.Width, Bounds.Height), LinePaint);
//g.DrawRect(new SKRect((int)(Bounds.Width * (1 / 7)), CurrentY, (float)(Bounds.Width - (Bounds.Width * (1 / 7))), (float)(CurrentY + (LineHeight * 2.5) + (LineHeight * 3) * 12)),LinePaint);
if (Source.IncrementedDrawState >= 0)
{
//draw "HIGH SCORES" header text.
SKRect MeasuredRect = new SKRect();
MainScoreFont.MeasureText(Source.HeaderText, ref MeasuredRect);
SKPoint DrawPosition = new SKPoint(MiddleX - (MeasuredRect.Width / 2), StartY);
g.DrawText(Source.HeaderText, new SKPoint(DrawPosition.X + 2, DrawPosition.Y + 2), ShadowScoreFont);
g.DrawText(Source.HeaderText, DrawPosition, MainScoreFont);
CurrentY = StartY + MeasuredRect.Height + 10;
}
if (Source.IncrementedDrawState >= 1)
{
//maybe a line under the header.
}
if (Source.IncrementedDrawState >= 2)
{
//draw the high score listing entries.
//iterate from 2 to drawstate and draw the high score at position drawstate-2.
for (int scoreiterate = 2; scoreiterate < Source.IncrementedDrawState; scoreiterate++)
{
int CurrentScoreIndex = scoreiterate - 2;
int CurrentScorePosition = CurrentScoreIndex + 1;
double useYPosition = StartY + (LineHeight * 2.5) + (LineHeight * 3) * CurrentScoreIndex;
double useXPosition = Bounds.Width * 0.19d;
String sUseName = "N/A";
int sUseScore = 0;
IHighScoreEntry currentScore = Source.hs.Count > CurrentScoreIndex ? Source.hs[CurrentScoreIndex] : null;
if (currentScore != null)
{
sUseName = currentScore.Name;
sUseScore = currentScore.Score;
}
SKRect MeasureName = new SKRect(), MeasureScore = new SKRect();
ListingFont.MeasureText(sUseName, ref MeasureName);
ListingFont.MeasureText(sUseScore.ToString(), ref MeasureScore);
float PosXPosition = Bounds.Width * 0.1f;
float NameXPosition = Bounds.Width * 0.20f;
float ScoreXPositionRight = Bounds.Width * (1 - 0.10f);
var useForegroundPaint = Source.HighlightedScorePositions.Contains(CurrentScorePosition) ? ListingFontRainbow : ListingFont;
//draw position
g.DrawText(CurrentScorePosition.ToString() + ".", new SKPoint(PosXPosition + 2, (float)useYPosition + 2), ListingFontShadow);
g.DrawText(CurrentScorePosition.ToString() + ".", new SKPoint(PosXPosition, (float)useYPosition), useForegroundPaint);
//draw high score name
g.DrawText(sUseName, new SKPoint(PosXPosition + 2 + Math.Abs(resultitem.Height) * 2.25f, (float)useYPosition + 2), ListingFontShadow);
g.DrawText(sUseName, new SKPoint(PosXPosition + Math.Abs(resultitem.Height) * 2.25f, (float)useYPosition), useForegroundPaint);
//draw the high score
float ScoreXPosition = ScoreXPositionRight - MeasureScore.Width;
g.DrawText(sUseScore.ToString(), new SKPoint(ScoreXPosition + 2, (float)useYPosition + 2), ListingFontShadow);
g.DrawText(sUseScore.ToString(), new SKPoint(ScoreXPosition, (float)useYPosition), useForegroundPaint);
useForegroundPaint.StrokeWidth = 6;
g.DrawLine(new SKPoint(NameXPosition + MeasureName.Width + 15, (float)useYPosition + LineHeight / 2), new SKPoint(ScoreXPosition - 15, (float)useYPosition + LineHeight / 2), useForegroundPaint);
if (Source.SelectedScorePosition == CurrentScoreIndex)
{
//draw selection indicator if needed
SKRect MeasureArrow = new SKRect();
useForegroundPaint.MeasureText(PointerText, ref MeasureArrow);
float ArrowX = PosXPosition - MeasureArrow.Width - 5;
float ArrowY = (float)useYPosition;
g.DrawText(PointerText, new SKPoint(ArrowX + 2, ArrowY + 2), ListingFontArrowShadow);
g.DrawText(PointerText, new SKPoint(ArrowX, ArrowY), ListingFontArrow);
}
}
}
}
private void SKCanvasView_PaintSurface(object sender, SkiaSharp.Views.Forms.SKPaintSurfaceEventArgs e)
{
var skImageInfo = e.Info;
var skSurface = e.Surface;
var skCanvas = skSurface.Canvas;
var skCanvasWidth = skImageInfo.Width;
var skCanvasHeight = skImageInfo.Height;
skCanvas.Clear();
skCanvas.Translate((float)skCanvasWidth / 2, (float)skCanvasHeight / 2);
using (SKPaint paintCenter = new SKPaint())
{
paintCenter.Style = SKPaintStyle.Fill;
paintCenter.Color = SKColors.Black;
paintCenter.IsDither = true;
skCanvas.DrawCircle(0, 0, skCanvasWidth / 17f, paintCenter); // 45
}
SKPaint paintOrbit = new SKPaint
{
Style = SKPaintStyle.Stroke,
IsAntialias = true,
StrokeWidth = 5,
};
var colors = new[] { SKColors.Gray, SKColors.LightGray, SKColors.Silver.WithAlpha(128) };
using (var shader = SKShader.CreateSweepGradient(
new SKPoint(0, 0), colors, null))
{
paintOrbit.Shader = shader;
}
Random rand = new Random();
float orbitAngleDegree = 180 / (float)ElectronsCount;
for (double degrees = 0; degrees < (180); degrees += orbitAngleDegree)
{
var arcRectWidth = rand.Next(skCanvasWidth / 4, skCanvasWidth / 2); //350
var arcRectHeight = skCanvasHeight / 11.3f; //100
skCanvas.DrawOval(0, 0, arcRectWidth, arcRectHeight, paintOrbit);
using (SKPaint paintElectron = new SKPaint())
{
paintElectron.Style = SKPaintStyle.Fill;
paintElectron.Color = SKColors.Black;
paintElectron.IsAntialias = true;
skCanvas.DrawCircle(arcRectWidth, 0, 10, paintElectron);
}
if (degrees == 0 && ElectronsCount % 2 == 0)
{
skCanvas.RotateDegrees((float)orbitAngleDegree);
}
else
{
skCanvas.RotateDegrees((float)orbitAngleDegree + 180);
}
}
}
protected override void OnPaintSurface(SKPaintSurfaceEventArgs eventArgs)
{
var givenCanvas = eventArgs.Surface.Canvas;
givenCanvas.Clear();
this.canvasWidth = eventArgs.Info.Width;
this.canvasHeight = eventArgs.Info.Height;
SKBitmap backgroundImageBitmap = new SKBitmap();
//// Background image
//if (this.imageBackground != "")
//{
// string resourceID = this.imageBackground;
// Assembly assembly = GetType().GetTypeInfo().Assembly;
// using (Stream stream = assembly.GetManifestResourceStream(resourceID))
// {
// backgroundImageBitmap = SKBitmap.Decode(stream);
// }
//}
// Background progress circle
SKPaint progressPaint = new SKPaint()
{
Color = this.ColorBackground.ToSKColor(),
Style = SKPaintStyle.Stroke,
StrokeJoin = SKStrokeJoin.Round,
IsStroke = true,
StrokeWidth = 30,
IsAntialias = true
};
SKRect progressRect = new SKRect();
progressRect.Size = new SKSize(this.canvasWidth - 35, this.canvasHeight - 35);
progressRect.Location = new SKPoint(15, 15);
SKPath progressPath = new SKPath();
progressPath.AddArc(progressRect, -90, 360);
// Current progress circle
SKPaint progressCurrentPaint = new SKPaint()
{
Color = this.ColorPrimary.ToSKColor(),
Style = SKPaintStyle.Stroke,
StrokeJoin = SKStrokeJoin.Round,
IsStroke = true,
StrokeCap = SKStrokeCap.Round,
StrokeWidth = 30,
IsAntialias = true
};
if (this.IsGradient)
{
progressCurrentPaint.Shader = SKShader.CreateLinearGradient(
new SKPoint(0, this.canvasWidth),
new SKPoint(this.canvasHeight, 0),
new SKColor[] {
this.ColorPrimary.ToSKColor(),
this.ColorSecondary.ToSKColor()
},
new float[] {
0,
1
},
SKShaderTileMode.Repeat
);
}
SKRect progressCurrentRect = new SKRect();
progressCurrentRect.Size = new SKSize(this.canvasWidth - 35, this.canvasHeight - 35);
progressCurrentRect.Location = new SKPoint(15, 15);
SKPath progressCurrentPath = new SKPath();
progressCurrentPath.AddArc(progressCurrentRect, -90, this.progressCurrentSweepAngle);
// Current progress text
SKPaint progrssCurrentTextPaint = new SKPaint()
{
Color = this.ColorPrimary.ToSKColor(),
TextAlign = SKTextAlign.Center,
TextSize = TextSize,
IsAntialias = true
};
givenCanvas.ClipPath(progressPath, SKClipOperation.Intersect, true);
//if(this.imageBackground != "")
//{
// givenCanvas.DrawBitmap(
// backgroundImageBitmap,
// new SKRect(
// 0,
// 0,
// this.canvasWidth,
// this.canvasHeight
// )
// );
//}
givenCanvas.DrawPath(progressPath, progressPaint);
givenCanvas.DrawPath(progressCurrentPath, progressCurrentPaint);
var percentageIndicator = DisplayAsPercentage ? "%" : "";
if (DisplayValue)
{
if (FormatProvider == null || CustomFormat == null)
{
givenCanvas.DrawText(string.Format("{0}" + $"{percentageIndicator}", this.progressCurrentTextValue), (canvasWidth + 20) / 2, (canvasHeight + 20 + 35) / 2, progrssCurrentTextPaint);
}
if (FormatProvider != null && CustomFormat != null)
{
givenCanvas.DrawText(string.Format(FormatProvider, CustomFormat, this.progressCurrentTextValue), (canvasWidth + 20) / 2, (canvasHeight + 20 + 35) / 2, progrssCurrentTextPaint);
}
}
}
public void DrawConnector(SKCanvas canvas, float _radX, float _radY)
{
float totalFlow = 0;
float totalSpO2 = 0;
float totalSpO2To = 0;
float totalSpO2From = 0;
float currentVolume = 0;
float radius = 0;
scale = _radX * scaleRelative;
radius = _radX / 2.5f;
if (_radX > _radY)
{
scale = _radY * scaleRelative;
radius = _radY / 2.5f;
}
float left = (float)Math.Sin(270 * 0.0174532925) * RadiusXOffset * radius + XOffset;
float right = (float)Math.Sin(90 * 0.0174532925) * RadiusXOffset * radius + XOffset;
float top = (float)Math.Cos(180 * 0.0174532925) * RadiusYOffset * radius + YOffset;
float bottom = (float)Math.Cos(0 * 0.0174532925) * RadiusYOffset * radius + YOffset;
// calculate the total volume and average spO2 if lumping is the case
foreach (BloodCompartmentConnector c in connectors)
{
totalFlow += (float)c.RealFlow * Speed;
if (totalFlow >= 0)
{
totalSpO2 += (float)c.Comp1.TO2;
if (NoLoss)
{
totalSpO2From += (float)c.Comp1.TO2;
totalSpO2To += (float)c.Comp1.TO2;
}
else
{
totalSpO2From += (float)c.Comp1.TO2;
totalSpO2To += (float)c.Comp2.TO2;
}
}
else
{
totalSpO2 += (float)c.Comp2.TO2;
if (NoLoss)
{
totalSpO2From += (float)c.Comp2.TO2;
totalSpO2To += (float)c.Comp2.TO2;
}
else
{
totalSpO2From += (float)c.Comp2.TO2;
totalSpO2To += (float)c.Comp1.TO2;
}
}
Title = "";
}
//paint.Color = CalculateColor(totalSpO2 / connectors.Count);
colorTo = CalculateColor(totalSpO2To / connectors.Count);
colorFrom = CalculateColor(totalSpO2From / connectors.Count);
currentAngle += totalFlow * Direction;
// calculate position
locationOrigen = GetPosition(StartAngle, radius);
locationTarget = GetPosition(EndAngle, radius);
float dx = (locationOrigen.X - locationTarget.X) / Math.Abs(StartAngle - EndAngle);
float dy = (locationOrigen.Y - locationTarget.Y) / Math.Abs(StartAngle - EndAngle);
if (Math.Abs(currentAngle) > Math.Abs(StartAngle - EndAngle))
{
currentAngle = 0;
}
if (currentAngle < 0)
{
currentAngle = 0;
}
if (sizeCompartment != null)
{
currentVolume = (float)sizeCompartment.VolCurrent;
circleOut.StrokeWidth = RadiusCalculator(currentVolume);
}
else
{
circleOut.StrokeWidth = 15;
}
SKRect mainRect = new SKRect(left, top, right, bottom);
circleOut.Shader = SKShader.CreateLinearGradient(
locationOrigen,
locationTarget,
new SKColor[] { colorFrom, colorTo },
null,
SKShaderTileMode.Mirror
);
offset.X = Math.Abs(locationOrigen.X - locationTarget.X) / 4f;
using (SKPath path = new SKPath())
{
path.MoveTo(locationTarget);
path.LineTo(locationOrigen);
canvas.DrawPath(path, circleOut);
canvas.DrawTextOnPath(Name, path, offset, textPaint2);
}
location1.X = locationOrigen.X - currentAngle * dx;
location1.Y = locationOrigen.Y - currentAngle * dy;
canvas.DrawCircle(location1.X + XOffset, location1.Y + YOffset, 10, paint);
}
public bool Draw(SKCanvas canvas, IReadOnlyViewport viewport, ILayer layer, IFeature feature, IStyle istyle,
ISymbolCache symbolCache)
{
var style = ((TiledBitmapStyle)istyle);
if (style.image == null)
{
return(false);
}
var position = feature.Geometry.BoundingBox.Centroid;
var dest = viewport.WorldToScreen(position);
var zoom = 1 / (float)viewport.Resolution;
canvas.Translate((float)dest.X, (float)dest.Y);
canvas.Scale(zoom, zoom);
canvas.RotateDegrees((float)viewport.Rotation, 0.0f, 0.0f);
if (style.rotation != 0)
{
canvas.RotateDegrees(style.rotation, 0.0f, 0.0f);
}
//#TODO store paint with shader in the style
using (SKPaint paint = new SKPaint())
{
if (style.rotation == 0) //Weird artifacting on 0 rotation, no idea why. Seems Skia bug.
{
style.rotation = 180;
}
SKMatrix shaderTransform =
SKMatrix.CreateScale((float)viewport.Resolution, (float)viewport.Resolution);
if (style.rotation != 0)
{
shaderTransform = SKMatrix.Concat(shaderTransform, SKMatrix.CreateRotationDegrees(-style.rotation));
}
paint.Shader = SKShader.CreateImage(style.image, SKShaderTileMode.Repeat, SKShaderTileMode.Repeat, shaderTransform);
paint.ColorFilter = style.colorFilter;
//style.image.Encode().SaveTo(File.Create($"P:/{style.image.UniqueId}.png"));
if (style.ellipse)
{
canvas.DrawOval(0, 0, style.rect.Right, style.rect.Bottom, paint);
}
else
{
canvas.DrawRect(style.rect, paint);
}
if (style.border)
{
var borderPaint = new SKPaint
{
Style = SKPaintStyle.Stroke,
Color = style.color
};
if (style.ellipse)
{
canvas.DrawOval(0, 0, style.rect.Right, style.rect.Bottom, borderPaint);
}
else
{
canvas.DrawRect(style.rect, borderPaint);
}
}
}
return(true);
}
public void SetFixShader(SKShader shader)
{
variableShader = false;
paint.Shader = shader;
}
private void DrawLineArea(SKCanvas canvas, ChartSerie serie, SKPoint[] points, SKSize itemSize, float origin)
{
if (LineAreaAlpha > 0 && points.Length > 1)
{
using (var paint = new SKPaint
{
Style = SKPaintStyle.Fill,
Color = SKColors.White,
IsAntialias = true,
})
{
using (var shaderX = CreateXGradient(points, serie.Entries, serie.Color, (byte)(LineAreaAlpha * AnimationProgress)))
using (var shaderY = CreateYGradient(points, (byte)(LineAreaAlpha * AnimationProgress)))
{
paint.Shader = EnableYFadeOutGradient ? SKShader.CreateCompose(shaderY, shaderX, SKBlendMode.SrcOut) : shaderX;
var path = new SKPath();
var isFirst = true;
var entries = serie.Entries;
var lineMode = LineMode;
var last = (lineMode == LineMode.Spline) ? points.Length - 1 : points.Length;
SKPoint lastPoint = points.First();
for (int i = 0; i < last; i++)
{
if (!entries.ElementAt(i).Value.HasValue)
{
continue;
}
if (isFirst)
{
path.MoveTo(points[i].X, origin);
path.LineTo(points[i]);
isFirst = false;
}
if (lineMode == LineMode.Spline)
{
int next = i + 1;
while (next < last && !entries.ElementAt(next).Value.HasValue)
{
next++;
}
if (next == last && !entries.ElementAt(next).Value.HasValue)
{
lastPoint = points[i];
break;
}
var cubicInfo = CalculateCubicInfo(points, i, next, itemSize);
path.CubicTo(cubicInfo.control, cubicInfo.nextControl, cubicInfo.nextPoint);
lastPoint = cubicInfo.nextPoint;
}
else if (lineMode == LineMode.Straight)
{
path.LineTo(points[i]);
lastPoint = points[i];
}
}
path.LineTo(lastPoint.X, origin);
path.Close();
canvas.DrawPath(path, paint);
}
}
}
}
public static Tuple <SKPaint, IEnumerable <IDisposable> > CreatePaint(this XInkStroke stroke, SKPaintStyle paintStyle = SKPaintStyle.Stroke, SKBlendMode blendMode = SKBlendMode.SrcATop)
{
if (stroke == null)
{
throw new ArgumentNullException(nameof(stroke));
}
var disposables = new List <IDisposable>();
SKShader shader = null;
if (stroke.DrawingAttributes.Kind == XInkDrawingAttributesKind.Pencil)
{
var perlin = SKShader.CreatePerlinNoiseFractalNoise(0.01f, 0.01f, 1, 1.0f);
var color = SKShader.CreateColor(stroke.DrawingAttributes.Color.ToSKColor().WithAlpha(0x7F));
disposables.Add(perlin);
disposables.Add(color);
shader = SKShader.CreateCompose(
perlin,
color,
blendMode);
}
Tuple <SKPaint, IEnumerable <IDisposable> > tuple = null;
SKPaint paint = null;
if (!stroke.DrawingAttributes.IgnorePressure)
{
paintStyle = SKPaintStyle.Fill;
}
try
{
paint = new SKPaint
{
Color = stroke.DrawingAttributes.Kind == XInkDrawingAttributesKind.Default ? stroke.DrawingAttributes.Color.ToSKColor() : new SKColor(),
StrokeWidth = stroke.DrawingAttributes.IgnorePressure? stroke.DrawingAttributes.Size : 0.0f,
Style = paintStyle,
IsAntialias = true,
StrokeCap = stroke.DrawingAttributes.PenTip == Inking.XPenTipShape.Circle ? SKStrokeCap.Round : SKStrokeCap.Butt,
PathEffect = SKPathEffect.CreateCorner(100)
};
if (shader != null)
{
paint.Shader = shader;
}
tuple = Tuple.Create(paint, disposables as IEnumerable <IDisposable>);
paint = null;
}
finally
{
paint?.Dispose();
}
return(tuple);
}
internal PaintWrapper CreatePaint(IBrush brush, Size targetSize)
{
SKPaint paint = new SKPaint();
var rv = new PaintWrapper(paint);
paint.IsStroke = false;
// TODO: SkiaSharp does not contain alpha yet!
double opacity = brush.Opacity * _currentOpacity;
//paint.SetAlpha(paint.GetAlpha() * opacity);
paint.IsAntialias = true;
SKColor color = new SKColor(255, 255, 255, 255);
var solid = brush as ISolidColorBrush;
if (solid != null)
{
color = solid.Color.ToSKColor();
}
paint.Color = (new SKColor(color.Red, color.Green, color.Blue, (byte)(color.Alpha * opacity)));
if (solid != null)
{
return(rv);
}
var gradient = brush as GradientBrush;
if (gradient != null)
{
var tileMode = gradient.SpreadMethod.ToSKShaderTileMode();
var stopColors = gradient.GradientStops.Select(s => s.Color.ToSKColor()).ToArray();
var stopOffsets = gradient.GradientStops.Select(s => (float)s.Offset).ToArray();
var linearGradient = brush as LinearGradientBrush;
if (linearGradient != null)
{
var start = linearGradient.StartPoint.ToPixels(targetSize).ToSKPoint();
var end = linearGradient.EndPoint.ToPixels(targetSize).ToSKPoint();
// would be nice to cache these shaders possibly?
using (var shader = SKShader.CreateLinearGradient(start, end, stopColors, stopOffsets, tileMode))
paint.Shader = shader;
}
else
{
var radialGradient = brush as RadialGradientBrush;
if (radialGradient != null)
{
var center = radialGradient.Center.ToPixels(targetSize).ToSKPoint();
var radius = (float)radialGradient.Radius;
// TODO: There is no SetAlpha in SkiaSharp
//paint.setAlpha(128);
// would be nice to cache these shaders possibly?
using (var shader = SKShader.CreateRadialGradient(center, radius, stopColors, stopOffsets, tileMode))
paint.Shader = shader;
}
}
return(rv);
}
var tileBrush = brush as TileBrush;
if (tileBrush != null)
{
var helper = new TileBrushImplHelper(tileBrush, targetSize);
var bitmap = new BitmapImpl((int)helper.IntermediateSize.Width, (int)helper.IntermediateSize.Height);
rv.AddDisposable(bitmap);
using (var ctx = bitmap.CreateDrawingContext())
helper.DrawIntermediate(ctx);
SKMatrix translation = SKMatrix.MakeTranslation(-(float)helper.DestinationRect.X, -(float)helper.DestinationRect.Y);
SKShaderTileMode tileX =
tileBrush.TileMode == TileMode.None
? SKShaderTileMode.Clamp
: tileBrush.TileMode == TileMode.FlipX || tileBrush.TileMode == TileMode.FlipXY
? SKShaderTileMode.Mirror
: SKShaderTileMode.Repeat;
SKShaderTileMode tileY =
tileBrush.TileMode == TileMode.None
? SKShaderTileMode.Clamp
: tileBrush.TileMode == TileMode.FlipY || tileBrush.TileMode == TileMode.FlipXY
? SKShaderTileMode.Mirror
: SKShaderTileMode.Repeat;
using (var shader = SKShader.CreateBitmap(bitmap.Bitmap, tileX, tileY, translation))
paint.Shader = shader;
}
return(rv);
}
private static void DrawBackground(SKCanvas canvas, SKRect rect, SKPath path, LinearGradient linear)
{
using (var paint = new SKPaint())
{
var rad = Math.PI / 180 * linear.Angle;
var cx = rect.MidX;
var cy = rect.MidY;
var tan = (float)Math.Tan(rad);
var cos = (float)Math.Cos(rad);
float x1 = 0, y1 = 0, x2 = 0, y2 = 0, px = 0, py = 0;
if (tan == 0)
{
x1 = rect.Left;
y1 = cy;
x2 = rect.Right;
y2 = cy;
}
else if (cos == 0)
{
x1 = cx;
y1 = rect.Top;
x2 = cx;
y2 = rect.Bottom;
}
else
{
if (tan > 0 && cos > 0)
{
px = rect.Right;
py = rect.Bottom;
}
else if (tan > 0 && cos < 0)
{
px = rect.Left;
py = rect.Top;
}
else if (tan < 0 && cos > 0)
{
px = rect.Right;
py = rect.Top;
}
else if (tan < 0 && cos < 0)
{
px = rect.Left;
py = rect.Bottom;
}
var p = (-tan * px + py + tan * cx - cy) / (tan * tan + 1);
x1 = p * tan + px;
y1 = py - p;
x2 = 2 * cx - x1;
y2 = 2 * cy - y1;
}
paint.Style = SKPaintStyle.Fill;
paint.Shader = SKShader.CreateLinearGradient(
new SKPoint(x1, y1),
new SKPoint(x2, y2),
linear.Colors.Select(color => color.ToSK()).ToArray(),
linear.ColorPosition.ToArray(), SKShaderTileMode.Repeat);
canvas.DrawPath(path, paint);
}
}
/// <summary>
/// Configure paint wrapper for using gradient brush.
/// </summary>
/// <param name="paintWrapper">Paint wrapper.</param>
/// <param name="targetSize">Target size.</param>
/// <param name="gradientBrush">Gradient brush.</param>
private void ConfigureGradientBrush(ref PaintWrapper paintWrapper, Size targetSize, IGradientBrush gradientBrush)
{
var tileMode = gradientBrush.SpreadMethod.ToSKShaderTileMode();
var stopColors = gradientBrush.GradientStops.Select(s => s.Color.ToSKColor()).ToArray();
var stopOffsets = gradientBrush.GradientStops.Select(s => (float)s.Offset).ToArray();
switch (gradientBrush)
{
case ILinearGradientBrush linearGradient:
{
var start = linearGradient.StartPoint.ToPixels(targetSize).ToSKPoint();
var end = linearGradient.EndPoint.ToPixels(targetSize).ToSKPoint();
// would be nice to cache these shaders possibly?
using (var shader =
SKShader.CreateLinearGradient(start, end, stopColors, stopOffsets, tileMode))
{
paintWrapper.Paint.Shader = shader;
}
break;
}
case IRadialGradientBrush radialGradient:
{
var center = radialGradient.Center.ToPixels(targetSize).ToSKPoint();
var radius = (float)(radialGradient.Radius * targetSize.Width);
var origin = radialGradient.GradientOrigin.ToPixels(targetSize).ToSKPoint();
if (origin.Equals(center))
{
// when the origin is the same as the center the Skia RadialGradient acts the same as D2D
using (var shader =
SKShader.CreateRadialGradient(center, radius, stopColors, stopOffsets, tileMode))
{
paintWrapper.Paint.Shader = shader;
}
}
else
{
// when the origin is different to the center use a two point ConicalGradient to match the behaviour of D2D
// reverse the order of the stops to match D2D
var reversedColors = new SKColor[stopColors.Length];
Array.Copy(stopColors, reversedColors, stopColors.Length);
Array.Reverse(reversedColors);
// and then reverse the reference point of the stops
var reversedStops = new float[stopOffsets.Length];
for (var i = 0; i < stopOffsets.Length; i++)
{
reversedStops[i] = stopOffsets[i];
if (reversedStops[i] > 0 && reversedStops[i] < 1)
{
reversedStops[i] = Math.Abs(1 - stopOffsets[i]);
}
}
// compose with a background colour of the final stop to match D2D's behaviour of filling with the final color
using (var shader = SKShader.CreateCompose(
SKShader.CreateColor(reversedColors[0]),
SKShader.CreateTwoPointConicalGradient(center, radius, origin, 0, reversedColors, reversedStops, tileMode)
))
{
paintWrapper.Paint.Shader = shader;
}
}
break;
}
case IConicGradientBrush conicGradient:
{
var center = conicGradient.Center.ToPixels(targetSize).ToSKPoint();
// Skia's default is that angle 0 is from the right hand side of the center point
// but we are matching CSS where the vertical point above the center is 0.
var angle = (float)(conicGradient.Angle - 90);
var rotation = SKMatrix.CreateRotationDegrees(angle, center.X, center.Y);
using (var shader =
SKShader.CreateSweepGradient(center, stopColors, stopOffsets, rotation))
{
paintWrapper.Paint.Shader = shader;
}
break;
}
}
}
public void DrawConnector(SKCanvas canvas, float _radX, float _radY)
{
float totalFlow = 0;
float totalSpO2 = 0;
float totalSpO2To = 0;
float totalSpO2From = 0;
float currentVolume = 0;
float radius = 0;
scale = _radX * scaleRelative;
radius = _radX / 2.5f;
if (_radX > _radY)
{
scale = _radY * scaleRelative;
radius = _radY / 2.5f;
}
// calculate the total volume and average spO2 if lumping is the case
foreach (BloodCompartmentConnector c in connectors)
{
totalFlow += (float)c.CurrentFlow * Speed;
if (totalFlow >= 0)
{
totalSpO2 += (float)c.Comp1.TO2;
if (NoLoss)
{
totalSpO2From += (float)c.Comp1.TO2;
totalSpO2To += (float)c.Comp1.TO2;
}
else
{
totalSpO2From += (float)c.Comp1.TO2;
totalSpO2To += (float)c.Comp2.TO2;
}
}
else
{
totalSpO2 += (float)c.Comp2.TO2;
if (NoLoss)
{
totalSpO2From += (float)c.Comp2.TO2;
totalSpO2To += (float)c.Comp2.TO2;
}
else
{
totalSpO2From += (float)c.Comp2.TO2;
totalSpO2To += (float)c.Comp1.TO2;
}
}
}
colorTo = AnimatedElementHelper.CalculateBloodColor(totalSpO2To / connectors.Count);
colorFrom = AnimatedElementHelper.CalculateBloodColor(totalSpO2From / connectors.Count);
currentAngle += totalFlow * Direction;
if (Math.Abs(currentAngle) > Math.Abs(StartAngle - EndAngle))
{
currentAngle = 0;
}
if (sizeCompartment != null)
{
currentVolume = (float)sizeCompartment.VolCurrent;
circleOut.StrokeWidth = AnimatedElementHelper.RadiusCalculator(currentVolume, scale);
}
else
{
circleOut.StrokeWidth = 22;
}
// calculate position
locationOrigen = AnimatedElementHelper.GetPosition(StartAngle, radius, RadiusXOffset, RadiusYOffset);
locationTarget = AnimatedElementHelper.GetPosition(EndAngle, radius, RadiusXOffset, RadiusYOffset);
float left = (float)Math.Sin(270 * 0.0174532925) * RadiusXOffset * radius + XOffset;
float right = (float)Math.Sin(90 * 0.0174532925) * RadiusXOffset * radius + XOffset;
float top = (float)Math.Cos(180 * 0.0174532925) * RadiusYOffset * radius + YOffset;
float bottom = (float)Math.Cos(0 * 0.0174532925) * RadiusYOffset * radius + YOffset;
mainRect.Left = left;
mainRect.Right = right;
mainRect.Top = top;
mainRect.Bottom = bottom;
circleOut.Shader = SKShader.CreateSweepGradient(
new SKPoint(0f, 0f),
new SKColor[] { colorFrom, colorTo },
new float[] { StartAngle / 360f, EndAngle / 360f }
);
using (SKPath path = new SKPath())
{
path.AddArc(mainRect, StartAngle, Math.Abs(StartAngle - EndAngle));
canvas.DrawPath(path, circleOut);
}
location1 = AnimatedElementHelper.GetPosition(StartAngle + currentAngle, radius, RadiusXOffset, RadiusYOffset);
canvas.DrawCircle(location1.X + XOffset, location1.Y + YOffset, 10, paint);
}
public override void Render(IStateOwner pOwner, SKCanvas pRenderTarget, ViewScoreDetailsState Source, GameStateSkiaDrawParameters Element)
{
//TODO: finish this!
var g = pRenderTarget;
var Bounds = Element.Bounds;
//Draw the background first.
RenderingProvider.Static.DrawElement(pOwner, pRenderTarget, Source.BG, new SkiaBackgroundDrawData(Bounds));
DrawTextInformationSkia skdraw = new DrawTextInformationSkia()
{
ForegroundPaint = new SKPaint()
};
float StartY = (Bounds.Height * 0.175f);
var CurrentY = StartY;
float MiddleX = Bounds.Width / 2;
float TextSize = Bounds.Height / 30f;
var ScoreFont = TetrisGame.RetroFontSK; //point size 24.
SKPaint MainScoreFont = new SKPaint()
{
Typeface = ScoreFont, TextSize = (float)(24 * pOwner.ScaleFactor), Color = SKColors.Black
};
SKPaint ShadowScoreFont = new SKPaint()
{
Typeface = ScoreFont, TextSize = (float)(24 * pOwner.ScaleFactor), Color = SKColors.White
};
SKPaint ListingFont = new SKPaint()
{
Typeface = ScoreFont, TextSize = (float)(18 * pOwner.ScaleFactor), Color = SKColors.Black
};
float PercentThroughSecond = (float)DateTime.Now.Millisecond / 1000f;
SKPaint ListingFontRainbow = new SKPaint()
{
Typeface = ScoreFont, TextSize = (float)(18 * pOwner.ScaleFactor), Color = SKColor.FromHsl(PercentThroughSecond * 240, 240, 120)
};
SKPaint ListingFontShadow = new SKPaint()
{
Typeface = ScoreFont, TextSize = (float)(18 * pOwner.ScaleFactor), Color = SKColors.White
};
SKPaint ListingFontArrow = new SKPaint()
{
Typeface = TetrisGame.ArialFontSK, TextSize = (float)(18 * pOwner.ScaleFactor), Color = SKColor.FromHsl(PercentThroughSecond * 240, 240, 120)
};
SKPaint ListingFontArrowShadow = new SKPaint()
{
Typeface = TetrisGame.ArialFontSK, TextSize = (float)(18 * pOwner.ScaleFactor), Color = SKColors.White
};
SKRect resultitem = new SKRect();
float LineHeight = MainScoreFont.MeasureText("#", ref resultitem);
var useShader = SKShader.CreateLinearGradient(new SKPoint(0, 0), new SKPoint(0, Bounds.Height), new SKColor[] { SKColors.Red, SKColors.Orange, SKColors.Yellow, SKColors.Green, SKColors.Blue, SKColors.Indigo, SKColors.Violet }, null, SKShaderTileMode.Mirror);
SKPaint LinePaint = new SKPaint()
{
BlendMode = SKBlendMode.ColorBurn, StrokeWidth = 24, Shader = useShader
};
g.DrawRect(new SKRect(0, 0, Bounds.Width, Bounds.Height), LinePaint);
//g.DrawRect(new SKRect((int)(Bounds.Width * (1 / 7)), CurrentY, (float)(Bounds.Width - (Bounds.Width * (1 / 7))), (float)(CurrentY + (LineHeight * 2.5) + (LineHeight * 3) * 12)),LinePaint);
if (Source.IncrementedDrawState >= 0)
{
//draw "SCORE DETAILS"
String sHeaderText = "SCORE DETAILS";
SKRect MeasuredRect = new SKRect();
MainScoreFont.MeasureText(sHeaderText, ref MeasuredRect);
SKPoint DrawPosition = new SKPoint(MiddleX - (MeasuredRect.Width / 2), StartY);
g.DrawText(sHeaderText, new SKPoint(DrawPosition.X + 2, DrawPosition.Y + 2), ShadowScoreFont);
g.DrawText(sHeaderText, DrawPosition, MainScoreFont);
CurrentY = StartY + MeasuredRect.Height + 10;
}
if (Source.IncrementedDrawState >= 1)
{
//maybe a line under the header.
}
if (Source.IncrementedDrawState >= 2)
{
switch (Source.CurrentView)
{
case ViewScoreDetailsState.ViewScoreDetailsType.Details_Tetrominoes:
DrawTetronimoDetails(Source, g, Bounds, CurrentY);
break;
case ViewScoreDetailsState.ViewScoreDetailsType.Details_LevelTimes:
DrawLevelTimesDetails(Source, g, Bounds, CurrentY);
break;
}
//draw the high score listing entries.
//iterate from 2 to drawstate and draw the high score at position drawstate-2.
/*for (int scoreiterate = 2; scoreiterate < Source.IncrementedDrawState; scoreiterate++)
* {
* int CurrentScoreIndex = scoreiterate - 2;
* int CurrentScorePosition = CurrentScoreIndex + 1;
* double useYPosition = StartY + (LineHeight * 2.5) + (LineHeight * 3) * CurrentScoreIndex;
* double useXPosition = Bounds.Width * 0.19d;
* String sUseName = "N/A";
* int sUseScore = 0;
* IHighScoreEntry currentScore = Source.hs.Count > CurrentScoreIndex ? Source.hs[CurrentScoreIndex] : null;
* if (currentScore != null)
* {
* sUseName = currentScore.Name;
* sUseScore = currentScore.Score;
* }
* SKRect MeasureName = new SKRect(), MeasureScore = new SKRect();
* ListingFont.MeasureText(sUseName, ref MeasureName);
* ListingFont.MeasureText(sUseScore.ToString(), ref MeasureScore);
* float PosXPosition = Bounds.Width * 0.1f;
* float NameXPosition = Bounds.Width * 0.20f;
* float ScoreXPositionRight = Bounds.Width * (1 - 0.10f);
* var useForegroundPaint = Source.HighlightedScorePositions.Contains(CurrentScorePosition) ? ListingFontRainbow : ListingFont;
*
* //draw position
* g.DrawText(CurrentScorePosition.ToString() + ".", new SKPoint(PosXPosition + 2, (float)useYPosition + 2), ListingFontShadow);
* g.DrawText(CurrentScorePosition.ToString() + ".", new SKPoint(PosXPosition, (float)useYPosition), useForegroundPaint);
* //draw high score name
* g.DrawText(sUseName, new SKPoint(PosXPosition + 2 + Math.Abs(resultitem.Height) * 2.25f, (float)useYPosition + 2), ListingFontShadow);
* g.DrawText(sUseName, new SKPoint(PosXPosition + Math.Abs(resultitem.Height) * 2.25f, (float)useYPosition), useForegroundPaint);
*
* //draw the high score
* float ScoreXPosition = ScoreXPositionRight - MeasureScore.Width;
*
* g.DrawText(sUseScore.ToString(), new SKPoint(ScoreXPosition + 2, (float)useYPosition + 2), ListingFontShadow);
* g.DrawText(sUseScore.ToString(), new SKPoint(ScoreXPosition, (float)useYPosition), useForegroundPaint);
* useForegroundPaint.StrokeWidth = 6;
*
* g.DrawLine(new SKPoint(NameXPosition + MeasureName.Width + 15, (float)useYPosition + LineHeight / 2), new SKPoint(ScoreXPosition - 15, (float)useYPosition + LineHeight / 2), useForegroundPaint);
*
* if (Source.SelectedScorePosition == CurrentScoreIndex)
* {
* //draw selection indicator if needed
* SKRect MeasureArrow = new SKRect();
* useForegroundPaint.MeasureText(PointerText, ref MeasureArrow);
* float ArrowX = PosXPosition - MeasureArrow.Width - 5;
* float ArrowY = (float)useYPosition;
* g.DrawText(PointerText, new SKPoint(ArrowX + 2, ArrowY + 2), ListingFontArrowShadow);
* g.DrawText(PointerText, new SKPoint(ArrowX, ArrowY), ListingFontArrow);
* }
* }*/
}
/*
*
* Font HeaderFont = TetrisGame.GetRetroFont(24, pOwner.ScaleFactor);
* Font PlacementFont = TetrisGame.GetRetroFont(10, pOwner.ScaleFactor);
* Font DetailFont = TetrisGame.GetRetroFont(8, pOwner.ScaleFactor);
*
*
* //One thing we draw in every case is the "--SCORE DETAILS--" header text. this is positioned at 5% from the top, centered in the middle of our bounds.
* float Millipercent = (float)DateTime.Now.Ticks / 5000f; //(float)DateTime.Now.Millisecond / 1000;
*
* var MeasuredHeader = g.MeasureString(Source._DetailHeader, HeaderFont);
* int RotateAmount = (int)(Millipercent * 240);
* Color UseColor1 = HSLColor.RotateHue(Color.Red, RotateAmount);
* Color UseColor2 = HSLColor.RotateHue(Color.LightPink, RotateAmount);
* PointF ScorePosition = new PointF((Bounds.Width / 2) - (MeasuredHeader.Width / 2), Bounds.Height * 0.05f);
* using (LinearGradientBrush lgb = new LinearGradientBrush(new Rectangle(0, 0, (int)MeasuredHeader.Width, (int)MeasuredHeader.Height), UseColor1, UseColor2, LinearGradientMode.Vertical))
* {
* using (GraphicsPath gp = new GraphicsPath())
* {
* gp.AddString(Source._DetailHeader, HeaderFont, new Point((int)ScorePosition.X, (int)ScorePosition.Y), StringFormat.GenericDefault);
* g.FillPath(lgb, gp);
* g.DrawPath(Pens.White, gp);
* }
* }
*
* //we also show Xth Place - <NAME> centered below the header using the placementfont.
* String sPlacement = TetrisGame.FancyNumber(Source._Position) + " - " + Source.ShowEntry.Name + " - " + Source.ShowEntry.Score.ToString();
*
* var measureit = g.MeasureString(sPlacement, PlacementFont);
*
* PointF DrawPlacement = new PointF(Bounds.Width / 2 - measureit.Width / 2, (float)(ScorePosition.Y + MeasuredHeader.Height * 1.1f));
*
* g.DrawString(sPlacement, PlacementFont, Brushes.Black, DrawPlacement.X + 3, DrawPlacement.Y + 3);
* g.DrawString(sPlacement, PlacementFont, Brushes.White, DrawPlacement.X, DrawPlacement.Y);
*
* g.DrawLine(Separator, (float)(Bounds.Width * 0.05f), (float)(DrawPlacement.Y + measureit.Height + 5), (float)(Bounds.Width * 0.95), (float)(DrawPlacement.Y + measureit.Height + 5));
*
*
* switch (Source.CurrentView)
* {
* case ViewScoreDetailsState.ViewScoreDetailsType.Details_Tetrominoes:
* DrawTetronimoDetails(Source, g, Bounds);
* break;
* case ViewScoreDetailsState.ViewScoreDetailsType.Details_LevelTimes:
* DrawLevelTimesDetails(Source, g, Bounds);
* break;
* }
*/
}
