コード例 #1
0
            private Texture2D getOrCreateTexture(GraphicsDevice device)
            {
                if (this.bitmap is null || this.texture is null)
                {
                    this.bitmap?.Dispose();
                    this.texture?.Dispose();

                    this.bitmap = new SKBitmap(this.mBounds.Width, this.mBounds.Height);

                    using var ms            = new MemoryStream();
                    using var canvas        = new SKCanvas(this.bitmap);
                    using var white_skpaint = new SKPaint()
                          {
                              Shader = SKShader.CreateLinearGradient(new SKPoint(0.0f, 0.0f), new SKPoint(this.mBounds.Width, 0.0f), new SKColor[] { SKColors.Transparent, SKColors.White }, SKShaderTileMode.Decal)
                          };
                    using var black_skpaint = new SKPaint()
                          {
                              Shader = SKShader.CreateLinearGradient(new SKPoint(0.0f, 0.0f), new SKPoint(this.mBounds.Height, 0.0f), new SKColor[] { SKColors.Transparent, new SKColor(1, 1, 1, 255) }, SKShaderTileMode.Decal)
                          };
                    using var colour_skpaint = new SKPaint()
                          {
                              Shader = SKShader.CreateColor(this.hueColour.AsSKColor())
                          };

                    canvas.DrawPaint(colour_skpaint);
                    canvas.DrawPaint(white_skpaint);
                    canvas.RotateDegrees(90.0f);
                    canvas.DrawPaint(black_skpaint);

                    this.bitmap.Encode(ms, SKEncodedImageFormat.Png, 95);
                    this.texture = Texture2D.FromStream(device, ms);
                }

                return(this.texture);
            }
コード例 #2
0
ファイル: GridDrawer.cs プロジェクト: Drumbits/DrumTrainer
        public void Draw(SKCanvas canvas, SKRect rect)
        {
            canvas.Save();
            canvas.Scale(rect.Height / 100f);
            canvas.DrawPaint(backgroundPaint);
            canvas.Restore();
            // drawing horizontal lines
            for (int i = 0; i < instruments.Length; ++i)
            {
                float line = gridRect.Top + (i + 1) * settings.LineHeight;
                canvas.DrawText(instruments[i].Name, 0, line, textPaint);
                DrawHorizontalLine(canvas, line);
            }
            int   col  = (int)gridRect.Left;
            float step = settings.BeatWidth / (float)subdivisions;

            for (int bar = 0; bar < info.BarsCount; ++bar)
            {
                for (int beatIndex = 1; beatIndex <= info.BeatsPerBar; ++beatIndex)
                {
                    DrawVerticalLine(canvas, col, beatIndex);
                    for (var subDivIndex = 1; subDivIndex < subdivisions; ++subDivIndex)
                    {
                        DrawVerticalLine(canvas, col + subDivIndex * step, (int?)null);
                    }
                    col += settings.BeatWidth;
                }
            }
        }
コード例 #3
0
 private void PrepareCanvas(SKCanvas canvas, SKImageInfo info)
 {
     canvas.Clear();
     canvas.DrawPaint(new SKPaint {
         Color = new SKColor(255, 255, 255)
     });
 }
コード例 #4
0
        void DisplayClipOp(SKCanvas canvas, SKRect rect, SKClipOperation clipOp)
        {
            float textSize = textPaint.TextSize;

            canvas.DrawText(clipOp.ToString(), rect.MidX, rect.Top + textSize, textPaint);
            rect.Top += textSize;

            float radius  = 0.9f * Math.Min(rect.Width / 3, rect.Height / 2);
            float xCenter = rect.MidX;
            float yCenter = rect.MidY;

            canvas.Save();

            using (SKPath path1 = new SKPath())
            {
                path1.AddCircle(xCenter - radius / 2, yCenter, radius);
                canvas.ClipPath(path1);

                using (SKPath path2 = new SKPath())
                {
                    path2.AddCircle(xCenter + radius / 2, yCenter, radius);
                    canvas.ClipPath(path2, clipOp);

                    canvas.DrawPaint(fillPaint);
                }
            }

            canvas.Restore();
        }
コード例 #5
0
        private void DrawTimer(SKCanvas canvas, SKImageInfo info)
        {
            canvas.Clear();
            canvas.DrawPaint(new SKPaint {
                Color = new SKColor(96, 96, 96)
            });


            SKPoint center = new SKPoint(info.Width / 2 - 15, info.Height / 2);
            float   radius = Math.Min(info.Width / 2, info.Height / 2) - 10;
            SKRect  rect   = new SKRect(center.X - radius, center.Y - radius,
                                        center.X + radius, center.Y + radius);

            var surroundCircle = new YCircle(center, radius + 2, new SKColor(48, 48, 48), 4, SKPaintStyle.Stroke);

            surroundCircle.Draw(canvas);

            var backgroundCircle = new YCircle(center, radius, new SKColor(80, 80, 80), 1, SKPaintStyle.Fill);

            backgroundCircle.Draw(canvas);

            float startAngle = 270;



            var path = new YPath(new SKPath(), new SKColor(245, 222, 179), 5);

            path.DrawingPath.MoveTo(center);
            path.Paint.Style = SKPaintStyle.Fill;
            path.DrawingPath.ArcTo(rect, startAngle, _sweepAngle, false);
            path.DrawingPath.Close();

            path.Draw(canvas);
        }
コード例 #6
0
        public async ValueTask <byte[]> GetBytesWithFilterAsync(
            int size,
            string topic = null,
            SKImageFilter imageFilter = null,
            SKColorFilter colorFilter = null,
            SKShader shader           = null,
            SKBlendMode blendMode     = SKBlendMode.Overlay)
        {
            Trace.WriteLine("Start");
            string url;

            if (string.IsNullOrEmpty(topic))
            {
                url = string.Format(URL_PATTERN_RND, size);
            }
            else
            {
                url = string.Format(URL_PATTERN, size, topic);
            }

            var imageInfo = new SKImageInfo(size, size);

            using (var http = new HttpClient())
            {
                var image = await http.GetByteArrayAsync(url);//.ConfigureAwait(false);

                Trace.WriteLine("Downloaded");
                using (var outStream = new MemoryStream())
                    using (var bitmap = SKBitmap.Decode(image, imageInfo))
                        using (var surface = SKSurface.Create(imageInfo))
                            using (var paint = new SKPaint())
                            {
                                SKCanvas canvas = surface.Canvas;
                                canvas.DrawColor(SKColors.White);
                                if (imageFilter != null)
                                {
                                    paint.ImageFilter = imageFilter;
                                }
                                if (colorFilter != null)
                                {
                                    paint.ColorFilter = colorFilter;
                                }

                                // draw the bitmap through the filter
                                var rect = SKRect.Create(imageInfo.Size);
                                canvas.DrawBitmap(bitmap, rect, paint);
                                if (shader != null)
                                {
                                    paint.Shader    = shader;
                                    paint.BlendMode = blendMode;
                                    canvas.DrawPaint(paint);
                                }
                                SKData data = surface.Snapshot().Encode(SKEncodedImageFormat.Jpeg, 80);
                                data.SaveTo(outStream);
                                byte[] manipedImage = outStream.ToArray();
                                Trace.WriteLine("End");
                                return(manipedImage);
                            }
            }
        }
コード例 #7
0
        void OnCanvasViewPaintSurface(object sender, SKPaintSurfaceEventArgs args)
        {
            SKImageInfo info    = args.Info;
            SKSurface   surface = args.Surface;
            SKCanvas    canvas  = surface.Canvas;

            canvas.Clear();

            // Set transform to center and enlarge clip path to window height
            SKRect bounds;

            path.GetTightBounds(out bounds);

            canvas.Translate(info.Width / 2, info.Height / 2);
            canvas.Scale((0.5f * info.Height / bounds.Height) * -1);
            canvas.Translate(-bounds.MidX, -bounds.MidY);

            // Set the clip path
            canvas.ClipPath(path, SKClipOperation.Difference);

            // Reset transforms
            canvas.ResetMatrix();
            using (SKPaint paint2 = new SKPaint())
            {
                paint2.Style = SKPaintStyle.Fill;
                paint2.Color = SKColors.Green.WithAlpha(0x50);
                canvas.DrawPaint(paint2);
            }
        }
コード例 #8
0
            private Texture2D getOrCreateTexture(GraphicsDevice device)
            {
                if (this.bitmap is null || this.texture is null)
                {
                    this.bitmap?.Dispose();
                    this.texture?.Dispose();

                    this.bitmap = new SKBitmap(this.mBounds.Width, this.mBounds.Height);

                    using var ms     = new MemoryStream();
                    using var canvas = new SKCanvas(this.bitmap);
                    using var paint  = new SKPaint()
                          {
                              Shader = SKShader.CreateLinearGradient(new SKPoint(0.0f, 0.0f), new SKPoint(this.mBounds.Width, this.mBounds.Height),
                                                                     new SKColor[] { SKColors.Red, SKColors.Yellow, SKColors.Lime, SKColors.Cyan, SKColors.Blue, SKColors.Magenta, SKColors.Red }, new Single[] { 0f,
                                                                                                                                                                                                                  1 / 6f,
                                                                                                                                                                                                                  2 / 6f,
                                                                                                                                                                                                                  3 / 6f,
                                                                                                                                                                                                                  4 / 6f,
                                                                                                                                                                                                                  5 / 6f,
                                                                                                                                                                                                                  1f }, SKShaderTileMode.Decal)
                          };

                    canvas.DrawPaint(paint);
                    canvas.RotateDegrees(90.0f);

                    this.bitmap.Encode(ms, SKEncodedImageFormat.Png, 95);
                    this.texture = Texture2D.FromStream(device, ms);
                }

                return(this.texture);
            }
コード例 #9
0
        private void canvasView_PaintSurface(object sender, SkiaSharp.Views.Forms.SKPaintSurfaceEventArgs e)
        {
            SKImageInfo info    = e.Info;
            SKSurface   surface = e.Surface;
            SKCanvas    canvas  = surface.Canvas;

            canvas.Clear();

            //Set transforms to shift path to center and scale to canvas size
            canvas.Translate(info.Width / 2, info.Height / 2);
            canvas.Scale(0.95f *
                         Math.Min(info.Width / (pathBounds.Width + STROKE_WIDTH),
                                  info.Height / (pathBounds.Height + STROKE_WIDTH)));



            using (SKPaint paint = new SKPaint())
            {
                paint.Style       = SKPaintStyle.Stroke;
                paint.StrokeWidth = STROKE_WIDTH;
                paint.Shader      = SKShader.CreateLinearGradient(
                    new SKPoint(pathBounds.Left, pathBounds.Top),
                    new SKPoint(pathBounds.Right, pathBounds.Bottom),
                    colors,
                    null,
                    SKShaderTileMode.Repeat,
                    SKMatrix.MakeTranslation(offset, 0));

                canvas.DrawPaint(paint);
            }
        }
コード例 #10
0
        protected override void OnDrawSample(SKCanvas canvas, int width, int height)
        {
            // load the image from the embedded resource stream
            using (var stream = new SKManagedStream(SampleMedia.Images.ColorWheel))
                using (var source = SKBitmap.Decode(stream))
                {
                    // invert the pixels
                    var pixels = source.Pixels;
                    for (int i = 0; i < pixels.Length; i++)
                    {
                        pixels[i] = new SKColor(
                            (byte)(255 - pixels[i].Red),
                            (byte)(255 - pixels[i].Green),
                            (byte)(255 - pixels[i].Blue),
                            pixels[i].Alpha);
                    }
                    source.Pixels = pixels;

                    using (var shader = SKShader.CreateBitmap(source, SKShaderTileMode.Repeat, SKShaderTileMode.Repeat))
                        using (var paint = new SKPaint())
                        {
                            paint.IsAntialias = true;
                            paint.Shader      = shader;

                            // tile the bitmap
                            canvas.Clear(SKColors.White);
                            canvas.DrawPaint(paint);
                        }
                }
        }
コード例 #11
0
        public BlueBananaPage()
        {
            Title = "Blue Banana";

            // Load banana matte bitmap (black on transparent)
            SKBitmap matteBitmap = BitmapExtensions.LoadBitmapResource(
                typeof(BlueBananaPage),
                "SkiaSharpFormsDemos.Media.BananaMatte.png");

            // Create a bitmap with a solid blue banana and transparent otherwise
            blueBananaBitmap = new SKBitmap(matteBitmap.Width, matteBitmap.Height);

            using (SKCanvas canvas = new SKCanvas(blueBananaBitmap))
            {
                canvas.Clear();
                canvas.DrawBitmap(matteBitmap, new SKPoint(0, 0));

                using (SKPaint paint = new SKPaint())
                {
                    paint.Color     = SKColors.Blue;
                    paint.BlendMode = SKBlendMode.SrcIn;
                    canvas.DrawPaint(paint);
                }
            }

            SKCanvasView canvasView = new SKCanvasView();

            canvasView.PaintSurface += OnCanvasViewPaintSurface;
            Content = canvasView;
        }
コード例 #12
0
ファイル: SkiaGraph.cs プロジェクト: marques999/xameteo
        /// <summary>
        /// </summary>
        /// <param name="canvas"></param>
        /// <param name="width"></param>
        /// <param name="height"></param>
        public void DrawGraph(SKCanvas canvas, int width, int height)
        {
            UpdateReferences(width, height);
            SetScale(width, height);

            using (var paint = new SKPaint())
            {
                paint.IsAntialias = true;

                var colors = new[]
                {
                    SKColors.White,
                    new SKColor(214, 244, 255)
                };

                paint.Shader = SKShader.CreateLinearGradient(
                    new SKPoint(0, 0),
                    new SKPoint(width, height),
                    colors,
                    null,
                    SKShaderTileMode.Clamp
                    );

                canvas.DrawPaint(paint);
                paint.StrokeCap   = SKStrokeCap.Round;
                paint.IsAntialias = true;
                paint.StrokeJoin  = SKStrokeJoin.Round;
                canvas.DrawPaint(paint);
            }

            DrawSeparators(canvas);

            for (var i = 1; i < _graph.Count; i++)
            {
                DrawLine(canvas, width, height, i, _graph[i - 1], _graph[i]);
            }

            for (var i = 0; i < _graph.Count; i++)
            {
                var x = _paddingW + _availableW * i / (_sizeX - 1);
                var y = height - (_paddingH * 2f + 0.8f * _availableH * (_graph[i].Y - _minY) / _sizeY);

                DrawWeatherImag(canvas, _graph[i], x, y, _scale);
                DrawYVal(canvas, _graph[i], x, y, _scale);
                DrawLabel(canvas, _graph[i], x, y, _scale);
            }
        }
コード例 #13
0
        public static void DrawCheckerboard(SKCanvas canvas, SKColor c1, SKColor c2, int size)
        {
            SKPaint paint = new SKPaint
            {
                Shader = CreateCheckerboardShader(c1, c2, size)
            };

            canvas.DrawPaint(paint);
        }
コード例 #14
0
 public void Clear(ColorValue backgroundColor)
 {
     canvas.Clear();
     using (var paint = new SKPaint())
     {
         paint.Color = GetColorFromColorValue(backgroundColor);
         canvas.DrawPaint(paint);
     }
 }
        protected override void OnDrawSample(SKCanvas canvas, int width, int height)
        {
            canvas.Clear(SKColors.White);

            using (var shader = SKShader.CreatePerlinNoiseTurbulence(0.05f, 0.05f, 4, 0.0f))
                using (var paint = new SKPaint())
                {
                    paint.Shader = shader;
                    canvas.DrawPaint(paint);
                }
        }
コード例 #16
0
        /// <summary>
        /// Draw on the canvas
        /// </summary>
        /// <param name="sender">object</param>
        /// <param name="e">SKPaintSurfaceEventArgs</param>
        private void CanvasView_PaintSurface(object sender, SKPaintSurfaceEventArgs e)
        {
            SKSurface surface = e.Surface;
            SKCanvas  canvas  = surface.Canvas;

            canvas.DrawPaint(backgroundFillPaint);
            int width  = e.Info.Width;
            int height = e.Info.Height;

            DateTime dateTime = DateTime.Now;

            canvas.Translate(width / 2, height / 2);
            canvas.Scale(Math.Min(width / 80f, height / 200f));
            canvas.DrawCircle(0, -160, 75, blackFillPaint);
            canvas.DrawCircle(0, 0, 100, blackFillPaint);

            // Display the face of the watch
            for (int angle = 0; angle < 360; angle += 6)
            {
                if (angle % 30 == 0)
                {
                    canvas.DrawCircle(0, -90, angle % 30 == 0 ? 4 : 2, redFillPaint);
                }
                else
                {
                    canvas.DrawCircle(0, -90, angle % 30 == 0 ? 4 : 2, whiteFillPaint);
                }

                canvas.RotateDegrees(6);
            }

            // Hour hand
            canvas.Save();
            canvas.RotateDegrees(30 * dateTime.Hour + dateTime.Minute / 2f);
            canvas.DrawPath(hourHandPath, grayFillPaint);
            canvas.DrawPath(hourHandPath, whiteStrokePaint);
            canvas.Restore();

            // Minute hand
            canvas.Save();
            canvas.RotateDegrees(6 * dateTime.Minute + dateTime.Second / 10f);
            canvas.DrawPath(minHandPath, grayFillPaint);
            canvas.DrawPath(minHandPath, whiteStrokePaint);
            canvas.Restore();

            // Second hand
            canvas.Save();
            float seconds = dateTime.Second + dateTime.Millisecond / 1000f;

            canvas.RotateDegrees(6 * seconds);
            canvas.DrawLine(0, 0, 0, -80, whiteStrokePaint);
            canvas.Restore();
        }
コード例 #17
0
 public void PopOpacityMask()
 {
     Canvas.SaveLayer(new SKPaint {
         BlendMode = SKBlendMode.DstIn
     });
     using (var paintWrapper = maskStack.Pop())
     {
         Canvas.DrawPaint(paintWrapper.Paint);
     }
     Canvas.Restore();
     Canvas.Restore();
 }
コード例 #18
0
        protected override void OnDrawSample(SKCanvas canvas, int width, int height)
        {
            var colors = new[] { SKColors.Cyan, SKColors.Magenta, SKColors.Yellow, SKColors.Cyan };
            var center = new SKPoint(width / 2f, height / 2f);

            using (var shader = SKShader.CreateSweepGradient(center, colors, null))
                using (var paint = new SKPaint())
                {
                    paint.Shader = shader;
                    canvas.DrawPaint(paint);
                }
        }
コード例 #19
0
        protected override void OnDrawSample(SKCanvas canvas, int width, int height)
        {
            var colors = new[] { SKColors.Blue, SKColors.Yellow };
            var center = new SKPoint(width / 2f, height / 2f);

            using (var shader1 = SKShader.CreateRadialGradient(center, 180.0f, colors, null, SKShaderTileMode.Clamp))
                using (var shader2 = SKShader.CreatePerlinNoiseTurbulence(0.025f, 0.025f, 2, 0.0f))
                    using (var shader = SKShader.CreateCompose(shader1, shader2))
                        using (var paint = new SKPaint())
                        {
                            paint.Shader = shader;
                            canvas.DrawPaint(paint);
                        }
        }
コード例 #20
0
        public override void Awake(NSObject context)
        {
            base.Awake(context);

            var scale = WKInterfaceDevice.CurrentDevice.ScreenScale;

            var bitmap = new SKBitmap((int)(ContentFrame.Width * scale), (int)(ContentFrame.Height * scale));

            var colors = new[] { SKColors.Cyan, SKColors.Magenta, SKColors.Yellow, SKColors.Cyan };
            var center = new SKPoint(bitmap.Width / 2, bitmap.Height / 2);

            using (var canvas = new SKCanvas(bitmap))
            {
                canvas.Clear(SKColors.Transparent);

                using (var path = new SKPath())
                {
                    path.AddRoundedRect(new SKRect(5, 5, bitmap.Width - 5, bitmap.Height - 5), 5, 5);
                    canvas.ClipPath(path);
                }

                using (var paint = new SKPaint())
                    using (var gradient = SKShader.CreateSweepGradient(center, colors, null))
                    {
                        paint.IsAntialias = true;
                        paint.Shader      = gradient;
                        canvas.DrawPaint(paint);
                        paint.Shader = null;
                    }

                using (var paint = new SKPaint())
                    using (var tf = SKTypeface.FromFamilyName("San Fransisco"))
                    {
                        paint.IsAntialias = true;
                        paint.Color       = SKColors.DarkBlue;
                        paint.TextSize    = (float)(20 * scale);
                        paint.TextAlign   = SKTextAlign.Center;
                        paint.Typeface    = tf;

                        canvas.DrawText("SkiaSharp", center.X, (center.Y / 2) + (paint.TextSize / 2), paint);
                    }
            }

            var image = bitmap.ToUIImage(scale, UIKit.UIImageOrientation.Up);

            imageView.SetImage(image);
        }
コード例 #21
0
        protected override void OnDrawSample(SKCanvas canvas, int width, int height)
        {
            var ltColor = SKColors.White;
            var dkColor = SKColors.Black;

            using (var paint = new SKPaint())
            {
                paint.IsAntialias = true;
                using (var shader = SKShader.CreateLinearGradient(
                           new SKPoint(0, 0),
                           new SKPoint(0, height),
                           new[] { ltColor, dkColor },
                           null,
                           SKShaderTileMode.Clamp))
                {
                    paint.Shader = shader;
                    canvas.DrawPaint(paint);
                }
            }

            // Center and Scale the Surface
            var scale = (width < height ? width : height) / (240f);

            canvas.Translate(width / 2f, height / 2f);
            canvas.Scale(scale, scale);
            canvas.Translate(-128, -128);

            using (var paint = new SKPaint())
            {
                paint.IsAntialias = true;
                using (var shader = SKShader.CreateTwoPointConicalGradient(
                           new SKPoint(115.2f, 102.4f),
                           25.6f,
                           new SKPoint(102.4f, 102.4f),
                           128.0f,
                           new[] { ltColor, dkColor },
                           null,
                           SKShaderTileMode.Clamp
                           ))
                {
                    paint.Shader = shader;

                    canvas.DrawOval(new SKRect(51.2f, 51.2f, 204.8f, 204.8f), paint);
                }
            }
        }
コード例 #22
0
        void DisplayClipOp(SKCanvas canvas, SKRect rect, SKRegionOperation regionOp)
        {
            float textSize = textPaint.TextSize;

            canvas.DrawText(regionOp.ToString(), rect.MidX, rect.Top + textSize, textPaint);
            rect.Top += textSize;

            float radius  = 0.9f * Math.Min(rect.Width / 3, rect.Height / 2);
            float xCenter = rect.MidX;
            float yCenter = rect.MidY;

            SKRectI recti = new SKRectI((int)rect.Left, (int)rect.Top,
                                        (int)rect.Right, (int)rect.Bottom);

            using (SKRegion wholeRectRegion = new SKRegion())
            {
                wholeRectRegion.SetRect(recti);

                using (SKRegion region1 = new SKRegion(wholeRectRegion))
                    using (SKRegion region2 = new SKRegion(wholeRectRegion))
                    {
                        using (SKPath path1 = new SKPath())
                        {
                            path1.AddCircle(xCenter - radius / 2, yCenter, radius);
                            region1.SetPath(path1);
                        }

                        using (SKPath path2 = new SKPath())
                        {
                            path2.AddCircle(xCenter + radius / 2, yCenter, radius);
                            region2.SetPath(path2);
                        }

                        region1.Op(region2, regionOp);

                        canvas.Save();
                        canvas.ClipRegion(region1);
                        canvas.DrawPaint(fillPaint);
                        canvas.Restore();
                    }
            }
        }
コード例 #23
0
        private void PaintGrayRadialGradient(SKCanvas canvas, float canvasRadius)
        {
            SKPoint center = new SKPoint(canvasRadius, canvasRadius);

            var colors = new SKColor[] {
                SKColors.Gray,
                SKColors.Transparent
            };

            var shader = SKShader.CreateRadialGradient(center, WheelHSRadius(canvasRadius), colors, null, SKShaderTileMode.Clamp);

            var paint = new SKPaint
            {
                IsAntialias = true,
                Shader      = shader,
                Style       = SKPaintStyle.Fill
            };

            canvas.DrawPaint(paint);
        }
コード例 #24
0
        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 };

                var gradient = SKShader.CreateLinearGradient(new SKPoint(0, height / 2), new SKPoint(width, height / 2), colors, positions, SKShaderTileMode.Mirror);
                var paint    = new SKPaint {
                    Shader = gradient, IsAntialias = true
                };

                canvas.DrawPaint(paint);
#endif
            }
            catch (Exception ex)
            {
                Log.IgnoreException(ex);
            }
        }
コード例 #25
0
        protected override void OnDrawSample(SKCanvas canvas, int width, int height)
        {
            // load the image from the embedded resource stream
            using (var stream = new SKManagedStream(SampleMedia.Images.ColorWheel))
                using (var source = SKBitmap.Decode(stream))
                {
                    var matrix = SKMatrix.MakeRotation(30.0f);

                    // create the shader and paint
                    using (var shader = SKShader.CreateBitmap(source, SKShaderTileMode.Repeat, SKShaderTileMode.Repeat, matrix))
                        using (var paint = new SKPaint())
                        {
                            paint.IsAntialias = true;
                            paint.Shader      = shader;

                            // tile the bitmap
                            canvas.Clear(SKColors.White);
                            canvas.DrawPaint(paint);
                        }
                }
        }
コード例 #26
0
        void OnCanvasViewPaintSurface(object sender, SKPaintSurfaceEventArgs args)
        {
            SKImageInfo info    = args.Info;
            SKSurface   surface = args.Surface;
            SKCanvas    canvas  = surface.Canvas;

            canvas.Clear();

            float size   = Math.Min(info.Width, info.Height);
            float radius = 0.4f * size;
            float offset = size / 2 - radius;

            // Translate to center
            canvas.Translate(info.Width / 2, info.Height / 2);

            using (SKPath path = new SKPath())
            {
                path.AddCircle(-offset, -offset, radius);
                canvas.ClipPath(path, SKClipOperation.Intersect);

                path.Reset();
                path.AddCircle(-offset, offset, radius);
                canvas.ClipPath(path, SKClipOperation.Intersect);

                path.Reset();
                path.AddCircle(offset, -offset, radius);
                canvas.ClipPath(path, SKClipOperation.Intersect);

                path.Reset();
                path.AddCircle(offset, offset, radius);
                canvas.ClipPath(path, SKClipOperation.Intersect);

                using (SKPaint paint = new SKPaint())
                {
                    paint.Style = SKPaintStyle.Fill;
                    paint.Color = SKColors.Blue;
                    canvas.DrawPaint(paint);
                }
            }
        }
コード例 #27
0
        private void DrawSended(SKCanvas canvas, SKSurface surface, SKImageInfo info)
        {
            using (var image = surface.Snapshot())
                using (var data = image.Encode(SKEncodedImageFormat.Png, 80))
                    using (var stream = File.OpenWrite(System.IO.Path.Combine("drawSaved", "1.png")))
                    {
                        data.SaveTo(stream);
                    }
            var paint = new SKPaint
            {
                Style       = SKPaintStyle.Stroke,
                Color       = new SKColor(50, 50, 50),
                TextSize    = 70,
                IsAntialias = true,
            };

            canvas.Clear();
            canvas.DrawPaint(new SKPaint {
                Color = new SKColor(255, 255, 255)
            });
            canvas.DrawText("Dessin envoyé", info.Width / 3 - 30, info.Height / 2 - 40, paint);
            canvas.DrawText("En attente des autres joueurs", info.Width / 6 - 80, info.Height / 2 + 50, paint);
        }
コード例 #28
0
        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);
        }
コード例 #29
0
ファイル: XfermodeSample.cs プロジェクト: vecalion/SkiaSharp
        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);
                                        }
                                    }
                                }
        }
コード例 #30
0
        public static void Draw()
        {
            const int beatsPerBar = 4;
            const int nbBars      = 2;
            const int unitPerBeat = 2;
            var       allBeats    = nbBars * beatsPerBar * unitPerBeat;
            const int blockHeight = 24;
            const int blockWidth  = 32;

            //const int heightInBlocks = 8;

            const int separator = 1;

            string[] instru    = new string[] { "HH", "SN", "T1", "CR", "RD" };
            var      upColor   = new SKColor(25, 146, 191);
            var      downColor = new SKColor(37, 92, 123);
            var      gradient  = SKShader.CreateLinearGradient(new SKPoint(0, 0), new SKPoint(0, 200), new[] { upColor, downColor }, null, SKShaderTileMode.Mirror);

            using (var headerPaint = new SKPaint())
            {
                headerPaint.Color         = SKColors.White;
                headerPaint.IsAntialias   = true;
                headerPaint.FakeBoldText  = false;
                headerPaint.IsDither      = false;
                headerPaint.StrokeWidth   = 1;
                headerPaint.Style         = SKPaintStyle.StrokeAndFill;
                headerPaint.Typeface      = SKTypeface.FromFamilyName("Arial Black", SKTypefaceStyle.Normal);
                headerPaint.LcdRenderText = true;

                headerPaint.TextAlign = SKTextAlign.Left;
                headerPaint.TextSize  = 24;

                var headerWidth = instru.Max(i => headerPaint.MeasureText(i)) + 4;

                using (var surface = SKSurface.Create((allBeats + 1) * blockWidth + (int)Math.Ceiling(headerWidth), (instru.Length + 2) * (blockHeight + separator), SKImageInfo.PlatformColorType, SKAlphaType.Premul))
                {
                    SKCanvas myCanvas = surface.Canvas;

                    using (var backgroundPaint = new SKPaint())
                    {
                        backgroundPaint.Shader = gradient;
                        myCanvas.DrawPaint(backgroundPaint);
                    }

                    var gridTop    = blockHeight + separator;
                    var gridBottom = (blockHeight + separator) * (instru.Length) + gridTop;
                    var gridLeft   = headerWidth;
                    var gridRight  = gridLeft + allBeats * blockWidth;
                    var height     = gridTop - 1;

                    var fadeOut = SKShader.CreateLinearGradient(new SKPoint(0, 0), new SKPoint(headerWidth, 0), new[] { new SKColor(255, 255, 255, 0), SKColors.White }, null, SKShaderTileMode.Clamp);

                    myCanvas.DrawLine(gridLeft, height + 1, gridRight, height + 1, headerPaint);
                    headerPaint.Shader = fadeOut;
                    myCanvas.DrawLine(0, height + 1, headerWidth, height + 1, headerPaint);
                    headerPaint.Shader = null;



                    height += blockHeight + separator;

                    for (var index = 0; index < instru.Length; ++index)
                    {
                        myCanvas.DrawText(instru[index], 0, height - 2, headerPaint);
                        myCanvas.DrawLine(gridLeft, height + 1, gridRight, height + 1, headerPaint);
                        headerPaint.Shader = fadeOut;
                        myCanvas.DrawLine(0, height + 1, headerWidth, height + 1, headerPaint);
                        headerPaint.Shader = null;
                        height            += blockHeight + separator;
                    }

                    myCanvas.DrawLine(headerWidth, gridTop, headerWidth, gridBottom, headerPaint);
                    var x = headerWidth + blockWidth;
                    for (var beatIndex = 1; beatIndex <= allBeats; ++beatIndex)
                    {
                        myCanvas.DrawLine(x, gridTop, x, gridBottom, headerPaint);
                        if (beatIndex % unitPerBeat == 1)
                        {
                            var fullBeatIndex = ((beatIndex - 1) / unitPerBeat) % beatsPerBar + 1;
                            var numberSize    = headerPaint.MeasureText(fullBeatIndex.ToString());
                            var left          = x - blockWidth / 2 - numberSize / 2;
                            myCanvas.DrawText(fullBeatIndex.ToString(), left, gridTop - 4, headerPaint);
                        }
                        x += blockWidth;
                    }
                    // Your drawing code goes here.
                    using (var img = surface.Snapshot())
                    {
                        using (var data = img.Encode(SKEncodedImageFormat.Png, 80))
                        {
                            // save the data to a stream
                            using (var stream = System.IO.File.OpenWrite(@"C:\Temp\img.png"))
                            {
                                data.SaveTo(stream);
                            }
                        }
                    }
                }
            }
        }