Merge 30157b5dea into 435c8b75eb

Updates #2640

examples/vector/main.go

@@ -44,7 +44,17 @@ const (
 	screenHeight = 480
 )
 
-func drawEbitenText(screen *ebiten.Image, x, y int, aa bool, line bool) {
+type Game struct {
+	counter int
+
+	aa   bool
+	line bool
+
+	vertices []ebiten.Vertex
+	indices  []uint16
+}
+
+func (g *Game) drawEbitenText(screen *ebiten.Image, x, y int, aa bool, line bool) {
 	var path vector.Path
 
 	// E
@@ -116,26 +126,24 @@ func drawEbitenText(screen *ebiten.Image, x, y int, aa bool, line bool) {
 	path.LineTo(290, 20)
 	path.Close()
 
-	var vs []ebiten.Vertex
-	var is []uint16
 	if line {
 		op := &vector.StrokeOptions{}
 		op.Width = 5
 		op.LineJoin = vector.LineJoinRound
-		vs, is = path.AppendVerticesAndIndicesForStroke(nil, nil, op)
+		g.vertices, g.indices = path.AppendVerticesAndIndicesForStroke(g.vertices[:0], g.indices[:0], op)
 	} else {
-		vs, is = path.AppendVerticesAndIndicesForFilling(nil, nil)
+		g.vertices, g.indices = path.AppendVerticesAndIndicesForFilling(g.vertices[:0], g.indices[:0])
 	}
 
-	for i := range vs {
-		vs[i].DstX = (vs[i].DstX + float32(x))
-		vs[i].DstY = (vs[i].DstY + float32(y))
-		vs[i].SrcX = 1
-		vs[i].SrcY = 1
-		vs[i].ColorR = 0xdb / float32(0xff)
-		vs[i].ColorG = 0x56 / float32(0xff)
-		vs[i].ColorB = 0x20 / float32(0xff)
-		vs[i].ColorA = 1
+	for i := range g.vertices {
+		g.vertices[i].DstX = (g.vertices[i].DstX + float32(x))
+		g.vertices[i].DstY = (g.vertices[i].DstY + float32(y))
+		g.vertices[i].SrcX = 1
+		g.vertices[i].SrcY = 1
+		g.vertices[i].ColorR = 0xdb / float32(0xff)
+		g.vertices[i].ColorG = 0x56 / float32(0xff)
+		g.vertices[i].ColorB = 0x20 / float32(0xff)
+		g.vertices[i].ColorA = 1
 	}
 
 	op := &ebiten.DrawTrianglesOptions{}
@@ -150,10 +158,10 @@ func drawEbitenText(screen *ebiten.Image, x, y int, aa bool, line bool) {
 	// For simplicity, this example always uses FillRuleNonZero, whichever strokes or filling is done.
 	op.FillRule = ebiten.FillRuleNonZero
 
-	screen.DrawTriangles(vs, is, whiteSubImage, op)
+	screen.DrawTriangles(g.vertices, g.indices, whiteSubImage, op)
 }
 
-func drawEbitenLogo(screen *ebiten.Image, x, y int, aa bool, line bool) {
+func (g *Game) drawEbitenLogo(screen *ebiten.Image, x, y int, aa bool, line bool) {
 	const unit = 16
 
 	var path vector.Path
@@ -179,35 +187,33 @@ func drawEbitenLogo(screen *ebiten.Image, x, y int, aa bool, line bool) {
 	path.LineTo(unit, 4*unit)
 	path.Close()
 
-	var vs []ebiten.Vertex
-	var is []uint16
 	if line {
 		op := &vector.StrokeOptions{}
 		op.Width = 5
 		op.LineJoin = vector.LineJoinRound
-		vs, is = path.AppendVerticesAndIndicesForStroke(nil, nil, op)
+		g.vertices, g.indices = path.AppendVerticesAndIndicesForStroke(g.vertices[:0], g.indices[:0], op)
 	} else {
-		vs, is = path.AppendVerticesAndIndicesForFilling(nil, nil)
+		g.vertices, g.indices = path.AppendVerticesAndIndicesForFilling(g.vertices[:0], g.indices[:0])
 	}
 
-	for i := range vs {
-		vs[i].DstX = (vs[i].DstX + float32(x))
-		vs[i].DstY = (vs[i].DstY + float32(y))
-		vs[i].SrcX = 1
-		vs[i].SrcY = 1
-		vs[i].ColorR = 0xdb / float32(0xff)
-		vs[i].ColorG = 0x56 / float32(0xff)
-		vs[i].ColorB = 0x20 / float32(0xff)
-		vs[i].ColorA = 1
+	for i := range g.vertices {
+		g.vertices[i].DstX = (g.vertices[i].DstX + float32(x))
+		g.vertices[i].DstY = (g.vertices[i].DstY + float32(y))
+		g.vertices[i].SrcX = 1
+		g.vertices[i].SrcY = 1
+		g.vertices[i].ColorR = 0xdb / float32(0xff)
+		g.vertices[i].ColorG = 0x56 / float32(0xff)
+		g.vertices[i].ColorB = 0x20 / float32(0xff)
+		g.vertices[i].ColorA = 1
 	}
 
 	op := &ebiten.DrawTrianglesOptions{}
 	op.AntiAlias = aa
 	op.FillRule = ebiten.FillRuleNonZero
-	screen.DrawTriangles(vs, is, whiteSubImage, op)
+	screen.DrawTriangles(g.vertices, g.indices, whiteSubImage, op)
 }
 
-func drawArc(screen *ebiten.Image, count int, aa bool, line bool) {
+func (g *Game) drawArc(screen *ebiten.Image, count int, aa bool, line bool) {
 	var path vector.Path
 
 	path.MoveTo(350, 100)
@@ -223,37 +229,35 @@ func drawArc(screen *ebiten.Image, count int, aa bool, line bool) {
 	path.Arc(550, 100, 50, float32(theta1), float32(theta2), vector.Clockwise)
 	path.Close()
 
-	var vs []ebiten.Vertex
-	var is []uint16
 	if line {
 		op := &vector.StrokeOptions{}
 		op.Width = 5
 		op.LineJoin = vector.LineJoinRound
-		vs, is = path.AppendVerticesAndIndicesForStroke(nil, nil, op)
+		g.vertices, g.indices = path.AppendVerticesAndIndicesForStroke(g.vertices[:0], g.indices[:0], op)
 	} else {
-		vs, is = path.AppendVerticesAndIndicesForFilling(nil, nil)
+		g.vertices, g.indices = path.AppendVerticesAndIndicesForFilling(g.vertices[:0], g.indices[:0])
 	}
 
-	for i := range vs {
-		vs[i].SrcX = 1
-		vs[i].SrcY = 1
-		vs[i].ColorR = 0x33 / float32(0xff)
-		vs[i].ColorG = 0xcc / float32(0xff)
-		vs[i].ColorB = 0x66 / float32(0xff)
-		vs[i].ColorA = 1
+	for i := range g.vertices {
+		g.vertices[i].SrcX = 1
+		g.vertices[i].SrcY = 1
+		g.vertices[i].ColorR = 0x33 / float32(0xff)
+		g.vertices[i].ColorG = 0xcc / float32(0xff)
+		g.vertices[i].ColorB = 0x66 / float32(0xff)
+		g.vertices[i].ColorA = 1
 	}
 
 	op := &ebiten.DrawTrianglesOptions{}
 	op.AntiAlias = aa
 	op.FillRule = ebiten.FillRuleNonZero
-	screen.DrawTriangles(vs, is, whiteSubImage, op)
+	screen.DrawTriangles(g.vertices, g.indices, whiteSubImage, op)
 }
 
 func maxCounter(index int) int {
 	return 128 + (17*index+32)%64
 }
 
-func drawWave(screen *ebiten.Image, counter int, aa bool, line bool) {
+func (g *Game) drawWave(screen *ebiten.Image, counter int, aa bool, line bool) {
 	var path vector.Path
 
 	const npoints = 8
@@ -278,37 +282,28 @@ func drawWave(screen *ebiten.Image, counter int, aa bool, line bool) {
 	path.LineTo(screenWidth, screenHeight)
 	path.LineTo(0, screenHeight)
 
-	var vs []ebiten.Vertex
-	var is []uint16
 	if line {
 		op := &vector.StrokeOptions{}
 		op.Width = 5
 		op.LineJoin = vector.LineJoinRound
-		vs, is = path.AppendVerticesAndIndicesForStroke(nil, nil, op)
+		g.vertices, g.indices = path.AppendVerticesAndIndicesForStroke(g.vertices[:0], g.indices[:0], op)
 	} else {
-		vs, is = path.AppendVerticesAndIndicesForFilling(nil, nil)
+		g.vertices, g.indices = path.AppendVerticesAndIndicesForFilling(g.vertices[:0], g.indices[:0])
 	}
 
-	for i := range vs {
-		vs[i].SrcX = 1
-		vs[i].SrcY = 1
-		vs[i].ColorR = 0x33 / float32(0xff)
-		vs[i].ColorG = 0x66 / float32(0xff)
-		vs[i].ColorB = 0xff / float32(0xff)
-		vs[i].ColorA = 1
+	for i := range g.vertices {
+		g.vertices[i].SrcX = 1
+		g.vertices[i].SrcY = 1
+		g.vertices[i].ColorR = 0x33 / float32(0xff)
+		g.vertices[i].ColorG = 0x66 / float32(0xff)
+		g.vertices[i].ColorB = 0xff / float32(0xff)
+		g.vertices[i].ColorA = 1
 	}
 
 	op := &ebiten.DrawTrianglesOptions{}
 	op.AntiAlias = aa
 	op.FillRule = ebiten.FillRuleNonZero
-	screen.DrawTriangles(vs, is, whiteSubImage, op)
-}
-
-type Game struct {
-	counter int
-
-	aa   bool
-	line bool
+	screen.DrawTriangles(g.vertices, g.indices, whiteSubImage, op)
 }
 
 func (g *Game) Update() error {
@@ -331,10 +326,10 @@ func (g *Game) Draw(screen *ebiten.Image) {
 	dst := screen
 
 	dst.Fill(color.RGBA{0xe0, 0xe0, 0xe0, 0xff})
-	drawEbitenText(dst, 0, 50, g.aa, g.line)
-	drawEbitenLogo(dst, 20, 150, g.aa, g.line)
-	drawArc(dst, g.counter, g.aa, g.line)
-	drawWave(dst, g.counter, g.aa, g.line)
+	g.drawEbitenText(dst, 0, 50, g.aa, g.line)
+	g.drawEbitenLogo(dst, 20, 150, g.aa, g.line)
+	g.drawArc(dst, g.counter, g.aa, g.line)
+	g.drawWave(dst, g.counter, g.aa, g.line)
 
 	msg := fmt.Sprintf("TPS: %0.2f\nFPS: %0.2f", ebiten.ActualTPS(), ebiten.ActualFPS())
 	msg += "\nPress A to switch anti-alias."

image.go

@@ -247,7 +247,7 @@ func (i *Image) DrawImage(img *Image, options *DrawImageOptions) {
 	colorm, cr, cg, cb, ca := colorMToScale(options.ColorM.affineColorM())
 	cr, cg, cb, ca = options.ColorScale.apply(cr, cg, cb, ca)
 	vs := i.ensureTmpVertices(4 * graphics.VertexFloatCount)
-	graphics.QuadVertices(vs, float32(sx0), float32(sy0), float32(sx1), float32(sy1), a, b, c, d, tx, ty, cr, cg, cb, ca)
+	graphics.QuadVerticesFromSrcAndMatrix(vs, float32(sx0), float32(sy0), float32(sx1), float32(sy1), a, b, c, d, tx, ty, cr, cg, cb, ca)
 	is := graphics.QuadIndices()
 
 	srcs := [graphics.ShaderSrcImageCount]*ui.Image{img.image}
@@ -829,7 +829,7 @@ func (i *Image) DrawRectShader(width, height int, shader *Shader, options *DrawR
 	vs := i.ensureTmpVertices(4 * graphics.VertexFloatCount)
 
 	// Do not use srcRegions[0].Dx() and srcRegions[0].Dy() as these might be empty.
-	graphics.QuadVertices(vs,
+	graphics.QuadVerticesFromSrcAndMatrix(vs,
 		float32(srcRegions[0].Min.X), float32(srcRegions[0].Min.Y),
 		float32(srcRegions[0].Min.X+width), float32(srcRegions[0].Min.Y+height),
 		a, b, c, d, tx, ty, cr, cg, cb, ca)

image_test.go

@@ -662,6 +662,59 @@ func BenchmarkDrawImage(b *testing.B) {
 	}
 }
 
+func BenchmarkDrawTriangles(b *testing.B) {
+	const w, h = 16, 16
+	img0 := ebiten.NewImage(w, h)
+	img1 := ebiten.NewImage(w, h)
+	op := &ebiten.DrawTrianglesOptions{}
+	vs := []ebiten.Vertex{
+		{
+			DstX:   0,
+			DstY:   0,
+			SrcX:   0,
+			SrcY:   0,
+			ColorR: 1,
+			ColorG: 1,
+			ColorB: 1,
+			ColorA: 1,
+		},
+		{
+			DstX:   w,
+			DstY:   0,
+			SrcX:   w,
+			SrcY:   0,
+			ColorR: 1,
+			ColorG: 1,
+			ColorB: 1,
+			ColorA: 1,
+		},
+		{
+			DstX:   0,
+			DstY:   h,
+			SrcX:   0,
+			SrcY:   h,
+			ColorR: 1,
+			ColorG: 1,
+			ColorB: 1,
+			ColorA: 1,
+		},
+		{
+			DstX:   w,
+			DstY:   h,
+			SrcX:   w,
+			SrcY:   h,
+			ColorR: 1,
+			ColorG: 1,
+			ColorB: 1,
+			ColorA: 1,
+		},
+	}
+	is := []uint16{0, 1, 2, 1, 2, 3}
+	for i := 0; i < b.N; i++ {
+		img0.DrawTriangles(vs, is, img1, op)
+	}
+}
+
 func TestImageLinearGraduation(t *testing.T) {
 	img0 := ebiten.NewImage(2, 2)
 	img0.WritePixels([]byte{

internal/atlas/image.go

@@ -43,16 +43,6 @@ func min(a, b int) int {
 	return b
 }
 
-// quadVertices returns vertices to render a quad. These values are passed to graphicscommand.Image.
-func quadVertices(dx0, dy0, dx1, dy1, sx0, sy0, sx1, sy1, cr, cg, cb, ca float32) []float32 {
-	return []float32{
-		dx0, dy0, sx0, sy0, cr, cg, cb, ca,
-		dx1, dy0, sx1, sy0, cr, cg, cb, ca,
-		dx0, dy1, sx0, sy1, cr, cg, cb, ca,
-		dx1, dy1, sx1, sy1, cr, cg, cb, ca,
-	}
-}
-
 func appendDeferred(f func()) {
 	deferredM.Lock()
 	defer deferredM.Unlock()
@@ -149,7 +139,8 @@ func (b *backend) extendIfNeeded(width, height int) {
 
 	srcs := [graphics.ShaderSrcImageCount]*graphicscommand.Image{b.image}
 	sw, sh := b.image.InternalSize()
-	vs := quadVertices(0, 0, float32(sw), float32(sh), 0, 0, float32(sw), float32(sh), 1, 1, 1, 1)
+	vs := make([]float32, 4*graphics.VertexFloatCount)
+	graphics.QuadVerticesFromDstAndSrc(vs, 0, 0, float32(sw), float32(sh), 0, 0, float32(sw), float32(sh), 1, 1, 1, 1)
 	is := graphics.QuadIndices()
 	dr := image.Rect(0, 0, sw, sh)
 	newImg.DrawTriangles(srcs, vs, is, graphicsdriver.BlendCopy, dr, [graphics.ShaderSrcImageCount]image.Rectangle{}, NearestFilterShader.ensureShader(), nil, graphicsdriver.FillRuleFillAll)
@@ -174,7 +165,8 @@ func newClearedImage(width, height int, screen bool) *graphicscommand.Image {
 }
 
 func clearImage(i *graphicscommand.Image, region image.Rectangle) {
-	vs := quadVertices(float32(region.Min.X), float32(region.Min.Y), float32(region.Max.X), float32(region.Max.Y), 0, 0, 0, 0, 0, 0, 0, 0)
+	vs := make([]float32, 4*graphics.VertexFloatCount)
+	graphics.QuadVerticesFromDstAndSrc(vs, float32(region.Min.X), float32(region.Min.Y), float32(region.Max.X), float32(region.Max.Y), 0, 0, 0, 0, 0, 0, 0, 0)
 	is := graphics.QuadIndices()
 	i.DrawTriangles([graphics.ShaderSrcImageCount]*graphicscommand.Image{}, vs, is, graphicsdriver.BlendClear, region, [graphics.ShaderSrcImageCount]image.Rectangle{}, clearShader.ensureShader(), nil, graphicsdriver.FillRuleFillAll)
 }
@@ -353,7 +345,7 @@ func (i *Image) ensureIsolatedFromSource(backends []*backend) {
 
 	w, h := float32(i.width), float32(i.height)
 	vs := make([]float32, 4*graphics.VertexFloatCount)
-	graphics.QuadVertices(vs, 0, 0, w, h, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1)
+	graphics.QuadVerticesFromDstAndSrc(vs, 0, 0, w, h, 0, 0, w, h, 1, 1, 1, 1)
 	is := graphics.QuadIndices()
 	dr := image.Rect(0, 0, i.width, i.height)
 
@@ -384,7 +376,7 @@ func (i *Image) putOnSourceBackend() {
 
 	w, h := float32(i.width), float32(i.height)
 	vs := make([]float32, 4*graphics.VertexFloatCount)
-	graphics.QuadVertices(vs, 0, 0, w, h, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1)
+	graphics.QuadVerticesFromDstAndSrc(vs, 0, 0, w, h, 0, 0, w, h, 1, 1, 1, 1)
 	is := graphics.QuadIndices()
 	dr := image.Rect(0, 0, i.width, i.height)
 	newI.drawTriangles([graphics.ShaderSrcImageCount]*Image{i}, vs, is, graphicsdriver.BlendCopy, dr, [graphics.ShaderSrcImageCount]image.Rectangle{}, NearestFilterShader, nil, graphicsdriver.FillRuleFillAll)

internal/atlas/image_test.go

@@ -50,12 +50,9 @@ func quadVertices(sw, sh, x, y int, scalex float32) []float32 {
 	sy0 := float32(0)
 	sx1 := float32(sw)
 	sy1 := float32(sh)
-	return []float32{
-		dx0, dy0, sx0, sy0, 1, 1, 1, 1,
-		dx1, dy0, sx1, sy0, 1, 1, 1, 1,
-		dx0, dy1, sx0, sy1, 1, 1, 1, 1,
-		dx1, dy1, sx1, sy1, 1, 1, 1, 1,
-	}
+	vs := make([]float32, 4*graphics.VertexFloatCount)
+	graphics.QuadVerticesFromDstAndSrc(vs, dx0, dy0, dx1, dy1, sx0, sy0, sx1, sy1, 1, 1, 1, 1)
+	return vs
 }
 
 const bigSize = 2049

internal/buffered/image.go

@@ -246,45 +246,51 @@ func (i *Image) syncPixelsIfNeeded() {
 		cbf := float32(c[2]) / 0xff
 		caf := float32(c[3]) / 0xff
 
-		vs[graphics.VertexFloatCount*4*idx] = dx
-		vs[graphics.VertexFloatCount*4*idx+1] = dy
-		vs[graphics.VertexFloatCount*4*idx+2] = sx
-		vs[graphics.VertexFloatCount*4*idx+3] = sy
-		vs[graphics.VertexFloatCount*4*idx+4] = crf
-		vs[graphics.VertexFloatCount*4*idx+5] = cgf
-		vs[graphics.VertexFloatCount*4*idx+6] = cbf
-		vs[graphics.VertexFloatCount*4*idx+7] = caf
-		vs[graphics.VertexFloatCount*4*idx+8] = dx + 1
-		vs[graphics.VertexFloatCount*4*idx+9] = dy
-		vs[graphics.VertexFloatCount*4*idx+10] = sx + 1
-		vs[graphics.VertexFloatCount*4*idx+11] = sy
-		vs[graphics.VertexFloatCount*4*idx+12] = crf
-		vs[graphics.VertexFloatCount*4*idx+13] = cgf
-		vs[graphics.VertexFloatCount*4*idx+14] = cbf
-		vs[graphics.VertexFloatCount*4*idx+15] = caf
-		vs[graphics.VertexFloatCount*4*idx+16] = dx
-		vs[graphics.VertexFloatCount*4*idx+17] = dy + 1
-		vs[graphics.VertexFloatCount*4*idx+18] = sx
-		vs[graphics.VertexFloatCount*4*idx+19] = sy + 1
-		vs[graphics.VertexFloatCount*4*idx+20] = crf
-		vs[graphics.VertexFloatCount*4*idx+21] = cgf
-		vs[graphics.VertexFloatCount*4*idx+22] = cbf
-		vs[graphics.VertexFloatCount*4*idx+23] = caf
-		vs[graphics.VertexFloatCount*4*idx+24] = dx + 1
-		vs[graphics.VertexFloatCount*4*idx+25] = dy + 1
-		vs[graphics.VertexFloatCount*4*idx+26] = sx + 1
-		vs[graphics.VertexFloatCount*4*idx+27] = sy + 1
-		vs[graphics.VertexFloatCount*4*idx+28] = crf
-		vs[graphics.VertexFloatCount*4*idx+29] = cgf
-		vs[graphics.VertexFloatCount*4*idx+30] = cbf
-		vs[graphics.VertexFloatCount*4*idx+31] = caf
+		vidx := 4 * idx
+		iidx := 6 * idx
 
-		is[6*idx] = uint32(4 * idx)
-		is[6*idx+1] = uint32(4*idx + 1)
-		is[6*idx+2] = uint32(4*idx + 2)
-		is[6*idx+3] = uint32(4*idx + 1)
-		is[6*idx+4] = uint32(4*idx + 2)
-		is[6*idx+5] = uint32(4*idx + 3)
+		vs[graphics.VertexFloatCount*vidx] = dx
+		vs[graphics.VertexFloatCount*vidx+1] = dy
+		vs[graphics.VertexFloatCount*vidx+2] = sx
+		vs[graphics.VertexFloatCount*vidx+3] = sy
+		vs[graphics.VertexFloatCount*vidx+4] = crf
+		vs[graphics.VertexFloatCount*vidx+5] = cgf
+		vs[graphics.VertexFloatCount*vidx+6] = cbf
+		vs[graphics.VertexFloatCount*vidx+7] = caf
+
+		vs[graphics.VertexFloatCount*(vidx+1)] = dx + 1
+		vs[graphics.VertexFloatCount*(vidx+1)+1] = dy
+		vs[graphics.VertexFloatCount*(vidx+1)+2] = sx + 1
+		vs[graphics.VertexFloatCount*(vidx+1)+3] = sy
+		vs[graphics.VertexFloatCount*(vidx+1)+4] = crf
+		vs[graphics.VertexFloatCount*(vidx+1)+5] = cgf
+		vs[graphics.VertexFloatCount*(vidx+1)+6] = cbf
+		vs[graphics.VertexFloatCount*(vidx+1)+7] = caf
+
+		vs[graphics.VertexFloatCount*(vidx+2)] = dx
+		vs[graphics.VertexFloatCount*(vidx+2)+1] = dy + 1
+		vs[graphics.VertexFloatCount*(vidx+2)+2] = sx
+		vs[graphics.VertexFloatCount*(vidx+2)+3] = sy + 1
+		vs[graphics.VertexFloatCount*(vidx+2)+4] = crf
+		vs[graphics.VertexFloatCount*(vidx+2)+5] = cgf
+		vs[graphics.VertexFloatCount*(vidx+2)+6] = cbf
+		vs[graphics.VertexFloatCount*(vidx+2)+7] = caf
+
+		vs[graphics.VertexFloatCount*(vidx+3)] = dx + 1
+		vs[graphics.VertexFloatCount*(vidx+3)+1] = dy + 1
+		vs[graphics.VertexFloatCount*(vidx+3)+2] = sx + 1
+		vs[graphics.VertexFloatCount*(vidx+3)+3] = sy + 1
+		vs[graphics.VertexFloatCount*(vidx+3)+4] = crf
+		vs[graphics.VertexFloatCount*(vidx+3)+5] = cgf
+		vs[graphics.VertexFloatCount*(vidx+3)+6] = cbf
+		vs[graphics.VertexFloatCount*(vidx+3)+7] = caf
+
+		is[iidx] = uint32(vidx)
+		is[iidx+1] = uint32(vidx + 1)
+		is[iidx+2] = uint32(vidx + 2)
+		is[iidx+3] = uint32(vidx + 1)
+		is[iidx+4] = uint32(vidx + 2)
+		is[iidx+5] = uint32(vidx + 3)
 
 		idx++
 	}

internal/buffered/image_test.go

@@ -52,7 +52,7 @@ func TestUnsyncedPixels(t *testing.T) {
 	// Flush unsynced pixel cache.
 	src := buffered.NewImage(16, 16, atlas.ImageTypeRegular)
 	vs := make([]float32, 4*graphics.VertexFloatCount)
-	graphics.QuadVertices(vs, 0, 0, 16, 16, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1)
+	graphics.QuadVerticesFromDstAndSrc(vs, 0, 0, 16, 16, 0, 0, 16, 16, 1, 1, 1, 1)
 	is := graphics.QuadIndices()
 	dr := image.Rect(0, 0, 16, 16)
 	sr := [graphics.ShaderSrcImageCount]image.Rectangle{image.Rect(0, 0, 16, 16)}

internal/graphics/vertex.go

@@ -50,16 +50,16 @@ func QuadIndices() []uint32 {
 	return quadIndices
 }
 
-// QuadVertices sets a float32 slice for a quadrangle.
-// QuadVertices sets a slice that never overlaps with other slices returned this function,
-// and users can do optimization based on this fact.
-func QuadVertices(dst []float32, sx0, sy0, sx1, sy1 float32, a, b, c, d, tx, ty float32, cr, cg, cb, ca float32) {
+// QuadVerticesFromSrcAndMatrix sets a float32 slice for a quadrangle.
+func QuadVerticesFromSrcAndMatrix(dst []float32, sx0, sy0, sx1, sy1 float32, a, b, c, d, tx, ty float32, cr, cg, cb, ca float32) {
 	x := sx1 - sx0
 	y := sy1 - sy0
 	ax, by, cx, dy := a*x, b*y, c*x, d*y
 	u0, v0, u1, v1 := sx0, sy0, sx1, sy1
 
 	// This function is very performance-sensitive and implement in a very dumb way.
+
+	// Remove the boundary check.
 	dst = dst[:4*VertexFloatCount]
 
 	dst[0] = adjustDestinationPixel(tx)
@@ -71,32 +71,79 @@ func QuadVertices(dst []float32, sx0, sy0, sx1, sy1 float32, a, b, c, d, tx, ty
 	dst[6] = cb
 	dst[7] = ca
 
-	dst[8] = adjustDestinationPixel(ax + tx)
-	dst[9] = adjustDestinationPixel(cx + ty)
-	dst[10] = u1
-	dst[11] = v0
-	dst[12] = cr
-	dst[13] = cg
-	dst[14] = cb
-	dst[15] = ca
+	dst[VertexFloatCount] = adjustDestinationPixel(ax + tx)
+	dst[VertexFloatCount+1] = adjustDestinationPixel(cx + ty)
+	dst[VertexFloatCount+2] = u1
+	dst[VertexFloatCount+3] = v0
+	dst[VertexFloatCount+4] = cr
+	dst[VertexFloatCount+5] = cg
+	dst[VertexFloatCount+6] = cb
+	dst[VertexFloatCount+7] = ca
 
-	dst[16] = adjustDestinationPixel(by + tx)
-	dst[17] = adjustDestinationPixel(dy + ty)
-	dst[18] = u0
-	dst[19] = v1
-	dst[20] = cr
-	dst[21] = cg
-	dst[22] = cb
-	dst[23] = ca
+	dst[2*VertexFloatCount] = adjustDestinationPixel(by + tx)
+	dst[2*VertexFloatCount+1] = adjustDestinationPixel(dy + ty)
+	dst[2*VertexFloatCount+2] = u0
+	dst[2*VertexFloatCount+3] = v1
+	dst[2*VertexFloatCount+4] = cr
+	dst[2*VertexFloatCount+5] = cg
+	dst[2*VertexFloatCount+6] = cb
+	dst[2*VertexFloatCount+7] = ca
 
-	dst[24] = adjustDestinationPixel(ax + by + tx)
-	dst[25] = adjustDestinationPixel(cx + dy + ty)
-	dst[26] = u1
-	dst[27] = v1
-	dst[28] = cr
-	dst[29] = cg
-	dst[30] = cb
-	dst[31] = ca
+	dst[3*VertexFloatCount] = adjustDestinationPixel(ax + by + tx)
+	dst[3*VertexFloatCount+1] = adjustDestinationPixel(cx + dy + ty)
+	dst[3*VertexFloatCount+2] = u1
+	dst[3*VertexFloatCount+3] = v1
+	dst[3*VertexFloatCount+4] = cr
+	dst[3*VertexFloatCount+5] = cg
+	dst[3*VertexFloatCount+6] = cb
+	dst[3*VertexFloatCount+7] = ca
+}
+
+// QuadVerticesFromDstAndSrc sets a float32 slice for a quadrangle.
+func QuadVerticesFromDstAndSrc(dst []float32, dx0, dy0, dx1, dy1, sx0, sy0, sx1, sy1, cr, cg, cb, ca float32) {
+	dx0 = adjustDestinationPixel(dx0)
+	dy0 = adjustDestinationPixel(dy0)
+	dx1 = adjustDestinationPixel(dx1)
+	dy1 = adjustDestinationPixel(dy1)
+
+	// Remove the boundary check.
+	dst = dst[:4*VertexFloatCount]
+
+	dst[0] = dx0
+	dst[1] = dy0
+	dst[2] = sx0
+	dst[3] = sy0
+	dst[4] = cr
+	dst[5] = cg
+	dst[6] = cb
+	dst[7] = ca
+
+	dst[VertexFloatCount] = dx1
+	dst[VertexFloatCount+1] = dy0
+	dst[VertexFloatCount+2] = sx1
+	dst[VertexFloatCount+3] = sy0
+	dst[VertexFloatCount+4] = cr
+	dst[VertexFloatCount+5] = cg
+	dst[VertexFloatCount+6] = cb
+	dst[VertexFloatCount+7] = ca
+
+	dst[2*VertexFloatCount] = dx0
+	dst[2*VertexFloatCount+1] = dy1
+	dst[2*VertexFloatCount+2] = sx0
+	dst[2*VertexFloatCount+3] = sy1
+	dst[2*VertexFloatCount+4] = cr
+	dst[2*VertexFloatCount+5] = cg
+	dst[2*VertexFloatCount+6] = cb
+	dst[2*VertexFloatCount+7] = ca
+
+	dst[3*VertexFloatCount] = dx1
+	dst[3*VertexFloatCount+1] = dy1
+	dst[3*VertexFloatCount+2] = sx1
+	dst[3*VertexFloatCount+3] = sy1
+	dst[3*VertexFloatCount+4] = cr
+	dst[3*VertexFloatCount+5] = cg
+	dst[3*VertexFloatCount+6] = cb
+	dst[3*VertexFloatCount+7] = ca
 }
 
 func adjustDestinationPixel(x float32) float32 {

internal/graphicscommand/command.go

@@ -183,9 +183,9 @@ func dstRegionFromVertices(vertices []float32) (minX, minY, maxX, maxY float32)
 	maxX = negInf32
 	maxY = negInf32
 
-	for i := 0; i < len(vertices)/graphics.VertexFloatCount; i++ {
-		x := vertices[graphics.VertexFloatCount*i]
-		y := vertices[graphics.VertexFloatCount*i+1]
+	for i := 0; i < len(vertices); i += graphics.VertexFloatCount {
+		x := vertices[i]
+		y := vertices[i+1]
 		if x < minX {
 			minX = x
 		}

internal/graphicscommand/image_test.go

@@ -43,12 +43,9 @@ func TestMain(m *testing.M) {
 }
 
 func quadVertices(w, h float32) []float32 {
-	return []float32{
-		0, 0, 0, 0, 1, 1, 1, 1,
-		w, 0, w, 0, 1, 1, 1, 1,
-		0, w, 0, h, 1, 1, 1, 1,
-		w, h, w, h, 1, 1, 1, 1,
-	}
+	vs := make([]float32, 8*graphics.VertexFloatCount)
+	graphics.QuadVerticesFromDstAndSrc(vs, 0, 0, w, h, 0, 0, w, h, 1, 1, 1, 1)
+	return vs
 }
 
 func TestClear(t *testing.T) {

internal/graphicsdriver/opengl/graphics_debug.go

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-//go:build ebitenginegldebug
+//go:build !playstation5 && ebitenginegldebug
 
 package opengl
 

internal/graphicsdriver/opengl/graphics_notdebug.go

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-//go:build !ebitenginegldebug
+//go:build !playstation5 && !ebitenginegldebug
 
 package opengl
 

internal/graphicsdriver/opengl/program.go

@@ -53,14 +53,14 @@ func (a *arrayBufferLayout) names() []string {
 	return ns
 }
 
-// totalBytes returns the size in bytes for one element of the array buffer.
-func (a *arrayBufferLayout) totalBytes() int {
+// float32Count returns the total float32 count for one element of the array buffer.
+func (a *arrayBufferLayout) float32Count() int {
 	if a.total != 0 {
 		return a.total
 	}
 	t := 0
 	for _, p := range a.parts {
-		t += floatSizeInBytes * p.num
+		t += p.num
 	}
 	a.total = t
 	return a.total
@@ -71,10 +71,10 @@ func (a *arrayBufferLayout) enable(context *context) {
 	for i := range a.parts {
 		context.ctx.EnableVertexAttribArray(uint32(i))
 	}
-	total := a.totalBytes()
+	total := a.float32Count()
 	offset := 0
 	for i, p := range a.parts {
-		context.ctx.VertexAttribPointer(uint32(i), int32(p.num), gl.FLOAT, false, int32(total), offset)
+		context.ctx.VertexAttribPointer(uint32(i), int32(p.num), gl.FLOAT, false, int32(floatSizeInBytes*total), offset)
 		offset += floatSizeInBytes * p.num
 	}
 }
@@ -88,7 +88,10 @@ func (a *arrayBufferLayout) disable(context *context) {
 }
 
 // theArrayBufferLayout is the array buffer layout for Ebitengine.
-var theArrayBufferLayout = arrayBufferLayout{
+var theArrayBufferLayout arrayBufferLayout
+
+func init() {
+	theArrayBufferLayout = arrayBufferLayout{
 		// Note that GL_MAX_VERTEX_ATTRIBS is at least 16.
 		parts: []arrayBufferLayoutPart{
 			{
@@ -104,12 +107,20 @@ var theArrayBufferLayout = arrayBufferLayout{
 				num:  4,
 			},
 		},
-}
-
-func init() {
-	vertexFloatCount := theArrayBufferLayout.totalBytes() / floatSizeInBytes
-	if graphics.VertexFloatCount != vertexFloatCount {
-		panic(fmt.Sprintf("vertex float num must be %d but %d", graphics.VertexFloatCount, vertexFloatCount))
+	}
+	n := theArrayBufferLayout.float32Count()
+	if n > graphics.VertexFloatCount {
+		panic("opengl: the array buffer layout is too large")
+	}
+	if n < graphics.VertexFloatCount {
+		d := graphics.VertexFloatCount - n
+		if d > 4 {
+			panic("opengl: the array buffer layout is too small")
+		}
+		theArrayBufferLayout.parts = append(theArrayBufferLayout.parts, arrayBufferLayoutPart{
+			name: "A3",
+			num:  d,
+		})
 	}
 }
 

internal/graphicsdriver/playstation5/graphics_playstation5.cpp

@@ -32,8 +32,11 @@ ebitengine_NewScreenFramebufferImage(int *image, int width, int height) {
 
 extern "C" void ebitengine_DisposeImage(int id) {}
 
-extern "C" ebitengine_Error
-ebitengine_DrawTriangles(ebitengine_DrawTrianglesArgs *args) {
+ebitengine_Error
+ebitengine_DrawTriangles(int dst, int *srcs, int srcCount, int shader,
+                         ebitengine_DstRegion *dstRegions, int dstRegionCount,
+                         int indexOffset, ebitengine_Blend blend,
+                         uint32_t *uniforms, int uniformCount, int fillRule) {
   return {};
 }
 

internal/graphicsdriver/playstation5/graphics_playstation5.go

@@ -118,26 +118,24 @@ func (g *Graphics) NewShader(program *shaderir.Program) (graphicsdriver.Shader,
 }
 
 func (g *Graphics) DrawTriangles(dst graphicsdriver.ImageID, srcs [graphics.ShaderSrcImageCount]graphicsdriver.ImageID, shader graphicsdriver.ShaderID, dstRegions []graphicsdriver.DstRegion, indexOffset int, blend graphicsdriver.Blend, uniforms []uint32, fillRule graphicsdriver.FillRule) error {
-	csrcs := make([]C.int, len(srcs))
+	cSrcs := make([]C.int, len(srcs))
 	for i, src := range srcs {
-		csrcs[i] = C.int(src)
+		cSrcs[i] = C.int(src)
 	}
+	defer runtime.KeepAlive(cSrcs)
+
 	cDstRegions := make([]C.ebitengine_DstRegion, len(dstRegions))
+	defer runtime.KeepAlive(cDstRegions)
 	for i, r := range dstRegions {
 		cDstRegions[i] = C.ebitengine_DstRegion{
-			Region: C.ebitengine_Rectangle{
 			MinX:       C.int(r.Region.Min.X),
 			MinY:       C.int(r.Region.Min.Y),
 			MaxX:       C.int(r.Region.Max.X),
 			MaxY:       C.int(r.Region.Max.Y),
-			},
 			IndexCount: C.int(r.IndexCount),
 		}
 	}
-	cUniforms := make([]C.uint32_t, len(uniforms))
-	for i, u := range uniforms {
-		cUniforms[i] = C.uint32_t(u)
-	}
+
 	cBlend := C.ebitengine_Blend{
 		BlendFactorSourceRGB:        C.uint8_t(blend.BlendFactorSourceRGB),
 		BlendFactorSourceAlpha:      C.uint8_t(blend.BlendFactorSourceAlpha),
@@ -147,23 +145,15 @@ func (g *Graphics) DrawTriangles(dst graphicsdriver.ImageID, srcs [graphics.Shad
 		BlendOperationAlpha:         C.uint8_t(blend.BlendOperationAlpha),
 	}
 
-	args := C.ebitengine_DrawTrianglesArgs{
-		Dst:            C.int(dst),
-		Srcs:           &csrcs[0],
-		SrcCount:       C.int(len(csrcs)),
-		Shader:         C.int(shader),
-		DstRegions:     &cDstRegions[0],
-		DstRegionCount: C.int(len(cDstRegions)),
-		IndexOffset:    C.int(indexOffset),
-		Blend:          cBlend,
-		Uniforms:       &cUniforms[0],
-		UniformCount:   C.int(len(cUniforms)),
-		FillRule:       C.int(fillRule),
+	cUniforms := make([]C.uint32_t, len(uniforms))
+	defer runtime.KeepAlive(cUniforms)
+	for i, u := range uniforms {
+		cUniforms[i] = C.uint32_t(u)
 	}
-	if err := C.ebitengine_DrawTriangles(&args); !C.ebitengine_IsErrorNil(&err) {
+
+	if err := C.ebitengine_DrawTriangles(C.int(dst), &cSrcs[0], C.int(len(cSrcs)), C.int(shader), &cDstRegions[0], C.int(len(cDstRegions)), C.int(indexOffset), cBlend, &cUniforms[0], C.int(len(cUniforms)), C.int(fillRule)); !C.ebitengine_IsErrorNil(&err) {
 		return newPlaystation5Error("(*playstation5.Graphics).DrawTriangles", err)
 	}
-	runtime.KeepAlive(args)
 	return nil
 }
 

internal/graphicsdriver/playstation5/graphics_playstation5.h

@@ -34,15 +34,11 @@ static bool ebitengine_IsErrorNil(ebitengine_Error *err) {
   return err->Message == NULL && err->Code == 0;
 }
 
-typedef struct ebitengine_Rectangle {
+typedef struct ebitengine_DstRegion {
   int MinX;
   int MinY;
   int MaxX;
   int MaxY;
-} ebitengine_Rectangle;
-
-typedef struct ebitengine_DstRegion {
-  ebitengine_Rectangle Region;
   int IndexCount;
 } ebitengine_DstRegion;
 
@@ -55,26 +51,17 @@ typedef struct ebitengine_Blend {
   uint8_t BlendOperationAlpha;
 } ebitengine_Blend;
 
-typedef struct ebitengine_DrawTrianglesArgs {
-  int Dst;
-  int *Srcs;
-  int SrcCount;
-  int Shader;
-  ebitengine_DstRegion *DstRegions;
-  int DstRegionCount;
-  int IndexOffset;
-  ebitengine_Blend Blend;
-  uint32_t *Uniforms;
-  int UniformCount;
-  int FillRule;
-} ebitengine_DrawTrianglesArgs;
-
 ebitengine_Error ebitengine_InitializeGraphics(void);
 ebitengine_Error ebitengine_NewImage(int *image, int width, int height);
 ebitengine_Error ebitengine_NewScreenFramebufferImage(int *image, int width,
                                                       int height);
 void ebitengine_DisposeImage(int id);
-ebitengine_Error ebitengine_DrawTriangles(ebitengine_DrawTrianglesArgs *args);
+
+ebitengine_Error
+ebitengine_DrawTriangles(int dst, int *srcs, int srcCount, int shader,
+                         ebitengine_DstRegion *dstRegions, int dstRegionCount,
+                         int indexOffset, ebitengine_Blend blend,
+                         uint32_t *uniforms, int uniformCount, int fillRule);
 
 ebitengine_Error ebitengine_NewShader(int *shader, const char *source);
 void ebitengine_DisposeShader(int id);

internal/mipmap/mipmap.go

@@ -73,20 +73,22 @@ func (m *Mipmap) DrawTriangles(srcs [graphics.ShaderSrcImageCount]*Mipmap, verti
 	level := 0
 	if !canSkipMipmap && srcs[0] != nil && canUseMipmap(srcs[0].imageType) {
 		level = math.MaxInt32
-		for i := 0; i < len(indices)/3; i++ {
-			const n = graphics.VertexFloatCount
-			dx0 := vertices[n*indices[3*i]+0]
-			dy0 := vertices[n*indices[3*i]+1]
-			sx0 := vertices[n*indices[3*i]+2]
-			sy0 := vertices[n*indices[3*i]+3]
-			dx1 := vertices[n*indices[3*i+1]+0]
-			dy1 := vertices[n*indices[3*i+1]+1]
-			sx1 := vertices[n*indices[3*i+1]+2]
-			sy1 := vertices[n*indices[3*i+1]+3]
-			dx2 := vertices[n*indices[3*i+2]+0]
-			dy2 := vertices[n*indices[3*i+2]+1]
-			sx2 := vertices[n*indices[3*i+2]+2]
-			sy2 := vertices[n*indices[3*i+2]+3]
+		for i := 0; i < len(indices); i += 3 {
+			idx0 := indices[i]
+			idx1 := indices[i+1]
+			idx2 := indices[i+2]
+			dx0 := vertices[graphics.VertexFloatCount*idx0]
+			dy0 := vertices[graphics.VertexFloatCount*idx0+1]
+			sx0 := vertices[graphics.VertexFloatCount*idx0+2]
+			sy0 := vertices[graphics.VertexFloatCount*idx0+3]
+			dx1 := vertices[graphics.VertexFloatCount*idx1]
+			dy1 := vertices[graphics.VertexFloatCount*idx1+1]
+			sx1 := vertices[graphics.VertexFloatCount*idx1+2]
+			sy1 := vertices[graphics.VertexFloatCount*idx1+3]
+			dx2 := vertices[graphics.VertexFloatCount*idx2]
+			dy2 := vertices[graphics.VertexFloatCount*idx2+1]
+			sx2 := vertices[graphics.VertexFloatCount*idx2+2]
+			sy2 := vertices[graphics.VertexFloatCount*idx2+3]
 			if l := mipmapLevelFromDistance(dx0, dy0, dx1, dy1, sx0, sy0, sx1, sy1); level > l {
 				level = l
 			}
@@ -109,11 +111,10 @@ func (m *Mipmap) DrawTriangles(srcs [graphics.ShaderSrcImageCount]*Mipmap, verti
 		}
 		if level != 0 {
 			if img := src.level(level); img != nil {
-				const n = graphics.VertexFloatCount
 				s := float32(pow2(level))
-				for i := 0; i < len(vertices)/n; i++ {
-					vertices[i*n+2] /= s
-					vertices[i*n+3] /= s
+				for i := 0; i < len(vertices); i += graphics.VertexFloatCount {
+					vertices[i+2] /= s
+					vertices[i+3] /= s
 				}
 				imgs[i] = img
 				continue
@@ -148,12 +149,10 @@ func (m *Mipmap) level(level int) *buffered.Image {
 
 	var src *buffered.Image
 	vs := make([]float32, 4*graphics.VertexFloatCount)
-	shader := atlas.NearestFilterShader
 	switch {
 	case level == 1:
 		src = m.orig
-		graphics.QuadVertices(vs, 0, 0, float32(m.width), float32(m.height), 0.5, 0, 0, 0.5, 0, 0, 1, 1, 1, 1)
-		shader = atlas.LinearFilterShader
+		graphics.QuadVerticesFromSrcAndMatrix(vs, 0, 0, float32(m.width), float32(m.height), 0.5, 0, 0, 0.5, 0, 0, 1, 1, 1, 1)
 	case level > 1:
 		src = m.level(level - 1)
 		if src == nil {
@@ -162,8 +161,7 @@ func (m *Mipmap) level(level int) *buffered.Image {
 		}
 		w := sizeForLevel(m.width, level-1)
 		h := sizeForLevel(m.height, level-1)
-		graphics.QuadVertices(vs, 0, 0, float32(w), float32(h), 0.5, 0, 0, 0.5, 0, 0, 1, 1, 1, 1)
-		shader = atlas.LinearFilterShader
+		graphics.QuadVerticesFromSrcAndMatrix(vs, 0, 0, float32(w), float32(h), 0.5, 0, 0, 0.5, 0, 0, 1, 1, 1, 1)
 	default:
 		panic(fmt.Sprintf("mipmap: invalid level: %d", level))
 	}
@@ -186,7 +184,7 @@ func (m *Mipmap) level(level int) *buffered.Image {
 	s := buffered.NewImage(w2, h2, m.imageType)
 
 	dstRegion := image.Rect(0, 0, w2, h2)
-	s.DrawTriangles([graphics.ShaderSrcImageCount]*buffered.Image{src}, vs, is, graphicsdriver.BlendCopy, dstRegion, [graphics.ShaderSrcImageCount]image.Rectangle{}, shader, nil, graphicsdriver.FillRuleFillAll)
+	s.DrawTriangles([graphics.ShaderSrcImageCount]*buffered.Image{src}, vs, is, graphicsdriver.BlendCopy, dstRegion, [graphics.ShaderSrcImageCount]image.Rectangle{}, atlas.LinearFilterShader, nil, graphicsdriver.FillRuleFillAll)
 	m.setImg(level, s)
 
 	return m.imgs[level]

internal/ui/image.go

@@ -158,7 +158,7 @@ func (i *Image) Fill(r, g, b, a float32, region image.Rectangle) {
 		i.tmpVerticesForFill = make([]float32, 4*graphics.VertexFloatCount)
 	}
 	// i.tmpVerticesForFill can be reused as this is sent to DrawTriangles immediately.
-	graphics.QuadVertices(
+	graphics.QuadVerticesFromSrcAndMatrix(
 		i.tmpVerticesForFill,
 		1, 1, float32(i.ui.whiteImage.width-1), float32(i.ui.whiteImage.height-1),
 		float32(i.width), 0, 0, float32(i.height), 0, 0,
@@ -235,7 +235,7 @@ func (i *bigOffscreenImage) drawTriangles(srcs [graphics.ShaderSrcImageCount]*Im
 			i.tmpVerticesForCopying = make([]float32, 4*graphics.VertexFloatCount)
 		}
 		// i.tmpVerticesForCopying can be reused as this is sent to DrawTriangles immediately.
-		graphics.QuadVertices(
+		graphics.QuadVerticesFromSrcAndMatrix(
 			i.tmpVerticesForCopying,
 			float32(i.region.Min.X), float32(i.region.Min.Y), float32(i.region.Max.X), float32(i.region.Max.Y),
 			bigOffscreenScale, 0, 0, bigOffscreenScale, 0, 0,
@@ -279,7 +279,7 @@ func (i *bigOffscreenImage) flush() {
 		i.tmpVerticesForFlushing = make([]float32, 4*graphics.VertexFloatCount)
 	}
 	// i.tmpVerticesForFlushing can be reused as this is sent to DrawTriangles in this function.
-	graphics.QuadVertices(
+	graphics.QuadVerticesFromSrcAndMatrix(
 		i.tmpVerticesForFlushing,
 		0, 0, float32(i.region.Dx()*bigOffscreenScale), float32(i.region.Dy()*bigOffscreenScale),
 		1.0/bigOffscreenScale, 0, 0, 1.0/bigOffscreenScale, float32(i.region.Min.X), float32(i.region.Min.Y),

text/v2/atlas.go

@@ -0,0 +1,295 @@
+// Copyright 2024 The Ebitengine Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package text
+
+import (
+	"github.com/hajimehoshi/ebiten/v2"
+	"github.com/hajimehoshi/ebiten/v2/internal/packing"
+)
+
+type glyphAtlas struct {
+	page  *packing.Page
+	image *ebiten.Image
+}
+
+type glyphImage struct {
+	atlas *glyphAtlas
+	node  *packing.Node
+}
+
+func (i *glyphImage) Image() *ebiten.Image {
+	return i.atlas.image.SubImage(i.node.Region()).(*ebiten.Image)
+}
+
+func newGlyphAtlas() *glyphAtlas {
+	return &glyphAtlas{
+		// Note: 128x128 is arbitrary, maybe a better value can be inferred
+		// from the font size or something
+		page:  packing.NewPage(128, 128, 1024), // TODO: not 1024
+		image: ebiten.NewImage(128, 128),
+	}
+}
+
+func (g *glyphAtlas) NewImage(w, h int) *glyphImage {
+	n := g.page.Alloc(w, h)
+	pw, ph := g.page.Size()
+	if pw > g.image.Bounds().Dx() || ph > g.image.Bounds().Dy() {
+		newImage := ebiten.NewImage(pw, ph)
+		newImage.DrawImage(g.image, nil)
+		g.image = newImage
+	}
+
+	return &glyphImage{
+		atlas: g,
+		node:  n,
+	}
+}
+
+func (g *glyphAtlas) Free(img *glyphImage) {
+	g.page.Free(img.node)
+}
+
+type drawRange struct {
+	atlas *glyphAtlas
+	end   int
+}
+
+// drawList stores triangle versions of DrawImage calls when
+// all images are sub-images of an atlas.
+// Temporary vertices and indices can be re-used after calling
+// Flush, so it is more efficient to keep a reference to a drawList
+// instead of creating a new one every frame.
+type drawList struct {
+	ranges []drawRange
+	vx     []ebiten.Vertex
+	ix     []uint16
+}
+
+// drawCommand is the equivalent of the regular DrawImageOptions
+// but only including options that will not break batching.
+// Filter, Address, Blend and AntiAlias are determined at Flush()
+type drawCommand struct {
+	Image *glyphImage
+
+	ColorScale ebiten.ColorScale
+	GeoM       ebiten.GeoM
+}
+
+var rectIndices = [6]uint16{0, 1, 2, 1, 2, 3}
+
+type point struct {
+	X, Y float32
+}
+
+func pt(x, y float64) point {
+	return point{
+		X: float32(x),
+		Y: float32(y),
+	}
+}
+
+type rectOpts struct {
+	Dsts         [4]point
+	SrcX0, SrcY0 float32
+	SrcX1, SrcY1 float32
+	R, G, B, A   float32
+}
+
+// adjustDestinationPixel is the original ebitengine implementation found here:
+// https://github.com/hajimehoshi/ebiten/blob/v2.8.0-alpha.1/internal/graphics/vertex.go#L102-L126
+func adjustDestinationPixel(x float32) float32 {
+	// Avoid the center of the pixel, which is problematic (#929, #1171).
+	// Instead, align the vertices with about 1/3 pixels.
+	//
+	// The intention here is roughly this code:
+	//
+	//     float32(math.Floor((float64(x)+1.0/6.0)*3) / 3)
+	//
+	// The actual implementation is more optimized than the above implementation.
+	ix := float32(int(x))
+	if x < 0 && x != ix {
+		ix -= 1
+	}
+	frac := x - ix
+	switch {
+	case frac < 3.0/16.0:
+		return ix
+	case frac < 8.0/16.0:
+		return ix + 5.0/16.0
+	case frac < 13.0/16.0:
+		return ix + 11.0/16.0
+	default:
+		return ix + 16.0/16.0
+	}
+}
+
+func appendRectVerticesIndices(vertices []ebiten.Vertex, indices []uint16, index int, opts *rectOpts) ([]ebiten.Vertex, []uint16) {
+	sx0, sy0, sx1, sy1 := opts.SrcX0, opts.SrcY0, opts.SrcX1, opts.SrcY1
+	r, g, b, a := opts.R, opts.G, opts.B, opts.A
+	vertices = append(vertices,
+		ebiten.Vertex{
+			DstX:   adjustDestinationPixel(opts.Dsts[0].X),
+			DstY:   adjustDestinationPixel(opts.Dsts[0].Y),
+			SrcX:   sx0,
+			SrcY:   sy0,
+			ColorR: r,
+			ColorG: g,
+			ColorB: b,
+			ColorA: a,
+		},
+		ebiten.Vertex{
+			DstX:   adjustDestinationPixel(opts.Dsts[1].X),
+			DstY:   adjustDestinationPixel(opts.Dsts[1].Y),
+			SrcX:   sx1,
+			SrcY:   sy0,
+			ColorR: r,
+			ColorG: g,
+			ColorB: b,
+			ColorA: a,
+		},
+		ebiten.Vertex{
+			DstX:   adjustDestinationPixel(opts.Dsts[2].X),
+			DstY:   adjustDestinationPixel(opts.Dsts[2].Y),
+			SrcX:   sx0,
+			SrcY:   sy1,
+			ColorR: r,
+			ColorG: g,
+			ColorB: b,
+			ColorA: a,
+		},
+		ebiten.Vertex{
+			DstX:   adjustDestinationPixel(opts.Dsts[3].X),
+			DstY:   adjustDestinationPixel(opts.Dsts[3].Y),
+			SrcX:   sx1,
+			SrcY:   sy1,
+			ColorR: r,
+			ColorG: g,
+			ColorB: b,
+			ColorA: a,
+		},
+	)
+
+	indiceCursor := uint16(index * 4)
+	indices = append(indices,
+		rectIndices[0]+indiceCursor,
+		rectIndices[1]+indiceCursor,
+		rectIndices[2]+indiceCursor,
+		rectIndices[3]+indiceCursor,
+		rectIndices[4]+indiceCursor,
+		rectIndices[5]+indiceCursor,
+	)
+
+	return vertices, indices
+}
+
+// Add adds DrawImage commands to the DrawList, images from multiple
+// atlases can be added but they will break the previous batch bound to
+// a different atlas, requiring an additional draw call internally.
+// So, it is better to have the maximum of consecutive DrawCommand images
+// sharing the same atlas.
+func (dl *drawList) Add(commands ...*drawCommand) {
+	if len(commands) == 0 {
+		return
+	}
+
+	var batch *drawRange
+
+	if len(dl.ranges) > 0 {
+		batch = &dl.ranges[len(dl.ranges)-1]
+	} else {
+		dl.ranges = append(dl.ranges, drawRange{
+			atlas: commands[0].Image.atlas,
+		})
+		batch = &dl.ranges[0]
+	}
+	// Add vertices and indices
+	opts := &rectOpts{}
+	for _, cmd := range commands {
+		if cmd.Image.atlas != batch.atlas {
+			dl.ranges = append(dl.ranges, drawRange{
+				atlas: cmd.Image.atlas,
+			})
+			batch = &dl.ranges[len(dl.ranges)-1]
+		}
+
+		// Dst attributes
+		bounds := cmd.Image.node.Region()
+		opts.Dsts[0] = pt(cmd.GeoM.Apply(0, 0))
+		opts.Dsts[1] = pt(cmd.GeoM.Apply(
+			float64(bounds.Dx()), 0,
+		))
+		opts.Dsts[2] = pt(cmd.GeoM.Apply(
+			0, float64(bounds.Dy()),
+		))
+		opts.Dsts[3] = pt(cmd.GeoM.Apply(
+			float64(bounds.Dx()), float64(bounds.Dy()),
+		))
+
+		// Color and source attributes
+		opts.R = cmd.ColorScale.R()
+		opts.G = cmd.ColorScale.G()
+		opts.B = cmd.ColorScale.B()
+		opts.A = cmd.ColorScale.A()
+		opts.SrcX0 = float32(bounds.Min.X)
+		opts.SrcY0 = float32(bounds.Min.Y)
+		opts.SrcX1 = float32(bounds.Max.X)
+		opts.SrcY1 = float32(bounds.Max.Y)
+
+		dl.vx, dl.ix = appendRectVerticesIndices(
+			dl.vx, dl.ix, batch.end, opts,
+		)
+
+		batch.end++
+	}
+}
+
+// DrawOptions are additional options that will be applied to
+// all draw commands from the draw list when calling Flush().
+type drawOptions struct {
+	ColorScaleMode ebiten.ColorScaleMode
+	Blend          ebiten.Blend
+	Filter         ebiten.Filter
+	Address        ebiten.Address
+	AntiAlias      bool
+}
+
+// Flush executes all the draw commands as the smallest possible
+// amount of draw calls, and then clears the list for next uses.
+func (dl *drawList) Flush(dst *ebiten.Image, opts *drawOptions) {
+	var topts *ebiten.DrawTrianglesOptions
+	if opts != nil {
+		topts = &ebiten.DrawTrianglesOptions{
+			ColorScaleMode: opts.ColorScaleMode,
+			Blend:          opts.Blend,
+			Filter:         opts.Filter,
+			Address:        opts.Address,
+			AntiAlias:      opts.AntiAlias,
+		}
+	}
+	index := 0
+	for _, r := range dl.ranges {
+		dst.DrawTriangles(
+			dl.vx[index*4:(index+r.end)*4],
+			dl.ix[index*6:(index+r.end)*6],
+			r.atlas.image,
+			topts,
+		)
+		index += r.end
+	}
+	// Clear buffers
+	dl.ranges = dl.ranges[:0]
+	dl.vx = dl.vx[:0]
+	dl.ix = dl.ix[:0]
+}

text/v2/glyph.go

@@ -18,7 +18,6 @@ import (
 	"math"
 	"sync"
 
-	"github.com/hajimehoshi/ebiten/v2"
 	"github.com/hajimehoshi/ebiten/v2/internal/hook"
 )
 
@@ -38,17 +37,18 @@ func init() {
 }
 
 type glyphImageCacheEntry struct {
-	image *ebiten.Image
+	image *glyphImage
 	atime int64
 }
 
 type glyphImageCache[Key comparable] struct {
+	atlas *glyphAtlas
 	cache map[Key]*glyphImageCacheEntry
 	atime int64
 	m     sync.Mutex
 }
 
-func (g *glyphImageCache[Key]) getOrCreate(face Face, key Key, create func() *ebiten.Image) *ebiten.Image {
+func (g *glyphImageCache[Key]) getOrCreate(face Face, key Key, create func(a *glyphAtlas) *glyphImage) *glyphImage {
 	g.m.Lock()
 	defer g.m.Unlock()
 
@@ -61,10 +61,11 @@ func (g *glyphImageCache[Key]) getOrCreate(face Face, key Key, create func() *eb
 	}
 
 	if g.cache == nil {
+		g.atlas = newGlyphAtlas()
 		g.cache = map[Key]*glyphImageCacheEntry{}
 	}
 
-	img := create()
+	img := create(g.atlas)
 	e = &glyphImageCacheEntry{
 		image: img,
 	}
@@ -91,6 +92,7 @@ func (g *glyphImageCache[Key]) getOrCreate(face Face, key Key, create func() *eb
 					continue
 				}
 				delete(g.cache, key)
+				g.atlas.Free(e.image)
 			}
 		}
 	}

text/v2/gotext.go

@@ -310,11 +310,16 @@ func (g *GoTextFace) appendGlyphsForLine(glyphs []Glyph, line string, indexOffse
 		}))
 		// Append a glyph even if img is nil.
 		// This is necessary to return index information for control characters.
+		var ebitenImage *ebiten.Image
+		if img != nil {
+			ebitenImage = img.Image()
+		}
 		glyphs = append(glyphs, Glyph{
+			img:               img,
 			StartIndexInBytes: indexOffset + glyph.startIndex,
 			EndIndexInBytes:   indexOffset + glyph.endIndex,
 			GID:               uint32(glyph.shapingGlyph.GlyphID),
-			Image:             img,
+			Image:             ebitenImage,
 			X:                 float64(imgX),
 			Y:                 float64(imgY),
 		})
@@ -327,7 +332,7 @@ func (g *GoTextFace) appendGlyphsForLine(glyphs []Glyph, line string, indexOffse
 	return glyphs
 }
 
-func (g *GoTextFace) glyphImage(glyph glyph, origin fixed.Point26_6) (*ebiten.Image, int, int) {
+func (g *GoTextFace) glyphImage(glyph glyph, origin fixed.Point26_6) (*glyphImage, int, int) {
 	if g.direction().isHorizontal() {
 		origin.X = adjustGranularity(origin.X, g)
 		origin.Y &^= ((1 << 6) - 1)
@@ -347,8 +352,8 @@ func (g *GoTextFace) glyphImage(glyph glyph, origin fixed.Point26_6) (*ebiten.Im
 		yoffset:    subpixelOffset.Y,
 		variations: g.ensureVariationsString(),
 	}
-	img := g.Source.getOrCreateGlyphImage(g, key, func() *ebiten.Image {
-		return segmentsToImage(glyph.scaledSegments, subpixelOffset, b)
+	img := g.Source.getOrCreateGlyphImage(g, key, func(a *glyphAtlas) *glyphImage {
+		return segmentsToImage(a, glyph.scaledSegments, subpixelOffset, b)
 	})
 
 	imgX := (origin.X + b.Min.X).Floor()

text/v2/gotextfacesource.go

@@ -26,8 +26,6 @@ import (
 	"github.com/go-text/typesetting/opentype/loader"
 	"github.com/go-text/typesetting/shaping"
 	"golang.org/x/image/math/fixed"
-
-	"github.com/hajimehoshi/ebiten/v2"
 )
 
 type goTextOutputCacheKey struct {
@@ -282,7 +280,7 @@ func (g *GoTextFaceSource) scale(size float64) float64 {
 	return size / float64(g.f.Upem())
 }
 
-func (g *GoTextFaceSource) getOrCreateGlyphImage(goTextFace *GoTextFace, key goTextGlyphImageCacheKey, create func() *ebiten.Image) *ebiten.Image {
+func (g *GoTextFaceSource) getOrCreateGlyphImage(goTextFace *GoTextFace, key goTextGlyphImageCacheKey, create func(a *glyphAtlas) *glyphImage) *glyphImage {
 	if g.glyphImageCache == nil {
 		g.glyphImageCache = map[float64]*glyphImageCache[goTextGlyphImageCacheKey]{}
 	}

text/v2/gotextseg.go

@@ -19,11 +19,11 @@ import (
 	"image/draw"
 	"math"
 
-	"github.com/go-text/typesetting/opentype/api"
-	"golang.org/x/image/math/fixed"
 	gvector "golang.org/x/image/vector"
 
-	"github.com/hajimehoshi/ebiten/v2"
+	"github.com/go-text/typesetting/opentype/api"
+	"golang.org/x/image/math/fixed"
+
 	"github.com/hajimehoshi/ebiten/v2/vector"
 )
 
@@ -75,7 +75,7 @@ func segmentsToBounds(segs []api.Segment) fixed.Rectangle26_6 {
 	}
 }
 
-func segmentsToImage(segs []api.Segment, subpixelOffset fixed.Point26_6, glyphBounds fixed.Rectangle26_6) *ebiten.Image {
+func segmentsToImage(a *glyphAtlas, segs []api.Segment, subpixelOffset fixed.Point26_6, glyphBounds fixed.Rectangle26_6) *glyphImage {
 	if len(segs) == 0 {
 		return nil
 	}
@@ -122,7 +122,10 @@ func segmentsToImage(segs []api.Segment, subpixelOffset fixed.Point26_6, glyphBo
 
 	dst := image.NewRGBA(image.Rect(0, 0, w, h))
 	rast.Draw(dst, dst.Bounds(), image.Opaque, image.Point{})
-	return ebiten.NewImageFromImage(dst)
+	img := a.NewImage(w, h)
+	img.Image().WritePixels(dst.Pix)
+
+	return img
 }
 
 func appendVectorPathFromSegments(path *vector.Path, segs []api.Segment, x, y float32) {

text/v2/gox.go

@@ -21,7 +21,6 @@ import (
 	"golang.org/x/image/font"
 	"golang.org/x/image/math/fixed"
 
-	"github.com/hajimehoshi/ebiten/v2"
 	"github.com/hajimehoshi/ebiten/v2/vector"
 )
 
@@ -119,9 +118,10 @@ func (s *GoXFace) appendGlyphsForLine(glyphs []Glyph, line string, indexOffset i
 		// Append a glyph even if img is nil.
 		// This is necessary to return index information for control characters.
 		glyphs = append(glyphs, Glyph{
+			img:               img,
 			StartIndexInBytes: indexOffset + i,
 			EndIndexInBytes:   indexOffset + i + size,
-			Image:             img,
+			Image:             img.Image(),
 			X:                 float64(imgX),
 			Y:                 float64(imgY),
 		})
@@ -132,7 +132,7 @@ func (s *GoXFace) appendGlyphsForLine(glyphs []Glyph, line string, indexOffset i
 	return glyphs
 }
 
-func (s *GoXFace) glyphImage(r rune, origin fixed.Point26_6) (*ebiten.Image, int, int, fixed.Int26_6) {
+func (s *GoXFace) glyphImage(r rune, origin fixed.Point26_6) (*glyphImage, int, int, fixed.Int26_6) {
 	// Assume that GoXFace's direction is always horizontal.
 	origin.X = adjustGranularity(origin.X, s)
 	origin.Y &^= ((1 << 6) - 1)
@@ -146,15 +146,15 @@ func (s *GoXFace) glyphImage(r rune, origin fixed.Point26_6) (*ebiten.Image, int
 		rune:    r,
 		xoffset: subpixelOffset.X,
 	}
-	img := s.glyphImageCache.getOrCreate(s, key, func() *ebiten.Image {
-		return s.glyphImageImpl(r, subpixelOffset, b)
+	img := s.glyphImageCache.getOrCreate(s, key, func(a *glyphAtlas) *glyphImage {
+		return s.glyphImageImpl(a, r, subpixelOffset, b)
 	})
 	imgX := (origin.X + b.Min.X).Floor()
 	imgY := (origin.Y + b.Min.Y).Floor()
 	return img, imgX, imgY, a
 }
 
-func (s *GoXFace) glyphImageImpl(r rune, subpixelOffset fixed.Point26_6, glyphBounds fixed.Rectangle26_6) *ebiten.Image {
+func (s *GoXFace) glyphImageImpl(a *glyphAtlas, r rune, subpixelOffset fixed.Point26_6, glyphBounds fixed.Rectangle26_6) *glyphImage {
 	w, h := (glyphBounds.Max.X - glyphBounds.Min.X).Ceil(), (glyphBounds.Max.Y - glyphBounds.Min.Y).Ceil()
 	if w == 0 || h == 0 {
 		return nil
@@ -178,7 +178,10 @@ func (s *GoXFace) glyphImageImpl(r rune, subpixelOffset fixed.Point26_6, glyphBo
 	}
 	d.DrawString(string(r))
 
-	return ebiten.NewImageFromImage(rgba)
+	img := a.NewImage(w, h)
+	img.Image().WritePixels(rgba.Pix)
+
+	return img
 }
 
 // direction implements Face.

text/v2/layout.go

@@ -111,15 +111,24 @@ func Draw(dst *ebiten.Image, text string, face Face, options *DrawOptions) {
 
 	geoM := drawOp.GeoM
 
+	dl := &drawList{}
+	dc := &drawCommand{}
 	for _, g := range AppendGlyphs(nil, text, face, &layoutOp) {
 		if g.Image == nil {
 			continue
 		}
-		drawOp.GeoM.Reset()
-		drawOp.GeoM.Translate(g.X, g.Y)
-		drawOp.GeoM.Concat(geoM)
-		dst.DrawImage(g.Image, &drawOp)
+		dc.GeoM.Reset()
+		dc.GeoM.Translate(g.X, g.Y)
+		dc.GeoM.Concat(geoM)
+		dc.ColorScale = drawOp.ColorScale
+		dc.Image = g.img
+		dl.Add(dc)
 	}
+	dl.Flush(dst, &drawOptions{
+		Blend:          drawOp.Blend,
+		Filter:         drawOp.Filter,
+		ColorScaleMode: ebiten.ColorScaleModePremultipliedAlpha,
+	})
 }
 
 // AppendGlyphs appends glyphs to the given slice and returns a slice.

text/v2/text.go

@@ -115,6 +115,11 @@ func adjustGranularity(x fixed.Int26_6, face Face) fixed.Int26_6 {
 
 // Glyph represents one glyph to render.
 type Glyph struct {
+	// Image is a rasterized glyph image.
+	// Image is a grayscale image i.e. RGBA values are the same.
+	// Image should be used as a render source and should not be modified.
+	img *glyphImage
+
 	// StartIndexInBytes is the start index in bytes for the given string at AppendGlyphs.
 	StartIndexInBytes int
 

vector/export_test.go

@@ -0,0 +1,32 @@
+// Copyright 2024 The Ebitengine Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package vector
+
+type Point struct {
+	X, Y float32
+}
+
+func IsPointCloseToSegment(p, p0, p1 Point, allow float32) bool {
+	return isPointCloseToSegment(point{
+		x: p.X,
+		y: p.Y,
+	}, point{
+		x: p0.X,
+		y: p0.Y,
+	}, point{
+		x: p1.X,
+		y: p1.Y,
+	}, allow)
+}

vector/path.go

@@ -31,6 +31,23 @@ const (
 	CounterClockwise
 )
 
+type opType int
+
+const (
+	opTypeMoveTo opType = iota
+	opTypeLineTo
+	opTypeQuadTo
+	opTypeCubicTo
+	opTypeClose
+)
+
+type op struct {
+	typ opType
+	p1  point
+	p2  point
+	p3  point
+}
+
 func abs(x float32) float32 {
 	if x < 0 {
 		return -x
@@ -48,21 +65,18 @@ type subpath struct {
 	closed bool
 }
 
-func (s *subpath) currentPosition() (point, bool) {
-	if len(s.points) == 0 {
-		return point{}, false
-	}
-	if s.closed {
-		return point{}, false
-	}
-	return s.points[len(s.points)-1], true
+// reset resets the subpath.
+// reset doesn't release the allocated memory so that the memory can be reused.
+func (s *subpath) reset() {
+	s.points = s.points[:0]
+	s.closed = false
 }
 
-func (s *subpath) pointCount() int {
+func (s subpath) pointCount() int {
 	return len(s.points)
 }
 
-func (s *subpath) lastPoint() point {
+func (s subpath) lastPoint() point {
 	return s.points[len(s.points)-1]
 }
 
@@ -71,11 +85,13 @@ func (s *subpath) appendPoint(pt point) {
 		panic("vector: a closed subpathment cannot append a new point")
 	}
 
+	if len(s.points) > 0 {
 		// Do not add a too close point to the last point.
 		// This can cause unexpected rendering results.
 		if lp := s.lastPoint(); abs(lp.x-pt.x) < 1e-2 && abs(lp.y-pt.y) < 1e-2 {
 			return
 		}
+	}
 
 	s.points = append(s.points, pt)
 }
@@ -91,15 +107,66 @@ func (s *subpath) close() {
 
 // Path represents a collection of path subpathments.
 type Path struct {
-	subpaths []*subpath
+	ops []op
+
+	subpaths []subpath
+}
+
+// reset resets the path.
+// reset doesn't release the allocated memory so that the memory can be reused.
+func (p *Path) reset() {
+	p.ops = p.ops[:0]
+	p.subpaths = p.subpaths[:0]
+}
+
+func (p *Path) appendNewSubpath(pt point) {
+	if cap(p.subpaths) > len(p.subpaths) {
+		// Reuse the last subpath since the last subpath might have an already allocated slice.
+		p.subpaths = p.subpaths[:len(p.subpaths)+1]
+		p.subpaths[len(p.subpaths)-1].reset()
+		p.subpaths[len(p.subpaths)-1].appendPoint(pt)
+		return
+	}
+	p.subpaths = append(p.subpaths, subpath{
+		points: []point{pt},
+	})
+}
+
+func (p *Path) ensureSubpaths() []subpath {
+	if len(p.subpaths) > 0 || len(p.ops) == 0 {
+		return p.subpaths
+	}
+
+	var cur point
+	for _, op := range p.ops {
+		switch op.typ {
+		case opTypeMoveTo:
+			p.appendNewSubpath(op.p1)
+			cur = op.p1
+		case opTypeLineTo:
+			p.lineTo(op.p1)
+			cur = op.p1
+		case opTypeQuadTo:
+			p.quadTo(cur, op.p1, op.p2, 0)
+			cur = op.p2
+		case opTypeCubicTo:
+			p.cubicTo(cur, op.p1, op.p2, op.p3, 0)
+			cur = op.p3
+		case opTypeClose:
+			p.close()
+			cur = point{}
+		}
+	}
+
+	return p.subpaths
 }
 
 // MoveTo starts a new subpath with the given position (x, y) without adding a subpath,
 func (p *Path) MoveTo(x, y float32) {
-	p.subpaths = append(p.subpaths, &subpath{
-		points: []point{
-			{x: x, y: y},
-		},
+	p.subpaths = p.subpaths[:0]
+	p.ops = append(p.ops, op{
+		typ: opTypeMoveTo,
+		p1:  point{x: x, y: y},
 	})
 }
 
@@ -107,22 +174,52 @@ func (p *Path) MoveTo(x, y float32) {
 // and ends to the given position (x, y).
 // If p doesn't have any subpaths or the last subpath is closed, LineTo sets (x, y) as the start position of a new subpath.
 func (p *Path) LineTo(x, y float32) {
-	if len(p.subpaths) == 0 || p.subpaths[len(p.subpaths)-1].closed {
-		p.subpaths = append(p.subpaths, &subpath{
-			points: []point{
-				{x: x, y: y},
-			},
+	p.subpaths = p.subpaths[:0]
+	p.ops = append(p.ops, op{
+		typ: opTypeLineTo,
+		p1:  point{x: x, y: y},
 	})
-		return
-	}
-
-	p.subpaths[len(p.subpaths)-1].appendPoint(point{x: x, y: y})
 }
 
 // QuadTo adds a quadratic Bézier curve to the path.
 // (x1, y1) is the control point, and (x2, y2) is the destination.
 func (p *Path) QuadTo(x1, y1, x2, y2 float32) {
-	p.quadTo(point{x: x1, y: y1}, point{x: x2, y: y2}, 0)
+	p.subpaths = p.subpaths[:0]
+	p.ops = append(p.ops, op{
+		typ: opTypeQuadTo,
+		p1:  point{x: x1, y: y1},
+		p2:  point{x: x2, y: y2},
+	})
+}
+
+// CubicTo adds a cubic Bézier curve to the path.
+// (x1, y1) and (x2, y2) are the control points, and (x3, y3) is the destination.
+func (p *Path) CubicTo(x1, y1, x2, y2, x3, y3 float32) {
+	p.subpaths = p.subpaths[:0]
+	p.ops = append(p.ops, op{
+		typ: opTypeCubicTo,
+		p1:  point{x: x1, y: y1},
+		p2:  point{x: x2, y: y2},
+		p3:  point{x: x3, y: y3},
+	})
+}
+
+// Close adds a new line from the last position of the current subpath to the first position of the current subpath,
+// and marks the current subpath closed.
+// Following operations for this path will start with a new subpath.
+func (p *Path) Close() {
+	p.subpaths = p.subpaths[:0]
+	p.ops = append(p.ops, op{
+		typ: opTypeClose,
+	})
+}
+
+func (p *Path) lineTo(pt point) {
+	if len(p.subpaths) == 0 || p.subpaths[len(p.subpaths)-1].closed {
+		p.appendNewSubpath(pt)
+		return
+	}
+	p.subpaths[len(p.subpaths)-1].appendPoint(pt)
 }
 
 // lineForTwoPoints returns parameters for a line passing through p0 and p1.
@@ -135,12 +232,17 @@ func lineForTwoPoints(p0, p1 point) (a, b, c float32) {
 }
 
 // isPointCloseToSegment detects the distance between a segment (x0, y0)-(x1, y1) and a point (x, y) is less than allow.
+// If p0 and p1 are the same, isPointCloseToSegment returns true when the distance between p0 and p is less than allow.
 func isPointCloseToSegment(p, p0, p1 point, allow float32) bool {
+	if p0 == p1 {
+		return allow*allow >= (p0.x-p.x)*(p0.x-p.x)+(p0.y-p.y)*(p0.y-p.y)
+	}
+
 	a, b, c := lineForTwoPoints(p0, p1)
 
 	// The distance between a line ax+by+c=0 and (x0, y0) is
 	//     |ax0 + by0 + c| / √(a² + b²)
-	return allow*allow*(a*a+b*b) > (a*p.x+b*p.y+c)*(a*p.x+b*p.y+c)
+	return allow*allow*(a*a+b*b) >= (a*p.x+b*p.y+c)*(a*p.x+b*p.y+c)
 }
 
 // crossingPointForTwoLines returns a crossing point for two lines.
@@ -154,24 +256,13 @@ func crossingPointForTwoLines(p00, p01, p10, p11 point) point {
 	}
 }
 
-func (p *Path) currentPosition() (point, bool) {
-	if len(p.subpaths) == 0 {
-		return point{}, false
-	}
-	return p.subpaths[len(p.subpaths)-1].currentPosition()
-}
-
-func (p *Path) quadTo(p1, p2 point, level int) {
+func (p *Path) quadTo(p0, p1, p2 point, level int) {
 	if level > 10 {
 		return
 	}
 
-	p0, ok := p.currentPosition()
-	if !ok {
-		p0 = p1
-	}
 	if isPointCloseToSegment(p1, p0, p2, 0.5) {
-		p.LineTo(p2.x, p2.y)
+		p.lineTo(p2)
 		return
 	}
 
@@ -187,27 +278,17 @@ func (p *Path) quadTo(p1, p2 point, level int) {
 		x: (p01.x + p12.x) / 2,
 		y: (p01.y + p12.y) / 2,
 	}
-	p.quadTo(p01, p012, level+1)
-	p.quadTo(p12, p2, level+1)
+	p.quadTo(p0, p01, p012, level+1)
+	p.quadTo(p012, p12, p2, level+1)
 }
 
-// CubicTo adds a cubic Bézier curve to the path.
-// (x1, y1) and (x2, y2) are the control points, and (x3, y3) is the destination.
-func (p *Path) CubicTo(x1, y1, x2, y2, x3, y3 float32) {
-	p.cubicTo(point{x: x1, y: y1}, point{x: x2, y: y2}, point{x: x3, y: y3}, 0)
-}
-
-func (p *Path) cubicTo(p1, p2, p3 point, level int) {
+func (p *Path) cubicTo(p0, p1, p2, p3 point, level int) {
 	if level > 10 {
 		return
 	}
 
-	p0, ok := p.currentPosition()
-	if !ok {
-		p0 = p1
-	}
 	if isPointCloseToSegment(p1, p0, p3, 0.5) && isPointCloseToSegment(p2, p0, p3, 0.5) {
-		p.LineTo(p3.x, p3.y)
+		p.lineTo(p3)
 		return
 	}
 
@@ -235,8 +316,8 @@ func (p *Path) cubicTo(p1, p2, p3 point, level int) {
 		x: (p012.x + p123.x) / 2,
 		y: (p012.y + p123.y) / 2,
 	}
-	p.cubicTo(p01, p012, p0123, level+1)
-	p.cubicTo(p123, p23, p3, level+1)
+	p.cubicTo(p0, p01, p012, p0123, level+1)
+	p.cubicTo(p0123, p123, p23, p3, level+1)
 }
 
 func normalize(p point) point {
@@ -248,6 +329,26 @@ func cross(p0, p1 point) float32 {
 	return p0.x*p1.y - p1.x*p0.y
 }
 
+func (p *Path) currentPosition() (point, bool) {
+	if len(p.ops) == 0 {
+		return point{}, false
+	}
+	op := p.ops[len(p.ops)-1]
+	switch op.typ {
+	case opTypeMoveTo:
+		return op.p1, true
+	case opTypeLineTo:
+		return op.p1, true
+	case opTypeQuadTo:
+		return op.p2, true
+	case opTypeCubicTo:
+		return op.p3, true
+	case opTypeClose:
+		return point{}, false
+	}
+	return point{}, false
+}
+
 // ArcTo adds an arc curve to the path.
 // (x1, y1) is the first control point, and (x2, y2) is the second control point.
 func (p *Path) ArcTo(x1, y1, x2, y2, radius float32) {
@@ -362,7 +463,7 @@ func (p *Path) Arc(x, y, radius, startAngle, endAngle float32, dir Direction) {
 	p.LineTo(x0, y0)
 
 	// Calculate the control points for an approximated Bézier curve.
-	// See https://docs.microsoft.com/en-us/xamarin/xamarin-forms/user-interface/graphics/skiasharp/curves/beziers.
+	// See https://learn.microsoft.com/en-us/previous-versions/xamarin/xamarin-forms/user-interface/graphics/skiasharp/curves/beziers.
 	l := radius * float32(math.Tan(da/4)*4/3)
 	var cx0, cy0, cx1, cy1 float32
 	if dir == Clockwise {
@@ -379,15 +480,11 @@ func (p *Path) Arc(x, y, radius, startAngle, endAngle float32, dir Direction) {
 	p.CubicTo(cx0, cy0, cx1, cy1, x1, y1)
 }
 
-// Close adds a new line from the last position of the current subpath to the first position of the current subpath,
-// and marks the current subpath closed.
-// Following operations for this path will start with a new subpath.
-func (p *Path) Close() {
+func (p *Path) close() {
 	if len(p.subpaths) == 0 {
 		return
 	}
-	subpath := p.subpaths[len(p.subpaths)-1]
-	subpath.close()
+	p.subpaths[len(p.subpaths)-1].close()
 }
 
 // AppendVerticesAndIndicesForFilling appends vertices and indices to fill this path and returns them.
@@ -405,7 +502,7 @@ func (p *Path) AppendVerticesAndIndicesForFilling(vertices []ebiten.Vertex, indi
 	// TODO: Add tests.
 
 	base := uint16(len(vertices))
-	for _, subpath := range p.subpaths {
+	for _, subpath := range p.ensureSubpaths() {
 		if subpath.pointCount() < 3 {
 			continue
 		}
@@ -486,12 +583,14 @@ func (p *Path) AppendVerticesAndIndicesForStroke(vertices []ebiten.Vertex, indic
 		return vertices, indices
 	}
 
-	for _, subpath := range p.subpaths {
+	var rects [][4]point
+	var tmpPath Path
+	for _, subpath := range p.ensureSubpaths() {
 		if subpath.pointCount() < 2 {
 			continue
 		}
 
-		var rects [][4]point
+		rects = rects[:0]
 		for i := 0; i < subpath.pointCount()-1; i++ {
 			pt := subpath.points[i]
 
@@ -571,46 +670,49 @@ func (p *Path) AppendVerticesAndIndicesForStroke(vertices []ebiten.Vertex, indic
 				delta := math.Pi - da
 				exceed := float32(math.Abs(1/math.Sin(float64(delta/2)))) > op.MiterLimit
 
-				var quad Path
-				quad.MoveTo(c.x, c.y)
+				// Quadrilateral
+				tmpPath.reset()
+				tmpPath.MoveTo(c.x, c.y)
 				if da < math.Pi {
-					quad.LineTo(rect[1].x, rect[1].y)
+					tmpPath.LineTo(rect[1].x, rect[1].y)
 					if !exceed {
 						pt := crossingPointForTwoLines(rect[0], rect[1], nextRect[0], nextRect[1])
-						quad.LineTo(pt.x, pt.y)
+						tmpPath.LineTo(pt.x, pt.y)
 					}
-					quad.LineTo(nextRect[0].x, nextRect[0].y)
+					tmpPath.LineTo(nextRect[0].x, nextRect[0].y)
 				} else {
-					quad.LineTo(rect[3].x, rect[3].y)
+					tmpPath.LineTo(rect[3].x, rect[3].y)
 					if !exceed {
 						pt := crossingPointForTwoLines(rect[2], rect[3], nextRect[2], nextRect[3])
-						quad.LineTo(pt.x, pt.y)
+						tmpPath.LineTo(pt.x, pt.y)
 					}
-					quad.LineTo(nextRect[2].x, nextRect[2].y)
+					tmpPath.LineTo(nextRect[2].x, nextRect[2].y)
 				}
-				vertices, indices = quad.AppendVerticesAndIndicesForFilling(vertices, indices)
+				vertices, indices = tmpPath.AppendVerticesAndIndicesForFilling(vertices, indices)
 
 			case LineJoinBevel:
-				var tri Path
-				tri.MoveTo(c.x, c.y)
+				// Triangle
+				tmpPath.reset()
+				tmpPath.MoveTo(c.x, c.y)
 				if da < math.Pi {
-					tri.LineTo(rect[1].x, rect[1].y)
-					tri.LineTo(nextRect[0].x, nextRect[0].y)
+					tmpPath.LineTo(rect[1].x, rect[1].y)
+					tmpPath.LineTo(nextRect[0].x, nextRect[0].y)
 				} else {
-					tri.LineTo(rect[3].x, rect[3].y)
-					tri.LineTo(nextRect[2].x, nextRect[2].y)
+					tmpPath.LineTo(rect[3].x, rect[3].y)
+					tmpPath.LineTo(nextRect[2].x, nextRect[2].y)
 				}
-				vertices, indices = tri.AppendVerticesAndIndicesForFilling(vertices, indices)
+				vertices, indices = tmpPath.AppendVerticesAndIndicesForFilling(vertices, indices)
 
 			case LineJoinRound:
-				var arc Path
-				arc.MoveTo(c.x, c.y)
+				// Arc
+				tmpPath.reset()
+				tmpPath.MoveTo(c.x, c.y)
 				if da < math.Pi {
-					arc.Arc(c.x, c.y, op.Width/2, a0, a1, Clockwise)
+					tmpPath.Arc(c.x, c.y, op.Width/2, a0, a1, Clockwise)
 				} else {
-					arc.Arc(c.x, c.y, op.Width/2, a0+math.Pi, a1+math.Pi, CounterClockwise)
+					tmpPath.Arc(c.x, c.y, op.Width/2, a0+math.Pi, a1+math.Pi, CounterClockwise)
 				}
-				vertices, indices = arc.AppendVerticesAndIndicesForFilling(vertices, indices)
+				vertices, indices = tmpPath.AppendVerticesAndIndicesForFilling(vertices, indices)
 			}
 		}
 
@@ -635,10 +737,11 @@ func (p *Path) AppendVerticesAndIndicesForStroke(vertices []ebiten.Vertex, indic
 					y: (startR[0].y + startR[2].y) / 2,
 				}
 				a := float32(math.Atan2(float64(startR[0].y-startR[2].y), float64(startR[0].x-startR[2].x)))
-				var arc Path
-				arc.MoveTo(startR[0].x, startR[0].y)
-				arc.Arc(c.x, c.y, op.Width/2, a, a+math.Pi, CounterClockwise)
-				vertices, indices = arc.AppendVerticesAndIndicesForFilling(vertices, indices)
+				// Arc
+				tmpPath.reset()
+				tmpPath.MoveTo(startR[0].x, startR[0].y)
+				tmpPath.Arc(c.x, c.y, op.Width/2, a, a+math.Pi, CounterClockwise)
+				vertices, indices = tmpPath.AppendVerticesAndIndicesForFilling(vertices, indices)
 			}
 			{
 				c := point{
@@ -646,10 +749,11 @@ func (p *Path) AppendVerticesAndIndicesForStroke(vertices []ebiten.Vertex, indic
 					y: (endR[1].y + endR[3].y) / 2,
 				}
 				a := float32(math.Atan2(float64(endR[1].y-endR[3].y), float64(endR[1].x-endR[3].x)))
-				var arc Path
-				arc.MoveTo(endR[1].x, endR[1].y)
-				arc.Arc(c.x, c.y, op.Width/2, a, a+math.Pi, Clockwise)
-				vertices, indices = arc.AppendVerticesAndIndicesForFilling(vertices, indices)
+				// Arc
+				tmpPath.reset()
+				tmpPath.MoveTo(endR[1].x, endR[1].y)
+				tmpPath.Arc(c.x, c.y, op.Width/2, a, a+math.Pi, Clockwise)
+				vertices, indices = tmpPath.AppendVerticesAndIndicesForFilling(vertices, indices)
 			}
 
 		case LineCapSquare:
@@ -659,24 +763,26 @@ func (p *Path) AppendVerticesAndIndicesForStroke(vertices []ebiten.Vertex, indic
 				s, c := math.Sincos(a)
 				dx, dy := float32(c)*op.Width/2, float32(s)*op.Width/2
 
-				var quad Path
-				quad.MoveTo(startR[0].x, startR[0].y)
-				quad.LineTo(startR[0].x+dx, startR[0].y+dy)
-				quad.LineTo(startR[2].x+dx, startR[2].y+dy)
-				quad.LineTo(startR[2].x, startR[2].y)
-				vertices, indices = quad.AppendVerticesAndIndicesForFilling(vertices, indices)
+				// Quadrilateral
+				tmpPath.reset()
+				tmpPath.MoveTo(startR[0].x, startR[0].y)
+				tmpPath.LineTo(startR[0].x+dx, startR[0].y+dy)
+				tmpPath.LineTo(startR[2].x+dx, startR[2].y+dy)
+				tmpPath.LineTo(startR[2].x, startR[2].y)
+				vertices, indices = tmpPath.AppendVerticesAndIndicesForFilling(vertices, indices)
 			}
 			{
 				a := math.Atan2(float64(endR[1].y-endR[0].y), float64(endR[1].x-endR[0].x))
 				s, c := math.Sincos(a)
 				dx, dy := float32(c)*op.Width/2, float32(s)*op.Width/2
 
-				var quad Path
-				quad.MoveTo(endR[1].x, endR[1].y)
-				quad.LineTo(endR[1].x+dx, endR[1].y+dy)
-				quad.LineTo(endR[3].x+dx, endR[3].y+dy)
-				quad.LineTo(endR[3].x, endR[3].y)
-				vertices, indices = quad.AppendVerticesAndIndicesForFilling(vertices, indices)
+				// Quadrilateral
+				tmpPath.reset()
+				tmpPath.MoveTo(endR[1].x, endR[1].y)
+				tmpPath.LineTo(endR[1].x+dx, endR[1].y+dy)
+				tmpPath.LineTo(endR[3].x+dx, endR[3].y+dy)
+				tmpPath.LineTo(endR[3].x, endR[3].y)
+				vertices, indices = tmpPath.AppendVerticesAndIndicesForFilling(vertices, indices)
 			}
 		}
 	}

vector/path_test.go

@@ -0,0 +1,88 @@
+// Copyright 2024 The Ebitengine Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package vector_test
+
+import (
+	"testing"
+
+	"github.com/hajimehoshi/ebiten/v2/vector"
+)
+
+func TestIsPointCloseToSegment(t *testing.T) {
+	testCases := []struct {
+		p     vector.Point
+		p0    vector.Point
+		p1    vector.Point
+		allow float32
+		want  bool
+	}{
+		{
+			p:     vector.Point{0.5, 0.5},
+			p0:    vector.Point{0, 0},
+			p1:    vector.Point{1, 0},
+			allow: 1,
+			want:  true,
+		},
+		{
+			p:     vector.Point{0.5, 1.5},
+			p0:    vector.Point{0, 0},
+			p1:    vector.Point{1, 0},
+			allow: 1,
+			want:  false,
+		},
+		{
+			p:     vector.Point{0.5, 0.5},
+			p0:    vector.Point{0, 0},
+			p1:    vector.Point{1, 1},
+			allow: 0,
+			want:  true,
+		},
+		{
+			p:     vector.Point{0, 1},
+			p0:    vector.Point{0, 0},
+			p1:    vector.Point{1, 1},
+			allow: 0.7,
+			want:  false,
+		},
+		{
+			p:     vector.Point{0, 1},
+			p0:    vector.Point{0, 0},
+			p1:    vector.Point{1, 1},
+			allow: 0.8,
+			want:  true,
+		},
+		{
+			// p0 and p1 are the same.
+			p:     vector.Point{0, 1},
+			p0:    vector.Point{0.5, 0.5},
+			p1:    vector.Point{0.5, 0.5},
+			allow: 0.7,
+			want:  false,
+		},
+		{
+			// p0 and p1 are the same.
+			p:     vector.Point{0, 1},
+			p0:    vector.Point{0.5, 0.5},
+			p1:    vector.Point{0.5, 0.5},
+			allow: 0.8,
+			want:  true,
+		},
+	}
+	for _, tc := range testCases {
+		if got := vector.IsPointCloseToSegment(tc.p, tc.p0, tc.p1, tc.allow); got != tc.want {
+			t.Errorf("got: %v, want: %v", got, tc.want)
+		}
+	}
+}

vector/util.go

@@ -18,6 +18,7 @@ import (
 	"image"
 	"image/color"
 	"math"
+	"sync"
 
 	"github.com/hajimehoshi/ebiten/v2"
 )
@@ -27,6 +28,18 @@ var (
 	whiteSubImage = whiteImage.SubImage(image.Rect(1, 1, 2, 2)).(*ebiten.Image)
 )
 
+var (
+	cachedVertices []ebiten.Vertex
+	cachedIndices  []uint16
+	cacheM         sync.Mutex
+)
+
+func useCachedVerticesAndIndices(fn func([]ebiten.Vertex, []uint16) (vs []ebiten.Vertex, is []uint16)) {
+	cacheM.Lock()
+	defer cacheM.Unlock()
+	cachedVertices, cachedIndices = fn(cachedVertices[:0], cachedIndices[:0])
+}
+
 func init() {
 	b := whiteImage.Bounds()
 	pix := make([]byte, 4*b.Dx()*b.Dy())
@@ -63,9 +76,12 @@ func StrokeLine(dst *ebiten.Image, x0, y0, x1, y1 float32, strokeWidth float32,
 	path.LineTo(x1, y1)
 	strokeOp := &StrokeOptions{}
 	strokeOp.Width = strokeWidth
-	vs, is := path.AppendVerticesAndIndicesForStroke(nil, nil, strokeOp)
 
+	useCachedVerticesAndIndices(func(vs []ebiten.Vertex, is []uint16) ([]ebiten.Vertex, []uint16) {
+		vs, is = path.AppendVerticesAndIndicesForStroke(vs, is, strokeOp)
 		drawVerticesForUtil(dst, vs, is, clr, antialias)
+		return vs, is
+	})
 }
 
 // DrawFilledRect fills a rectangle with the specified width and color.
@@ -75,9 +91,12 @@ func DrawFilledRect(dst *ebiten.Image, x, y, width, height float32, clr color.Co
 	path.LineTo(x, y+height)
 	path.LineTo(x+width, y+height)
 	path.LineTo(x+width, y)
-	vs, is := path.AppendVerticesAndIndicesForFilling(nil, nil)
 
+	useCachedVerticesAndIndices(func(vs []ebiten.Vertex, is []uint16) ([]ebiten.Vertex, []uint16) {
+		vs, is = path.AppendVerticesAndIndicesForFilling(vs, is)
 		drawVerticesForUtil(dst, vs, is, clr, antialias)
+		return vs, is
+	})
 }
 
 // StrokeRect strokes a rectangle with the specified width and color.
@@ -94,18 +113,24 @@ func StrokeRect(dst *ebiten.Image, x, y, width, height float32, strokeWidth floa
 	strokeOp := &StrokeOptions{}
 	strokeOp.Width = strokeWidth
 	strokeOp.MiterLimit = 10
-	vs, is := path.AppendVerticesAndIndicesForStroke(nil, nil, strokeOp)
 
+	useCachedVerticesAndIndices(func(vs []ebiten.Vertex, is []uint16) ([]ebiten.Vertex, []uint16) {
+		vs, is = path.AppendVerticesAndIndicesForStroke(vs, is, strokeOp)
 		drawVerticesForUtil(dst, vs, is, clr, antialias)
+		return vs, is
+	})
 }
 
 // DrawFilledCircle fills a circle with the specified center position (cx, cy), the radius (r), width and color.
 func DrawFilledCircle(dst *ebiten.Image, cx, cy, r float32, clr color.Color, antialias bool) {
 	var path Path
 	path.Arc(cx, cy, r, 0, 2*math.Pi, Clockwise)
-	vs, is := path.AppendVerticesAndIndicesForFilling(nil, nil)
 
+	useCachedVerticesAndIndices(func(vs []ebiten.Vertex, is []uint16) ([]ebiten.Vertex, []uint16) {
+		vs, is = path.AppendVerticesAndIndicesForFilling(vs, is)
 		drawVerticesForUtil(dst, vs, is, clr, antialias)
+		return vs, is
+	})
 }
 
 // StrokeCircle strokes a circle with the specified center position (cx, cy), the radius (r), width and color.
@@ -118,7 +143,10 @@ func StrokeCircle(dst *ebiten.Image, cx, cy, r float32, strokeWidth float32, clr
 
 	strokeOp := &StrokeOptions{}
 	strokeOp.Width = strokeWidth
-	vs, is := path.AppendVerticesAndIndicesForStroke(nil, nil, strokeOp)
 
+	useCachedVerticesAndIndices(func(vs []ebiten.Vertex, is []uint16) ([]ebiten.Vertex, []uint16) {
+		vs, is = path.AppendVerticesAndIndicesForStroke(vs, is, strokeOp)
 		drawVerticesForUtil(dst, vs, is, clr, antialias)
+		return vs, is
+	})
 }