Merge pull request fyne-io#1130 from andydotxyz/software_circle

Add a simple circle renderer to software painter

internal/painter/draw.go

@@ -0,0 +1,40 @@
+package painter
+
+import (
+	"image"
+	"math"
+
+	"fyne.io/fyne/canvas"
+
+	"github.com/srwiley/rasterx"
+	"golang.org/x/image/math/fixed"
+)
+
+// DrawCircle rasterizes the given circle object into an image.
+// The bounds of the output image will be increased by vectorPad to allow for stroke overflow at the edges.
+// The scale function is used to understand how many pixels are required per unit of size.
+func DrawCircle(circle *canvas.Circle, vectorPad int, scale func(float32) int) *image.RGBA {
+	radius := float32(math.Min(float64(circle.Size().Width), float64(circle.Size().Height)) / 2)
+
+	width := scale(float32(circle.Size().Width + vectorPad*2))
+	height := scale(float32(circle.Size().Height + vectorPad*2))
+	stroke := scale(circle.StrokeWidth)
+
+	raw := image.NewRGBA(image.Rect(0, 0, width, height))
+	scanner := rasterx.NewScannerGV(circle.Size().Width, circle.Size().Height, raw, raw.Bounds())
+
+	if circle.FillColor != nil {
+		filler := rasterx.NewFiller(width, height, scanner)
+		filler.SetColor(circle.FillColor)
+		rasterx.AddCircle(float64(width/2), float64(height/2), float64(scale(radius)), filler)
+		filler.Draw()
+	}
+
+	dasher := rasterx.NewDasher(width, height, scanner)
+	dasher.SetColor(circle.StrokeColor)
+	dasher.SetStroke(fixed.Int26_6(float64(stroke)*64), 0, nil, nil, nil, 0, nil, 0)
+	rasterx.AddCircle(float64(width/2), float64(height/2), float64(scale(radius)), dasher)
+	dasher.Draw()
+
+	return raw
+}

internal/painter/gl/gl_common.go

@@ -46,27 +46,8 @@ func getTexture(object fyne.CanvasObject, creator func(canvasObject fyne.CanvasO
 
 func (p *glPainter) newGlCircleTexture(obj fyne.CanvasObject) Texture {
 	circle := obj.(*canvas.Circle)
-	radius := fyne.Min(circle.Size().Width, circle.Size().Height) / 2
 
-	width := p.textureScaleInt(circle.Size().Width + vectorPad*2)
-	height := p.textureScaleInt(circle.Size().Height + vectorPad*2)
-	stroke := circle.StrokeWidth * p.canvas.Scale() * p.texScale
-
-	raw := image.NewRGBA(image.Rect(0, 0, width, height))
-	scanner := rasterx.NewScannerGV(circle.Size().Width, circle.Size().Height, raw, raw.Bounds())
-
-	if circle.FillColor != nil {
-		filler := rasterx.NewFiller(width, height, scanner)
-		filler.SetColor(circle.FillColor)
-		rasterx.AddCircle(float64(width/2), float64(height/2), float64(p.textureScaleInt(radius)), filler)
-		filler.Draw()
-	}
-
-	dasher := rasterx.NewDasher(width, height, scanner)
-	dasher.SetColor(circle.StrokeColor)
-	dasher.SetStroke(fixed.Int26_6(float64(stroke)*64), 0, nil, nil, nil, 0, nil, 0)
-	rasterx.AddCircle(float64(width/2), float64(height/2), float64(p.textureScaleInt(radius)), dasher)
-	dasher.Draw()
+	raw := painter.DrawCircle(circle, vectorPad, p.textureScale)
 
 	return p.imgToTexture(raw, canvas.ImageScaleSmooth)
 }

internal/painter/gl/painter.go

@@ -80,6 +80,13 @@ func (p *glPainter) textureScaleInt(v int) int {
 	return int(math.Round(float64(v) * float64(p.canvas.Scale()*p.texScale)))
 }
 
+func (p *glPainter) textureScale(v float32) int {
+	if p.canvas.Scale() == 1.0 && p.texScale == 1.0 {
+		return int(v)
+	}
+	return int(math.Round(float64(v) * float64(p.canvas.Scale()*p.texScale)))
+}
+
 var startCacheMonitor = &sync.Once{}
 
 // NewPainter creates a new GL based renderer for the provided canvas.

internal/painter/software/draw.go

@@ -3,6 +3,7 @@ package software
 import (
 	"fmt"
 	"image"
+	"math"
 
 	"fyne.io/fyne"
 	"fyne.io/fyne/canvas"
@@ -21,6 +22,19 @@ type gradient interface {
 	Size() fyne.Size
 }
 
+func drawCircle(c fyne.Canvas, circle *canvas.Circle, pos fyne.Position, base *image.NRGBA, clip image.Rectangle) {
+	scaledWidth := internal.ScaleInt(c, circle.Size().Width)
+	scaledHeight := internal.ScaleInt(c, circle.Size().Height)
+	scaledX, scaledY := internal.ScaleInt(c, pos.X), internal.ScaleInt(c, pos.Y)
+	bounds := clip.Intersect(image.Rect(scaledX, scaledY, scaledX+scaledWidth, scaledY+scaledHeight))
+
+	raw := painter.DrawCircle(circle, 0, func(in float32) int {
+		return int(math.Round(float64(in) * float64(c.Scale())))
+	})
+
+	draw.Draw(base, bounds, raw, image.ZP, draw.Over)
+}
+
 func drawGradient(c fyne.Canvas, g gradient, pos fyne.Position, base *image.NRGBA, clip image.Rectangle) {
 	bounds := g.Size()
 	width := internal.ScaleInt(c, bounds.Width)

internal/painter/software/painter.go

@@ -44,6 +44,8 @@ func (*Painter) Paint(c fyne.Canvas) image.Image {
 			drawText(c, o, pos, base, clip)
 		case gradient:
 			drawGradient(c, o, pos, base, clip)
+		case *canvas.Circle:
+			drawCircle(c, o, pos, base, clip)
 		case *canvas.Rectangle:
 			drawRectangle(c, o, pos, base, clip)
 		case fyne.Widget:

internal/painter/software/painter_test.go

@@ -19,6 +19,19 @@ func makeTestImage(w, h int) image.Image {
 	return internalTest.NewCheckedImage(w, h, w, h)
 }
 
+func TestPainter_paintCircle(t *testing.T) {
+	test.ApplyTheme(t, theme.LightTheme())
+	obj := canvas.NewCircle(color.Black)
+
+	c := test.NewCanvas()
+	c.SetPadded(true)
+	c.SetContent(obj)
+	c.Resize(fyne.NewSize(70+2*theme.Padding(), 70+2*theme.Padding()))
+	p := software.NewPainter()
+
+	test.AssertImageMatches(t, "draw_circle.png", p.Paint(c))
+}
+
 func TestPainter_paintGradient_clipped(t *testing.T) {
 	test.ApplyTheme(t, theme.LightTheme())
 	g := canvas.NewRadialGradient(color.NRGBA{R: 200, A: 255}, color.NRGBA{B: 200, A: 255})