示例#1
0
 public Paint toPaint()
 {
     return(new Paint {
         color = this.color,
         maskFilter = MaskFilter.blur(BlurStyle.normal, this.blurSigma)
     });
 }
示例#2
0
        void drawPicture()
        {
            var pictureRecorder = new PictureRecorder();
            var canvas          = new RecorderCanvas(pictureRecorder);

            var paint = new Paint {
                color = new Color(0xFFFF0000),
            };

            var path = new Path();

            path.moveTo(10, 10);
            path.lineTo(10, 110);
            path.lineTo(90, 110);
            path.lineTo(100, 10);
            path.close();
            canvas.drawPath(path, paint);

            paint = new Paint {
                color = new Color(0xFFFFFF00),
            };

            var rect   = Unity.UIWidgets.ui.Rect.fromLTWH(10, 150, 100, 100);
            var rrect  = RRect.fromRectAndCorners(rect, 0, 4, 8, 16);
            var rect1  = Unity.UIWidgets.ui.Rect.fromLTWH(18, 152, 88, 92);
            var rrect1 = RRect.fromRectAndCorners(rect1, 0, 4, 8, 16);

            canvas.drawDRRect(rrect, rrect1, paint);

            canvas.rotate(-45 * Mathf.PI / 180, new Offset(150, 150));

            paint = new Paint {
                color      = new Color(0xFF00FFFF),
                maskFilter = MaskFilter.blur(BlurStyle.normal, 3),
            };
            canvas.drawRect(
                Unity.UIWidgets.ui.Rect.fromLTWH(150, 150, 110, 120),
                paint);

            var picture = pictureRecorder.endRecording();

            Debug.Log("picture.paintBounds: " + picture.paintBounds);

            var editorCanvas = new CommandBufferCanvas(this._renderTexture, Window.instance.devicePixelRatio,
                                                       this._meshPool);

            editorCanvas.drawPicture(picture);

            editorCanvas.rotate(-15 * Mathf.PI / 180);
            editorCanvas.translate(100, 100);
            editorCanvas.drawPicture(picture);
            editorCanvas.flush();
        }
示例#3
0
        void drawRectShadow()
        {
            var canvas = new CommandBufferCanvas(this._renderTexture, Window.instance.devicePixelRatio,
                                                 this._meshPool);

            var paint = new Paint {
                color      = new Color(0xFF00FF00),
                maskFilter = MaskFilter.blur(BlurStyle.normal, 3),
            };

            canvas.clipRect(Unity.UIWidgets.ui.Rect.fromLTWH(25, 25, 300, 300));

            canvas.rotate(-Mathf.PI / 8.0f);

            canvas.drawRect(
                Unity.UIWidgets.ui.Rect.fromLTWH(10, 10, 100, 100),
                paint);

            paint = new Paint {
                color       = new Color(0xFFFFFF00),
                maskFilter  = MaskFilter.blur(BlurStyle.normal, 5),
                style       = PaintingStyle.stroke,
                strokeWidth = 55,
                shader      = Gradient.linear(new Offset(10, 10), new Offset(180, 180), new List <Color>()
                {
                    Colors.red, Colors.green, Colors.yellow
                }, null, TileMode.clamp)
            };

            canvas.drawRect(
                Unity.UIWidgets.ui.Rect.fromLTWH(10, 150, 200, 200),
                paint);

            canvas.drawImage(new Image(texture6, true),
                             new Offset(50, 150),
                             paint);

            canvas.flush();
        }
示例#4
0
        void drawLine()
        {
            var canvas = new CommandBufferCanvas(this._renderTexture, Window.instance.devicePixelRatio,
                                                 this._meshPool);

            var paint = new Paint {
                color       = new Color(0xFFFF0000),
                style       = PaintingStyle.stroke,
                strokeWidth = 10,
                shader      = Gradient.linear(new Offset(10, 10), new Offset(180, 180), new List <Color>()
                {
                    Colors.red, Colors.green, Colors.yellow
                }, null, TileMode.clamp)
            };

            canvas.drawLine(
                new Offset(10, 20),
                new Offset(50, 20),
                paint);

            canvas.drawLine(
                new Offset(10, 10),
                new Offset(100, 100),
                paint);

            canvas.drawLine(
                new Offset(10, 10),
                new Offset(10, 50),
                paint);

            canvas.drawLine(
                new Offset(40, 10),
                new Offset(90, 10),
                paint);


            canvas.drawArc(Unity.UIWidgets.ui.Rect.fromLTWH(200, 200, 100, 100), Mathf.PI / 4,
                           -Mathf.PI / 2 + Mathf.PI * 4 - 1, true, paint);

            paint.maskFilter  = MaskFilter.blur(BlurStyle.normal, 1);
            paint.strokeWidth = 4;

            canvas.drawLine(
                new Offset(40, 20),
                new Offset(120, 190),
                paint);

            canvas.scale(3);
            TextBlobBuilder builder = new TextBlobBuilder();
            string          text    = "This is a text blob";

            builder.allocRunPos(new TextStyle(), text, 0, text.Length);
            builder.setBounds(Unity.UIWidgets.ui.Rect.fromLTWH(-10, -20, 200, 50));
            builder.positions = new Vector2d[] {
                new Vector2d(10, 0),
                new Vector2d(20, 0),
                new Vector2d(30, 0),
                new Vector2d(40, 0),
                new Vector2d(50, 0),
                new Vector2d(60, 0),
                new Vector2d(70, 0),
                new Vector2d(80, 0),
                new Vector2d(90, 0),
                new Vector2d(100, 0),
                new Vector2d(110, 0),
                new Vector2d(120, 0),
                new Vector2d(130, 0),
                new Vector2d(140, 0),
                new Vector2d(150, 0),
                new Vector2d(160, 0),
                new Vector2d(170, 0),
                new Vector2d(180, 0),
                new Vector2d(190, 0),
            };

            var textBlob = builder.make();

            canvas.drawTextBlob(textBlob, new Offset(100, 100), new Paint {
                color      = Colors.black,
                maskFilter = MaskFilter.blur(BlurStyle.normal, 5),
            });
            canvas.drawTextBlob(textBlob, new Offset(100, 100), paint);

            canvas.drawLine(
                new Offset(10, 30),
                new Offset(10, 60),
                new Paint()
            {
                style = PaintingStyle.stroke, strokeWidth = 0.1f
            });

            canvas.drawLine(
                new Offset(20, 30),
                new Offset(20, 60),
                new Paint()
            {
                style = PaintingStyle.stroke, strokeWidth = 0.333f
            });

            canvas.flush();
        }
示例#5
0
        void drawLine()
        {
            var canvas = new CommandBufferCanvas(this._renderTexture, (float)Window.instance.devicePixelRatio, this._meshPool);

            var paint = new Paint {
                color       = new Color(0xFFFF0000),
                style       = PaintingStyle.stroke,
                strokeWidth = 10,
                shader      = Gradient.linear(new Offset(10, 10), new Offset(180, 180), new List <Color>()
                {
                    Colors.red, Colors.green, Colors.yellow
                }, null, TileMode.clamp)
            };

            canvas.drawLine(
                new Offset(10, 20),
                new Offset(50, 20),
                paint);

            canvas.drawLine(
                new Offset(10, 10),
                new Offset(100, 100),
                paint);

            canvas.drawLine(
                new Offset(10, 10),
                new Offset(10, 50),
                paint);

            canvas.drawLine(
                new Offset(40, 10),
                new Offset(90, 10),
                paint);

            paint.maskFilter  = MaskFilter.blur(BlurStyle.normal, 1);
            paint.strokeWidth = 4;

            canvas.drawLine(
                new Offset(40, 20),
                new Offset(120, 190),
                paint);

            canvas.scale(3);
            TextBlob textBlob = new TextBlob("This is a text blob", 0, 19, new Vector2d[] {
                new Vector2d(10, 0),
                new Vector2d(20, 0),
                new Vector2d(30, 0),
                new Vector2d(40, 0),
                new Vector2d(50, 0),
                new Vector2d(60, 0),
                new Vector2d(70, 0),
                new Vector2d(80, 0),
                new Vector2d(90, 0),
                new Vector2d(100, 0),
                new Vector2d(110, 0),
                new Vector2d(120, 0),
                new Vector2d(130, 0),
                new Vector2d(140, 0),
                new Vector2d(150, 0),
                new Vector2d(160, 0),
                new Vector2d(170, 0),
                new Vector2d(180, 0),
                new Vector2d(190, 0),
            }, Unity.UIWidgets.ui.Rect.fromLTWH(0, 0, 200, 50), new TextStyle());

            canvas.drawTextBlob(textBlob, new Offset(100, 100), paint);

            canvas.drawLine(
                new Offset(10, 30),
                new Offset(10, 60),
                new Paint()
            {
                style = PaintingStyle.stroke, strokeWidth = 0.1
            });

            canvas.drawLine(
                new Offset(20, 30),
                new Offset(20, 60),
                new Paint()
            {
                style = PaintingStyle.stroke, strokeWidth = 0.333
            });

            canvas.flush();
        }
示例#6
0
        public override void debugPaint(PaintingContext context, Offset offset)
        {
            D.assert(() => {
                if (D.debugPaintSizeEnabled)
                {
                    float strokeWidth = Mathf.Min(4.0f, geometry.paintExtent / 30.0f);
                    Paint paint       = new Paint();
                    paint.color       = new Color(0xFF33CC33);
                    paint.strokeWidth = strokeWidth;
                    paint.style       = PaintingStyle.stroke;
                    paint.maskFilter  = MaskFilter.blur(BlurStyle.solid, strokeWidth);
                    float arrowExtent = geometry.paintExtent;
                    float padding     = Mathf.Max(2.0f, strokeWidth);
                    Canvas canvas     = context.canvas;
                    canvas.drawCircle(
                        offset.translate(padding, padding),
                        padding * 0.5f,
                        paint
                        );
                    switch (constraints.axis)
                    {
                    case Axis.vertical:
                        canvas.drawLine(
                            offset,
                            offset.translate(constraints.crossAxisExtent, 0.0f),
                            paint
                            );
                        _debugDrawArrow(
                            canvas,
                            paint,
                            offset.translate(constraints.crossAxisExtent * 1.0f / 4.0f, padding),
                            offset.translate(constraints.crossAxisExtent * 1.0f / 4.0f,
                                             (arrowExtent - padding)),
                            constraints.normalizedGrowthDirection
                            );
                        _debugDrawArrow(
                            canvas,
                            paint,
                            offset.translate(constraints.crossAxisExtent * 3.0f / 4.0f, padding),
                            offset.translate(constraints.crossAxisExtent * 3.0f / 4.0f,
                                             (arrowExtent - padding)),
                            constraints.normalizedGrowthDirection
                            );
                        break;

                    case Axis.horizontal:
                        canvas.drawLine(
                            offset,
                            offset.translate(0.0f, constraints.crossAxisExtent),
                            paint
                            );
                        _debugDrawArrow(
                            canvas,
                            paint,
                            offset.translate(padding, constraints.crossAxisExtent * 1.0f / 4.0f),
                            offset.translate((arrowExtent - padding),
                                             constraints.crossAxisExtent * 1.0f / 4.0f),
                            constraints.normalizedGrowthDirection
                            );
                        _debugDrawArrow(
                            canvas,
                            paint,
                            offset.translate(padding, constraints.crossAxisExtent * 3.0f / 4.0f),
                            offset.translate((arrowExtent - padding),
                                             constraints.crossAxisExtent * 3.0f / 4.0f),
                            constraints.normalizedGrowthDirection
                            );
                        break;
                    }
                }

                return(true);
            });
        }