From bd1ef92dc4e7bbcaa494922d91574482b451d3fc Mon Sep 17 00:00:00 2001
From: Elias Naur <mail@eliasnaur.com>
Date: Fri, 8 Oct 2021 17:56:50 +0200
Subject: [PATCH] op/clip: remove complex stroke support

In a discussion with Raph Levien, the author of our compute renderer
implementation, it became clear to me that it's not at all certain that
complex strokes will ever be efficiently supported by a GPU renderer.

At the same time, the machinery for converting a complex stroke to a
GPU-friendly outline has a significant maintenance cost. Further, it is
surprising to users that complex strokes are significantly slower and
allocate memory.

This change removes support for complex strokes, leaving only
round-capped, round-joined strokes supported by the compute renderer.
The default renderer still converts all strokes to outline, but it also
caches the result.

This is an API change. The complex stroke conversion code has been moved
to the external gioui.org/x/stroke package, with a similar API.

Updats gio#282 (Inkeliz brought up the allocation issue)

Signed-off-by: Elias Naur <mail@eliasnaur.com>
---
 gpu/compute.go                                |  35 +-
 gpu/gpu.go                                    |  30 +-
 gpu/internal/rendertest/clip_test.go          | 389 +----------------
 .../refs/TestDashedPathFlatCapEllipse.png     | Bin 5159 -> 0 bytes
 .../refs/TestDashedPathFlatCapZ.png           | Bin 2891 -> 0 bytes
 .../refs/TestDashedPathFlatCapZNoDash.png     | Bin 1573 -> 0 bytes
 .../refs/TestDashedPathFlatCapZNoPath.png     | Bin 765 -> 0 bytes
 .../refs/TestStrokedPathBevelFlat.png         | Bin 2758 -> 0 bytes
 .../refs/TestStrokedPathBevelRound.png        | Bin 2769 -> 0 bytes
 .../refs/TestStrokedPathBevelSquare.png       | Bin 2756 -> 0 bytes
 .../refs/TestStrokedPathFlatMiter.png         | Bin 1585 -> 0 bytes
 .../refs/TestStrokedPathFlatMiterInf.png      | Bin 1573 -> 0 bytes
 .../refs/TestStrokedPathRoundRound.png        | Bin 2782 -> 0 bytes
 internal/stroke/dash.go                       | 394 ------------------
 internal/stroke/stroke.go                     | 151 +------
 op/clip/clip.go                               |  93 +----
 op/clip/stroke.go                             | 118 ------
 widget/border.go                              |   2 +-
 widget/material/loader.go                     |   7 +-
 19 files changed, 60 insertions(+), 1159 deletions(-)
 delete mode 100644 gpu/internal/rendertest/refs/TestDashedPathFlatCapEllipse.png
 delete mode 100644 gpu/internal/rendertest/refs/TestDashedPathFlatCapZ.png
 delete mode 100644 gpu/internal/rendertest/refs/TestDashedPathFlatCapZNoDash.png
 delete mode 100644 gpu/internal/rendertest/refs/TestDashedPathFlatCapZNoPath.png
 delete mode 100644 gpu/internal/rendertest/refs/TestStrokedPathBevelFlat.png
 delete mode 100644 gpu/internal/rendertest/refs/TestStrokedPathBevelRound.png
 delete mode 100644 gpu/internal/rendertest/refs/TestStrokedPathBevelSquare.png
 delete mode 100644 gpu/internal/rendertest/refs/TestStrokedPathFlatMiter.png
 delete mode 100644 gpu/internal/rendertest/refs/TestStrokedPathFlatMiterInf.png
 delete mode 100644 gpu/internal/rendertest/refs/TestStrokedPathRoundRound.png
 delete mode 100644 internal/stroke/dash.go
 delete mode 100644 op/clip/stroke.go

diff --git a/gpu/compute.go b/gpu/compute.go
index ee4eccc3..1645e061 100644
--- a/gpu/compute.go
+++ b/gpu/compute.go
@@ -28,7 +28,6 @@ import (
 	"gioui.org/internal/scene"
 	"gioui.org/layout"
 	"gioui.org/op"
-	"gioui.org/op/clip"
 	"gioui.org/shader"
 	"gioui.org/shader/gio"
 	"gioui.org/shader/piet"
@@ -236,10 +235,10 @@ type encoderState struct {
 // clipKey completely describes a clip operation (along with its path) and is appropriate
 // for hashing and equality checks.
 type clipKey struct {
-	bounds   f32.Rectangle
-	stroke   clip.StrokeStyle
-	relTrans f32.Affine2D
-	pathHash uint64
+	bounds      f32.Rectangle
+	strokeWidth float32
+	relTrans    f32.Affine2D
+	pathHash    uint64
 }
 
 // paintKey completely defines a paint operation. It is suitable for hashing and
@@ -1683,7 +1682,7 @@ func (c *opsCollector) reset() {
 	c.layers = c.layers[:0]
 }
 
-func (c *collector) addClip(state *encoderState, viewport, bounds f32.Rectangle, path []byte, key ops.Key, hash uint64, stroke clip.StrokeStyle, push bool) {
+func (c *collector) addClip(state *encoderState, viewport, bounds f32.Rectangle, path []byte, key ops.Key, hash uint64, strokeWidth float32, push bool) {
 	// Rectangle clip regions.
 	if len(path) == 0 && !push {
 		// If the rectangular clip region contains a previous path it can be discarded.
@@ -1713,10 +1712,10 @@ func (c *collector) addClip(state *encoderState, viewport, bounds f32.Rectangle,
 		intersect: intersect,
 		push:      push,
 		clipKey: clipKey{
-			bounds:   bounds,
-			relTrans: state.relTrans,
-			stroke:   stroke,
-			pathHash: hash,
+			bounds:      bounds,
+			relTrans:    state.relTrans,
+			strokeWidth: strokeWidth,
+			pathHash:    hash,
 		},
 	})
 	state.clip = &c.clipStates[len(c.clipStates)-1]
@@ -1742,9 +1741,9 @@ func (c *collector) collect(root *op.Ops, viewport image.Point, texOps *[]textur
 			key  ops.Key
 			hash uint64
 		}
-		str clip.StrokeStyle
+		strWidth float32
 	)
-	c.addClip(&state, fview, fview, nil, ops.Key{}, 0, clip.StrokeStyle{}, false)
+	c.addClip(&state, fview, fview, nil, ops.Key{}, 0, 0, false)
 	for encOp, ok := r.Decode(); ok; encOp, ok = r.Decode() {
 		switch ops.OpType(encOp.Data[0]) {
 		case ops.TypeProfile:
@@ -1763,7 +1762,7 @@ func (c *collector) collect(root *op.Ops, viewport image.Point, texOps *[]textur
 			state.t = st.t
 			state.relTrans = st.relTrans
 		case ops.TypeStroke:
-			str = decodeStrokeOp(encOp.Data)
+			strWidth = decodeStrokeOp(encOp.Data)
 		case ops.TypePath:
 			hash := bo.Uint64(encOp.Data[1:])
 			encOp, ok = r.Decode()
@@ -1776,9 +1775,9 @@ func (c *collector) collect(root *op.Ops, viewport image.Point, texOps *[]textur
 		case ops.TypeClip:
 			var op clipOp
 			op.decode(encOp.Data)
-			c.addClip(&state, fview, op.bounds, pathData.data, pathData.key, pathData.hash, str, op.push)
+			c.addClip(&state, fview, op.bounds, pathData.data, pathData.key, pathData.hash, strWidth, op.push)
 			pathData.data = nil
-			str = clip.StrokeStyle{}
+			strWidth = 0
 		case ops.TypePopClip:
 			for {
 				push := state.clip.push
@@ -1806,7 +1805,7 @@ func (c *collector) collect(root *op.Ops, viewport image.Point, texOps *[]textur
 			if paintState.matType == materialTexture {
 				// Clip to the bounds of the image, to hide other images in the atlas.
 				bounds := paintState.image.src.Bounds()
-				c.addClip(&paintState, fview, layout.FRect(bounds), nil, ops.Key{}, 0, clip.StrokeStyle{}, false)
+				c.addClip(&paintState, fview, layout.FRect(bounds), nil, ops.Key{}, 0, 0, false)
 			}
 			intersect := paintState.clip.intersect
 			if intersect.Empty() {
@@ -2101,9 +2100,9 @@ func encodeOp(viewport image.Point, absOff image.Point, enc *encoder, texOps []t
 	enc.transform(inv)
 	for i := len(op.clipStack) - 1; i >= 0; i-- {
 		cl := op.clipStack[i]
-		if str := cl.state.stroke; str.Width > 0 {
+		if w := cl.state.strokeWidth; w > 0 {
 			enc.fillMode(scene.FillModeStroke)
-			enc.lineWidth(str.Width)
+			enc.lineWidth(w)
 			fillMode = scene.FillModeStroke
 		} else if fillMode != scene.FillModeNonzero {
 			enc.fillMode(scene.FillModeNonzero)
diff --git a/gpu/gpu.go b/gpu/gpu.go
index 7cd7df40..0ca6b689 100644
--- a/gpu/gpu.go
+++ b/gpu/gpu.go
@@ -27,7 +27,6 @@ import (
 	"gioui.org/internal/stroke"
 	"gioui.org/layout"
 	"gioui.org/op"
-	"gioui.org/op/clip"
 	"gioui.org/shader"
 	"gioui.org/shader/gio"
 
@@ -135,15 +134,13 @@ type imageOp struct {
 	place    placement
 }
 
-func decodeStrokeOp(data []byte) clip.StrokeStyle {
+func decodeStrokeOp(data []byte) float32 {
 	_ = data[4]
 	if ops.OpType(data[0]) != ops.TypeStroke {
 		panic("invalid op")
 	}
 	bo := binary.LittleEndian
-	return clip.StrokeStyle{
-		Width: math.Float32frombits(bo.Uint32(data[1:])),
-	}
+	return math.Float32frombits(bo.Uint32(data[1:]))
 }
 
 type quadsOp struct {
@@ -907,9 +904,9 @@ func (k opKey) SetTransform(t f32.Affine2D) opKey {
 
 func (d *drawOps) collectOps(r *ops.Reader, viewport f32.Rectangle) {
 	var (
-		quads quadsOp
-		str   clip.StrokeStyle
-		state drawState
+		quads    quadsOp
+		strWidth float32
+		state    drawState
 	)
 	reset := func() {
 		state = drawState{
@@ -934,7 +931,7 @@ loop:
 			d.transStack = d.transStack[:n-1]
 
 		case ops.TypeStroke:
-			str = decodeStrokeOp(encOp.Data)
+			strWidth = decodeStrokeOp(encOp.Data)
 
 		case ops.TypePath:
 			encOp, ok = r.Decode()
@@ -960,7 +957,7 @@ loop:
 					op.bounds = v.bounds
 				} else {
 					pathData, bounds := d.buildVerts(
-						quads.aux, trans, op.outline, str,
+						quads.aux, trans, op.outline, strWidth,
 					)
 					op.bounds = bounds
 					quads.aux = pathData
@@ -974,7 +971,7 @@ loop:
 			}
 			d.addClipPath(&state, quads.aux, quads.key, op.bounds, off, op.push)
 			quads = quadsOp{}
-			str = clip.StrokeStyle{}
+			strWidth = 0
 		case ops.TypePopClip:
 			for {
 				push := state.cpath.push
@@ -1343,7 +1340,7 @@ func (d *drawOps) writeVertCache(n int) []byte {
 }
 
 // transform, split paths as needed, calculate maxY, bounds and create GPU vertices.
-func (d *drawOps) buildVerts(pathData []byte, tr f32.Affine2D, outline bool, str clip.StrokeStyle) (verts []byte, bounds f32.Rectangle) {
+func (d *drawOps) buildVerts(pathData []byte, tr f32.Affine2D, outline bool, strWidth float32) (verts []byte, bounds f32.Rectangle) {
 	inf := float32(math.Inf(+1))
 	d.qs.bounds = f32.Rectangle{
 		Min: f32.Point{X: inf, Y: inf},
@@ -1353,15 +1350,12 @@ func (d *drawOps) buildVerts(pathData []byte, tr f32.Affine2D, outline bool, str
 	startLength := len(d.vertCache)
 
 	switch {
-	case str.Width > 0:
+	case strWidth > 0:
 		// Stroke path.
 		ss := stroke.StrokeStyle{
-			Width: str.Width,
-			Miter: str.Miter,
-			Cap:   stroke.StrokeCap(str.Cap),
-			Join:  stroke.StrokeJoin(str.Join),
+			Width: strWidth,
 		}
-		quads := stroke.StrokePathCommands(ss, stroke.DashOp{}, pathData)
+		quads := stroke.StrokePathCommands(ss, pathData)
 		for _, quad := range quads {
 			d.qs.contour = quad.Contour
 			quad.Quad = quad.Quad.Transform(tr)
diff --git a/gpu/internal/rendertest/clip_test.go b/gpu/internal/rendertest/clip_test.go
index 895adddb..dbee98fc 100644
--- a/gpu/internal/rendertest/clip_test.go
+++ b/gpu/internal/rendertest/clip_test.go
@@ -125,10 +125,8 @@ func TestTexturedStrokeClipped(t *testing.T) {
 		smallSquares.Add(o)
 		defer op.Offset(f32.Pt(50, 50)).Push(o).Pop()
 		defer clip.Stroke{
-			Path: clip.RRect{Rect: f32.Rect(0, 0, 30, 30)}.Path(o),
-			Style: clip.StrokeStyle{
-				Width: 10,
-			},
+			Path:  clip.RRect{Rect: f32.Rect(0, 0, 30, 30)}.Path(o),
+			Width: 10,
 		}.Op().Push(o).Pop()
 		defer clip.RRect{Rect: f32.Rect(-30, -30, 60, 60)}.Push(o).Pop()
 		defer op.Offset(f32.Pt(-10, -10)).Push(o).Pop()
@@ -142,10 +140,8 @@ func TestTexturedStroke(t *testing.T) {
 		smallSquares.Add(o)
 		defer op.Offset(f32.Pt(50, 50)).Push(o).Pop()
 		defer clip.Stroke{
-			Path: clip.RRect{Rect: f32.Rect(0, 0, 30, 30)}.Path(o),
-			Style: clip.StrokeStyle{
-				Width: 10,
-			},
+			Path:  clip.RRect{Rect: f32.Rect(0, 0, 30, 30)}.Path(o),
+			Width: 10,
 		}.Op().Push(o).Pop()
 		defer op.Offset(f32.Pt(-10, -10)).Push(o).Pop()
 		paint.PaintOp{}.Add(o)
@@ -165,175 +161,8 @@ func TestPaintClippedTexture(t *testing.T) {
 	})
 }
 
-func TestStrokedPathBevelFlat(t *testing.T) {
-	run(t, func(o *op.Ops) {
-		p := newStrokedPath(o)
-		defer clip.Stroke{
-			Path: p,
-			Style: clip.StrokeStyle{
-				Width: 2.5,
-				Cap:   clip.FlatCap,
-				Join:  clip.BevelJoin,
-			},
-		}.Op().Push(o).Pop()
-
-		paint.Fill(o, red)
-	}, func(r result) {
-		r.expect(0, 0, transparent)
-		r.expect(10, 50, colornames.Red)
-	})
-}
-
-func TestStrokedPathBevelRound(t *testing.T) {
-	run(t, func(o *op.Ops) {
-		p := newStrokedPath(o)
-		defer clip.Stroke{
-			Path: p,
-			Style: clip.StrokeStyle{
-				Width: 2.5,
-				Cap:   clip.RoundCap,
-				Join:  clip.BevelJoin,
-			},
-		}.Op().Push(o).Pop()
-
-		paint.Fill(o, red)
-	}, func(r result) {
-		r.expect(0, 0, transparent)
-		r.expect(10, 50, colornames.Red)
-	})
-}
-
-func TestStrokedPathBevelSquare(t *testing.T) {
-	run(t, func(o *op.Ops) {
-		p := newStrokedPath(o)
-		defer clip.Stroke{
-			Path: p,
-			Style: clip.StrokeStyle{
-				Width: 2.5,
-				Cap:   clip.SquareCap,
-				Join:  clip.BevelJoin,
-			},
-		}.Op().Push(o).Pop()
-
-		paint.Fill(o, red)
-	}, func(r result) {
-		r.expect(0, 0, transparent)
-		r.expect(10, 50, colornames.Red)
-	})
-}
-
-func TestStrokedPathRoundRound(t *testing.T) {
-	run(t, func(o *op.Ops) {
-		p := newStrokedPath(o)
-		defer clip.Stroke{
-			Path: p,
-			Style: clip.StrokeStyle{
-				Width: 2.5,
-				Cap:   clip.RoundCap,
-				Join:  clip.RoundJoin,
-			},
-		}.Op().Push(o).Pop()
-
-		paint.Fill(o, red)
-	}, func(r result) {
-		r.expect(0, 0, transparent)
-		r.expect(10, 50, colornames.Red)
-	})
-}
-
-func TestStrokedPathFlatMiter(t *testing.T) {
-	run(t, func(o *op.Ops) {
-		{
-			p := newZigZagPath(o)
-			cl := clip.Stroke{
-				Path: p,
-				Style: clip.StrokeStyle{
-					Width: 10,
-					Cap:   clip.FlatCap,
-					Join:  clip.BevelJoin,
-					Miter: 5,
-				},
-			}.Op().Push(o)
-			paint.Fill(o, red)
-			cl.Pop()
-		}
-		{
-			p := newZigZagPath(o)
-			cl := clip.Stroke{
-				Path: p,
-				Style: clip.StrokeStyle{
-					Width: 2,
-					Cap:   clip.FlatCap,
-					Join:  clip.BevelJoin,
-				},
-			}.Op().Push(o)
-			paint.Fill(o, black)
-			cl.Pop()
-		}
-
-	}, func(r result) {
-		r.expect(0, 0, transparent)
-		r.expect(40, 10, colornames.Black)
-		r.expect(40, 12, colornames.Red)
-	})
-}
-
-func TestStrokedPathFlatMiterInf(t *testing.T) {
-	run(t, func(o *op.Ops) {
-		{
-			p := newZigZagPath(o)
-			cl := clip.Stroke{
-				Path: p,
-				Style: clip.StrokeStyle{
-					Width: 10,
-					Cap:   clip.FlatCap,
-					Join:  clip.BevelJoin,
-					Miter: float32(math.Inf(+1)),
-				},
-			}.Op().Push(o)
-			paint.Fill(o, red)
-			cl.Pop()
-		}
-		{
-			p := newZigZagPath(o)
-			cl := clip.Stroke{
-				Path: p,
-				Style: clip.StrokeStyle{
-					Width: 2,
-					Cap:   clip.FlatCap,
-					Join:  clip.BevelJoin,
-				},
-			}.Op().Push(o)
-			paint.Fill(o, black)
-			cl.Pop()
-		}
-	}, func(r result) {
-		r.expect(0, 0, transparent)
-		r.expect(40, 10, colornames.Black)
-		r.expect(40, 12, colornames.Red)
-	})
-}
-
 func TestStrokedPathZeroWidth(t *testing.T) {
 	run(t, func(o *op.Ops) {
-		{
-			p := new(clip.Path)
-			p.Begin(o)
-			p.Move(f32.Pt(10, 50))
-			p.Line(f32.Pt(50, 0))
-			cl := clip.Stroke{
-				Path: p.End(),
-				Style: clip.StrokeStyle{
-					Width: 2,
-					Cap:   clip.FlatCap,
-					Join:  clip.BevelJoin,
-				},
-			}.Op().Push(o)
-
-			paint.Fill(o, black)
-			cl.Pop()
-		}
-
 		{
 			p := new(clip.Path)
 			p.Begin(o)
@@ -354,213 +183,3 @@ func TestStrokedPathZeroWidth(t *testing.T) {
 		r.expect(65, 50, transparent)
 	})
 }
-
-func TestDashedPathFlatCapEllipse(t *testing.T) {
-	run(t, func(o *op.Ops) {
-		{
-			p := newEllipsePath(o)
-
-			var dash clip.Dash
-			dash.Begin(o)
-			dash.Dash(5)
-			dash.Dash(3)
-
-			cl := clip.Stroke{
-				Path: p,
-				Style: clip.StrokeStyle{
-					Width: 10,
-					Cap:   clip.FlatCap,
-					Join:  clip.BevelJoin,
-					Miter: float32(math.Inf(+1)),
-				},
-				Dashes: dash.End(),
-			}.Op().Push(o)
-
-			paint.Fill(
-				o,
-				red,
-			)
-			cl.Pop()
-		}
-		{
-			p := newEllipsePath(o)
-			cl := clip.Stroke{
-				Path: p,
-				Style: clip.StrokeStyle{
-					Width: 2,
-				},
-			}.Op().Push(o)
-
-			paint.Fill(
-				o,
-				black,
-			)
-			cl.Pop()
-		}
-
-	}, func(r result) {
-		r.expect(0, 0, transparent)
-		r.expect(0, 62, colornames.Red)
-		r.expect(0, 65, colornames.Black)
-	})
-}
-
-func TestDashedPathFlatCapZ(t *testing.T) {
-	run(t, func(o *op.Ops) {
-		{
-			p := newZigZagPath(o)
-			var dash clip.Dash
-			dash.Begin(o)
-			dash.Dash(5)
-			dash.Dash(3)
-
-			cl := clip.Stroke{
-				Path: p,
-				Style: clip.StrokeStyle{
-					Width: 10,
-					Cap:   clip.FlatCap,
-					Join:  clip.BevelJoin,
-					Miter: float32(math.Inf(+1)),
-				},
-				Dashes: dash.End(),
-			}.Op().Push(o)
-			paint.Fill(o, red)
-			cl.Pop()
-		}
-
-		{
-			p := newZigZagPath(o)
-			cl := clip.Stroke{
-				Path: p,
-				Style: clip.StrokeStyle{
-					Width: 2,
-					Cap:   clip.FlatCap,
-					Join:  clip.BevelJoin,
-				},
-			}.Op().Push(o)
-			paint.Fill(o, black)
-			cl.Pop()
-		}
-	}, func(r result) {
-		r.expect(0, 0, transparent)
-		r.expect(40, 10, colornames.Black)
-		r.expect(40, 12, colornames.Red)
-		r.expect(46, 12, transparent)
-	})
-}
-
-func TestDashedPathFlatCapZNoDash(t *testing.T) {
-	run(t, func(o *op.Ops) {
-		{
-			p := newZigZagPath(o)
-			var dash clip.Dash
-			dash.Begin(o)
-			dash.Phase(1)
-
-			cl := clip.Stroke{
-				Path: p,
-				Style: clip.StrokeStyle{
-					Width: 10,
-					Cap:   clip.FlatCap,
-					Join:  clip.BevelJoin,
-					Miter: float32(math.Inf(+1)),
-				},
-				Dashes: dash.End(),
-			}.Op().Push(o)
-			paint.Fill(o, red)
-			cl.Pop()
-		}
-		{
-			cl := clip.Stroke{
-				Path: newZigZagPath(o),
-				Style: clip.StrokeStyle{
-					Width: 2,
-					Cap:   clip.FlatCap,
-					Join:  clip.BevelJoin,
-				},
-			}.Op().Push(o)
-			paint.Fill(o, black)
-			cl.Pop()
-		}
-	}, func(r result) {
-		r.expect(0, 0, transparent)
-		r.expect(40, 10, colornames.Black)
-		r.expect(40, 12, colornames.Red)
-		r.expect(46, 12, colornames.Red)
-	})
-}
-
-func TestDashedPathFlatCapZNoPath(t *testing.T) {
-	run(t, func(o *op.Ops) {
-		{
-			var dash clip.Dash
-			dash.Begin(o)
-			dash.Dash(0)
-			cl := clip.Stroke{
-				Path: newZigZagPath(o),
-				Style: clip.StrokeStyle{
-					Width: 10,
-					Cap:   clip.FlatCap,
-					Join:  clip.BevelJoin,
-					Miter: float32(math.Inf(+1)),
-				},
-				Dashes: dash.End(),
-			}.Op().Push(o)
-			paint.Fill(o, red)
-			cl.Pop()
-		}
-		{
-			p := newZigZagPath(o)
-			cl := clip.Stroke{
-				Path: p,
-				Style: clip.StrokeStyle{
-					Width: 2,
-					Cap:   clip.FlatCap,
-					Join:  clip.BevelJoin,
-				},
-			}.Op().Push(o)
-			paint.Fill(o, black)
-			cl.Pop()
-		}
-	}, func(r result) {
-		r.expect(0, 0, transparent)
-		r.expect(40, 10, colornames.Black)
-		r.expect(40, 12, transparent)
-		r.expect(46, 12, transparent)
-	})
-}
-
-func newStrokedPath(o *op.Ops) clip.PathSpec {
-	p := new(clip.Path)
-	p.Begin(o)
-	p.Move(f32.Pt(10, 50))
-	p.Line(f32.Pt(10, 0))
-	p.Arc(f32.Pt(10, 0), f32.Pt(20, 0), math.Pi)
-	p.Line(f32.Pt(10, 0))
-	p.Line(f32.Pt(10, 10))
-	p.Arc(f32.Pt(0, 30), f32.Pt(0, 30), 2*math.Pi)
-	p.Line(f32.Pt(-20, 0))
-	p.Quad(f32.Pt(-10, -10), f32.Pt(-30, 30))
-	return p.End()
-}
-
-func newZigZagPath(o *op.Ops) clip.PathSpec {
-	p := new(clip.Path)
-	p.Begin(o)
-	p.Move(f32.Pt(40, 10))
-	p.Line(f32.Pt(50, 0))
-	p.Line(f32.Pt(-50, 50))
-	p.Line(f32.Pt(50, 0))
-	p.Quad(f32.Pt(-50, 20), f32.Pt(-50, 50))
-	p.Line(f32.Pt(50, 0))
-	return p.End()
-}
-
-func newEllipsePath(o *op.Ops) clip.PathSpec {
-	p := new(clip.Path)
-	p.Begin(o)
-	p.Move(f32.Pt(0, 65))
-	p.Line(f32.Pt(20, 0))
-	p.Arc(f32.Pt(20, 0), f32.Pt(70, 0), 2*math.Pi)
-	return p.End()
-}
diff --git a/gpu/internal/rendertest/refs/TestDashedPathFlatCapEllipse.png b/gpu/internal/rendertest/refs/TestDashedPathFlatCapEllipse.png
deleted file mode 100644
index 79bae3842d74b1eac858919856ac82870bab4aae..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 5159
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%0D<vk3xj$+Ov3*FHNjHY

diff --git a/gpu/internal/rendertest/refs/TestDashedPathFlatCapZ.png b/gpu/internal/rendertest/refs/TestDashedPathFlatCapZ.png
deleted file mode 100644
index 12212e99858cefa8421f1f67e9d98b1b83cee7d1..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 2891
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

diff --git a/gpu/internal/rendertest/refs/TestDashedPathFlatCapZNoDash.png b/gpu/internal/rendertest/refs/TestDashedPathFlatCapZNoDash.png
deleted file mode 100644
index d315f0f8161e098aeb2979d663358de4bd5054ab..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1573
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

diff --git a/gpu/internal/rendertest/refs/TestDashedPathFlatCapZNoPath.png b/gpu/internal/rendertest/refs/TestDashedPathFlatCapZNoPath.png
deleted file mode 100644
index 94c160ef51d703bb49f52a3c54a99a07a05fe041..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 765
zcmeAS@N?(olHy`uVBq!ia0vp^4Is?H0wgodS2{2-Fdgx9aSW-r^>&W0M@XQI`}q~g
zV&8gCiLkb<w(Bs;zN+Vx9he)lW3B5}5iOOBi%MCF6CK}1ZRt?ZnBFYF;`ks(%bmkb
z>C^$9MIN(M=6=stR<b%}Q7pOV{l9ZLZ8N{ieV<eQ{OogS0VfW{7J<GES}|64c()%r
zeZqF(xpirqBqC=m)vtZ&9sldn^nG8*V%CZ7jGk)j7W9to&99z`>Y*oV47OBGUDBS&
zlicQLWovtJxsO?4Ya!2L>+LsWug%MUXtv*=N9TDahj*Pi^Ap3K=_QkZO!n_Ty8|Cs
z$_h;TXZCKwag7gC{uXa%6<*M|`p=P$ievX!x3dc^nC&m&HtTTrJ5GfIjB$w)?=1qK
z+?&Ckv1GnvkEdQhbV+9fyT#G;p2&9_Q*WjwNhfIccN!SUL>2Cw!DewXT<PD1-Di&U
zmo`-W>NJSE9Cql^M(zt<Y>(w@Rrjs$j%?7YOQ?AgaWeae)&Wy43H>mOXU8oZCb>(n
zu3I0Zsm5q#)M9vaX6Sm!Zid?@6MS?k=gNCDsNEAbbjyy+R{wMVx3a|I)cQGZD;wO5
zBo>R-L_R8Qu(~9XyhQ852de|lJ^61|dK`YtAa3|cW^KUX+YE1ggwOu}8d<<7buy91
z;=%`$1I#_!ue3`&un@fbdHx%A@dbT4$9UbP<k)ujxb&4SWV>;IMKFDCW`+0y@yBN;
zC9(@EoV0M8?#z3hsU$gNZdQd@0>|T^9gIO|CZ%uIXT0<O-Yc1{OMbpR{jW&=fr){~
z29=pgi<Z7v!uv>~faURFBWJ!x5*PS*ew(Dmvfp6uX^~mLd!kh)LHvX269(S{DvXnl
zN4&qhx#6|1_zK3HgWGyp+>+kiN?Nl<Q03Y?=Lc%w^aLi7azD$fFRyO<6}o8(Fj+Hr
My85}Sb4q9e0KLdqng9R*

diff --git a/gpu/internal/rendertest/refs/TestStrokedPathBevelFlat.png b/gpu/internal/rendertest/refs/TestStrokedPathBevelFlat.png
deleted file mode 100644
index 9d442f5ad9f4525b8a783720bb4d6afa498820be..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 2758
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
K=E{w%6aNL52FM)%

diff --git a/gpu/internal/rendertest/refs/TestStrokedPathBevelRound.png b/gpu/internal/rendertest/refs/TestStrokedPathBevelRound.png
deleted file mode 100644
index a37235cca098039b66c670ff24e171a9f408a173..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 2769
zcmbVOdpy&98~*-&+iaH2`84N>Ii$oybDHE-2<frtup)_yTAH(s_fbzpJv=2vErfCm
zk5h;JmQqh7X(2hxTiOsNVmZFvzuy1fKkobb<GMbd`@a6T@6Yvzua7$cPr?HL2%a80
z{nwEF-@?hP^%ln?Z2;hJdhT=%i0zxmKXoM_Q1exa9WL0^{QgP*ibv+2_pbYLf6v(1
z?Av$KIQ%Hvs3=HznSoavzW^5-C7+P{EBu=OUNd~3O6kQvJPW(F;M;-=|EzCSuivuu
zIcY<YR<POQS}UfmQ@`jOu_x~FW2;)`l>KU`rG?#mzn$n;euF4)M%yCS%P9MwP|N=V
ziZ7Y+7j-tN)5#Loq>5~DZKU}HOJi&U&fZ9pMRTS-e1c!df2G}jbbHQ9SMp=z9@VW1
z)8fqeY);-=?02)+Fqsl2aKhUgR1fk8f~@*Ys|9?S<<Di0B3rc+Tlkc=PbwaadgL+(
z+8vaY)5=RA#y>226d>IGw7X=c06Ez<+_7y%o5SS1U)k7scw+G*kls(8<R1PY8C`Z}
zWR9FWPD*J;rV+YRRZm$JmR+1sQEUkN2>*qgYn$#sF#;J&B6qFuS}ln7;m$W<37(Dn
zUZXu#eq_)AcD3%9!o+JeRr&#y)I*#h*^8GaV;V*hMSrb?IA2}vaI4x4vj;^)&Xd9M
zn<I(GHB$V1e@=Oxoj?PzVyvZDev{=oF9%?^9Q}@eszQc~o=F`Z_Nhe#D4~u`iA<SB
zWiAjenmiSig>g&*wvq~dbxC8jpxFK%s_Si9#QuNokfWn2a?;*9FY+E`fRl2QkDCUW
z_;%~dM%U_VLuAQOlTjPMJUOx6jM#na*ll?>t9>bm+mHcf#~iY07GVmMCRqi#VRV#i
zr6%Xjc_?}_iEu#K(Ium24uqv~bMb`U(;%z=6+bAAdl|C8$$>NkSm69+*|ZLRK8zwx
zlF~G@Aw=Ip7EovA>yY5hq|?--lwe^3Y@><RMAHJnME5@aeMB-n-v(c$Sjd(CjHk}3
z+V+}uPBD@dE3MWwXacOBqLe9QnBtb6^K%4?^IT*dbw+GdEwCRQui5OpSc#zEq_CfA
zkbZTLaLD<AlR<T~v9yCOpv>C#iiNyWK!3#)pQqA$)PkZ2u#ro;FxC}2r1DyJHUOq^
znjWQ-C1tSsn8u8C40+YJ$7*sPt_N@bRX9$Zlg+EB<~i4`O3IO=D25Wi^{a<Q9};q+
zdjkpVdvBI6U|@GMihPu~IC~#4-hH-jSU=;;>x_LKOyh@V;#JEJ!cnaY1Rr530;BW|
z0KB^{aB8=pWQcRXAE3j=-V`OCjQnK4;YgFRVc+2<thRRMskpXrt9A+?X{9I8gsC^U
z1zUc3LJD-FXvc1!DfOEop1RHVPzZM?>JGwTxYpTfDA7*?L8nH$g6+r~m*%QpJVS`a
z*n6^X!7FiHklC7&`Cv}<`2*2g8QRY-9$Dkvs{T^&25`k)=LI>YQCzn$V8s7>0*xeW
z`l<QD`IJQPdH<k*stC}I<8RUv9-ytVfUw};jtk4tehfOpHJ?;60?_$=staCI6IpML
z$Cw4LnK}KN=#p~mZee$$RjC?KFZ4g}0h!7^Ss%@;NT@H9xk!j~Dtb4ki_R^V%>ou0
z*E2(&4X~=8W!Y4#0VQi4SB&rq@;zSJrDZQ*JB|}b6E9q<8_FOB>DkW7sj6?pN*Q*V
zH~-@BF>KGe*>k1<zeIS%R=?e>1UT~Ju|u*;6`+R<(b9Hhn1U2_DR*9_8^s96L%3UM
z!$@HDleNPzFkZe}dc(~SYz$iZ6?kgq)kZw&eYP5yWtHRHup+B3n<CI4-*x8c3hM8!
zQW(kPewZ({NxTI*hia_D@#oKD0Nf+H<dU(vg`<@Xgp6m@eR;@erz8XJoIJuHfU|@9
zzcTEVnOFjl=<ql%`08W#{qD)w78vsMtG}N8>yHQJ5PbC>OH1!91sKwe6-Nu0iw>T^
zn13__?XM*LleVW1^2N<9W>gr`v-X2j-!m92%R0*q$42%Dq;c4WV;C@SUUXdX?%Rz3
zzB|qQLA(<|A;`07cPkYoTV)bzU^X#Q9=lhVlnc{ZUgooov8MWqfNihR?2^+BYk-zX
zRpj6Bf`kP>&nCC8dSp>jNethCmsN*1YuQ@?anXA%Jn~OF;7)$pP5rJ#y8L$58fGKf
zfphayjVdp7I#j@d-Cdkob^BX1a2BhPt2dt@QRfcp3G`9f81CLBpbF@!6qJ^~JR9+b
zSEtRGMp<q`yJ$G@hlN86Xve9wOm@H^A?<fvGcul?Hnc0Q*(T?s5yN(YklZZY`4GAm
zo;P{0o=3`K6rTuM6&ML~Hv`69IND?aXiHkQVduS6*heWW-%b)Ea&2RQ5e@2{T!bF<
zUoLIQ#f(ibVfTn-X?*TC#<S*>d_+`p2xS{<Os7$uDuA}!wxgT!<Uq4kL#a1XvPOy3
zVw{x3dvw59;e2f{HYwc)W?y$ER6ks|0Om2E+{+AvQ1hA!l_9aj5g7|W2@6>{j6wZb
z3dCLk>^<k#v_>Dj*)NhMq0q$`SnoRw9Pf_#Flr%%o2qgsy$Kl9W2}+#O051lv}__z
z6UedVEF`%BcBw&VB&z5MjxuhI<OV!W4Mrmks%+Nnt(pS<2fkI2wkVu62HE!5gKiV>
zdzcrNWdY36KK!<gPVn_%W@e)Cnuir?_Cg+0sn^s#g6$k<jPP%kW#dM#9-n8GAWu6l
zRQ$R8zeJTWcqz99Z$28i+X#f8C3KP{m9XT13}jo>%3I%g+?pl_lIGtxxLGxB4Ltx!
z&vY$~T_Vv2o?ouhH1-OM)Hv52dhIlUNxWp3VHsgf8zJeF-~Ty{;p{N6yY2F{Y|+Dk
z-mD7-bdz1n+CFU1?A5I_EBP_}^(y3x0oKxn#H*j~+tFUsGk7h;6Wk^Xu-;`JzvOD5
z;Z0g!tQ^7C-+ARjw2c*k-3q-vVb9<NOLv%DvbkBT@28%oP}62Qk`MW!!18JfXMFZR
z;gNr*7dv|On>kAty!mlh8JZF}H#4eh;!fB;;K6<U0Orz(Dx;s5pB}lR36ufjYs8iy
zKj8>bUUgi)iTd5;B?)8$S_no&d7eJBBiT<__^~T${*u1lCTcG^jxJ1^Ub_S%2pPep
zI`HFAaSlJsZT1xc46|%%Vll#L#Y={!3_7#Uf8;3M8b1C7>sE&X4h!E-c7D=Qj&1yH
zZKyY(@ftQ=^qfs`Z>>`T4whj&*3_6)o;rOSU9=Q};(7ux@AyNOx!z7=lkmgCU#1hb
zed#owxRQxYf4BDh%dfAwS_g2I2f6Nz*I|WSq-!U7c3#cU>IwOBK&40Y77-VWu6i-}
z9wD_H8Cn^@b<xW&P%~RIb7K}h?Z+-^pX@R3i<~`xe1s!sYbR8RnNLi0O0e$n(Q<4e
zr0-F-CntxnE3PfKvG;NEA-VL^(`g3Fyq3ZcQR||H4DA9WEQ^b2>rn0GlC$;H8w0SQ
z#9%6O+*)f#;nf$!T1!CHW}D96x*thgh?yQ`J2?)H9(o$VdkOv*1xMenf)iceY+Nk7
RYu2JF@O1UrS-FFe`X3;H+vorQ

diff --git a/gpu/internal/rendertest/refs/TestStrokedPathBevelSquare.png b/gpu/internal/rendertest/refs/TestStrokedPathBevelSquare.png
deleted file mode 100644
index 8d2919d30a0426249eea651f77d793f7f924b8e9..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 2756
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
EACaWqQUCw|

diff --git a/gpu/internal/rendertest/refs/TestStrokedPathFlatMiter.png b/gpu/internal/rendertest/refs/TestStrokedPathFlatMiter.png
deleted file mode 100644
index ae6472a73c9cc76c361460884e8d42e5b8e16f60..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1585
zcma)-eN>VM8^#|%h)8O!O(b#J#A(qKMeUuXEYrj?Kc-6y6SmUU$E&p(N+uA@S`kx7
zV`cf|mSc$~<w;ykk$IY#HZo0_mYAZ>i6UyoBk-`^?LGT@=Un%7opYUY-+%t@vq=fD
zc-(3n008(nM)XIoQ}DmRVqSY|<R={ffVRd(Z%)ncpSpVVtGBY;&wx#}_3Kk=;x}*e
zrwGYD%g!>sI)__#OXhtJhmxo^UH7K?i@bv$UHdYr9k<z{3O@U7K=PU$PU`Y?JGKQ<
zYJ0kAx_ejE^o0mp4kz2}BEEXbfbyC&71q}n=9&#Z(dMQCuxq}2BMRH~nR|NIZWnRG
zmbisw?tqLn1eDm3O9aL~$tjb%P{uL==@jUGxXbZVcN*<(hKqKgi@-?u4?xzmAgJk(
z2bn$)tzujXgk*n7RH8|k6;oK>`9V>$MaE_A1X&=N#b_=$x#nLN@{{fVNEbR#N&f$B
z866AZ2e)?Q933s!dIo1?KyKQ(+ZjpF;LeWuwGTEprRdL}gun3nEfNil(d%V$K)+O~
z#qRRDZm+q6(=S&MS{?=zlJrdWz3NZ_F<uH?X*XjAfQ2I^Qz_bBk>|}R=Xv9JG>@S7
zW2-Sl1F`{M<5#H3^QDi>77OkOcOVaOpt=QcZ1PUoWv9nmqIL|k+vtgAqQbhWSU|%*
zfdMto>0!sYtO|XIXP~#ns5VvaoCrlaG0bt|3VjTFyLP$jdY)QK`WTj!TYN=C4BvOD
z$ud06(OIQzv%nFgvPv*1_{$*=@!MQR@cmE74Wfu?qQSM{4U>BD2?bM&xe$66AMY1J
z-1OhaW#rH4dP;>QOSNCi=_45Ss(v0?C&?K}g!bZ_8E<ltrY)-N5tE8jg(;e9^R0u=
zshK|Ic<9w?`z7)*KmB(V7P)oppk;pJ390rWE~7H}(P=9U@3uRth)+6<)+gx}xhSu3
zx_D@}<RAyv6qG6LdthH_S|g_u5AStMH183Aa9a*ta19?0E^wsNpVh-zD$&I73a&Q)
z^wtpOtb#}qFN-jCpCp>LsTvk{IeFJZPhKje59r!$OP`}Ta<H3@SlI4R=BW>m>$#mE
zm})9Shy6lxPL<*eO56RFSCrDu?6E*b_#l6%Z84e6`aTgVz~^-Nk1==~^hn)ec}sI5
zINRrbzQ;d14c;D?XCC8@B_`6<=CE&SS9Uho6|$WZooEkCSU1J#0@+-1da&6{_&KJ@
z(g{v>!z5OV)SJ%?JpUA%eXn2Be~reYDRTS43vgvuG5*&sZ1%>vGqEaKGpV2w9MQ$=
z>{V^YV*&{X)w+PZvi-1QLjDE8qcr5iZ*pgP#<ZKx9=BFZ^T|)~kr$7^_c3R-{HPJ`
z8F}0J^**Sh41(I>;^7#>dL7(rJiu?79v+Q_BaUj7j^pMJG)51bO&xKhVr#$>(wVXR
zr<ykNcp@XSod0;}HgtLM*ab)8X)pZ`E-ZHoclM|=5<q_#X<QNXI~Fx`i1kY-h5HAq
zS6zqn_Cip78q;$9THcuftO3v>j75K#@cR$E!^#L(fh5z~^v$N1boc2x-~n&JK)Ts`
z!%Co*7IM?p17U5i(tv$*;9?Qt@$|U;{q}KtO8BQgzYT~KHxQ#BIvx+&db|{U97C!w
z>_BHSkhBNPn~h2!%&ewrndkeesC>kc{f%AANkBHRW$~5GGo4ZdT|p$=zF$1Pp=W`)
zOPIO#^_qJIHe*ojiBJma<Lo4ka(*-y)A;o@p&{`l$-I*NnUi<5<-LgxgX`nEUnghU
zCJ)`q>755#0e^Hiy(N=RN*nk>*)v))M9Fv;RnS@oJE${xme?0O#f=z6eO<Od8}!~Y
z{YbG-sYlUL!Cb2ZbR>%*@hYHIhP<|`0`9o0tUM?<x1<VD)s-6f>V@J|R<-9{$B)5J
z%fRQUb#J~iH+~u!D}=LhtsLL{M}zE*35~hF`e_^Um@3!0dUWVkF1QMRLR5W2YS0x#
z=3hpfqoMQ~XHD}46y+r!bmJQ~du^0B6)D_WgzaJo3X2vb0e=(sFYNwpupf*dRXqDR
UqJJjn^(z44ViKZnMzMu|0zY;X?*IS*

diff --git a/gpu/internal/rendertest/refs/TestStrokedPathFlatMiterInf.png b/gpu/internal/rendertest/refs/TestStrokedPathFlatMiterInf.png
deleted file mode 100644
index d315f0f8161e098aeb2979d663358de4bd5054ab..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1573
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

diff --git a/gpu/internal/rendertest/refs/TestStrokedPathRoundRound.png b/gpu/internal/rendertest/refs/TestStrokedPathRoundRound.png
deleted file mode 100644
index 8ef5a942f2c0f5ffe9ea7552135cd3abe085d95d..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 2782
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

diff --git a/internal/stroke/dash.go b/internal/stroke/dash.go
deleted file mode 100644
index 58745379..00000000
--- a/internal/stroke/dash.go
+++ /dev/null
@@ -1,394 +0,0 @@
-// SPDX-License-Identifier: Unlicense OR MIT
-
-// The algorithms to compute dashes have been extracted, adapted from
-// (and used as a reference implementation):
-//  - github.com/tdewolff/canvas (Licensed under MIT)
-
-package stroke
-
-import (
-	"math"
-	"sort"
-
-	"gioui.org/f32"
-)
-
-type DashOp struct {
-	Phase  float32
-	Dashes []float32
-}
-
-func IsSolidLine(sty DashOp) bool {
-	return sty.Phase == 0 && len(sty.Dashes) == 0
-}
-
-func (qs StrokeQuads) dash(sty DashOp) StrokeQuads {
-	sty = dashCanonical(sty)
-
-	switch {
-	case len(sty.Dashes) == 0:
-		return qs
-	case len(sty.Dashes) == 1 && sty.Dashes[0] == 0.0:
-		return StrokeQuads{}
-	}
-
-	if len(sty.Dashes)%2 == 1 {
-		// If the dash pattern is of uneven length, dash and space lengths
-		// alternate. The following duplicates the pattern so that uneven
-		// indices are always spaces.
-		sty.Dashes = append(sty.Dashes, sty.Dashes...)
-	}
-
-	var (
-		i0, pos0 = dashStart(sty)
-		out      StrokeQuads
-
-		contour uint32 = 1
-	)
-
-	for _, ps := range qs.split() {
-		var (
-			i      = i0
-			pos    = pos0
-			t      []float64
-			length = ps.len()
-		)
-		for pos+sty.Dashes[i] < length {
-			pos += sty.Dashes[i]
-			if 0.0 < pos {
-				t = append(t, float64(pos))
-			}
-			i++
-			if i == len(sty.Dashes) {
-				i = 0
-			}
-		}
-
-		j0 := 0
-		endsInDash := i%2 == 0
-		if len(t)%2 == 1 && endsInDash || len(t)%2 == 0 && !endsInDash {
-			j0 = 1
-		}
-
-		var (
-			qd StrokeQuads
-			pd = ps.splitAt(&contour, t...)
-		)
-		for j := j0; j < len(pd)-1; j += 2 {
-			qd = qd.append(pd[j])
-		}
-		if endsInDash {
-			if ps.closed() {
-				qd = pd[len(pd)-1].append(qd)
-			} else {
-				qd = qd.append(pd[len(pd)-1])
-			}
-		}
-		out = out.append(qd)
-		contour++
-	}
-	return out
-}
-
-func dashCanonical(sty DashOp) DashOp {
-	var (
-		o  = sty
-		ds = o.Dashes
-	)
-
-	if len(sty.Dashes) == 0 {
-		return sty
-	}
-
-	// Remove zeros except first and last.
-	for i := 1; i < len(ds)-1; i++ {
-		if f32Eq(ds[i], 0.0) {
-			ds[i-1] += ds[i+1]
-			ds = append(ds[:i], ds[i+2:]...)
-			i--
-		}
-	}
-
-	// Remove first zero, collapse with second and last.
-	if f32Eq(ds[0], 0.0) {
-		if len(ds) < 3 {
-			return DashOp{
-				Phase:  0.0,
-				Dashes: []float32{0.0},
-			}
-		}
-		o.Phase -= ds[1]
-		ds[len(ds)-1] += ds[1]
-		ds = ds[2:]
-	}
-
-	// Remove last zero, collapse with fist and second to last.
-	if f32Eq(ds[len(ds)-1], 0.0) {
-		if len(ds) < 3 {
-			return DashOp{}
-		}
-		o.Phase += ds[len(ds)-2]
-		ds[0] += ds[len(ds)-2]
-		ds = ds[:len(ds)-2]
-	}
-
-	// If there are zeros or negatives, don't draw dashes.
-	for i := 0; i < len(ds); i++ {
-		if ds[i] < 0.0 || f32Eq(ds[i], 0.0) {
-			return DashOp{
-				Phase:  0.0,
-				Dashes: []float32{0.0},
-			}
-		}
-	}
-
-	// Remove repeated patterns.
-loop:
-	for len(ds)%2 == 0 {
-		mid := len(ds) / 2
-		for i := 0; i < mid; i++ {
-			if !f32Eq(ds[i], ds[mid+i]) {
-				break loop
-			}
-		}
-		ds = ds[:mid]
-	}
-	return o
-}
-
-func dashStart(sty DashOp) (int, float32) {
-	i0 := 0 // i0 is the index into dashes.
-	for sty.Dashes[i0] <= sty.Phase {
-		sty.Phase -= sty.Dashes[i0]
-		i0++
-		if i0 == len(sty.Dashes) {
-			i0 = 0
-		}
-	}
-	// pos0 may be negative if the offset lands halfway into dash.
-	pos0 := -sty.Phase
-	if sty.Phase < 0.0 {
-		var sum float32
-		for _, d := range sty.Dashes {
-			sum += d
-		}
-		pos0 = -(sum + sty.Phase) // handle negative offsets
-	}
-	return i0, pos0
-}
-
-func (qs StrokeQuads) len() float32 {
-	var sum float32
-	for i := range qs {
-		q := qs[i].Quad
-		sum += quadBezierLen(q.From, q.Ctrl, q.To)
-	}
-	return sum
-}
-
-// splitAt splits the path into separate paths at the specified intervals
-// along the path.
-// splitAt updates the provided contour counter as it splits the segments.
-func (qs StrokeQuads) splitAt(contour *uint32, ts ...float64) []StrokeQuads {
-	if len(ts) == 0 {
-		qs.setContour(*contour)
-		return []StrokeQuads{qs}
-	}
-
-	sort.Float64s(ts)
-	if ts[0] == 0 {
-		ts = ts[1:]
-	}
-
-	var (
-		j int     // index into ts
-		t float64 // current position along curve
-	)
-
-	var oo []StrokeQuads
-	var oi StrokeQuads
-	push := func() {
-		oo = append(oo, oi)
-		oi = nil
-	}
-
-	for _, ps := range qs.split() {
-		for _, q := range ps {
-			if j == len(ts) {
-				oi = append(oi, q)
-				continue
-			}
-			speed := func(t float64) float64 {
-				return float64(lenPt(quadBezierD1(q.Quad.From, q.Quad.Ctrl, q.Quad.To, float32(t))))
-			}
-			invL, dt := invSpeedPolynomialChebyshevApprox(20, gaussLegendre7, speed, 0, 1)
-
-			var (
-				t0 float64
-				r0 = q.Quad.From
-				r1 = q.Quad.Ctrl
-				r2 = q.Quad.To
-
-				// from keeps track of the start of the 'running' segment.
-				from = r0
-			)
-			for j < len(ts) && t < ts[j] && ts[j] <= t+dt {
-				tj := invL(ts[j] - t)
-				tsub := (tj - t0) / (1.0 - t0)
-				t0 = tj
-
-				var q1 f32.Point
-				_, q1, _, r0, r1, r2 = quadBezierSplit(r0, r1, r2, float32(tsub))
-
-				oi = append(oi, StrokeQuad{
-					Contour: *contour,
-					Quad: QuadSegment{
-						From: from,
-						Ctrl: q1,
-						To:   r0,
-					},
-				})
-				push()
-				(*contour)++
-
-				from = r0
-				j++
-			}
-			if !f64Eq(t0, 1) {
-				if len(oi) > 0 {
-					r0 = oi.pen()
-				}
-				oi = append(oi, StrokeQuad{
-					Contour: *contour,
-					Quad: QuadSegment{
-						From: r0,
-						Ctrl: r1,
-						To:   r2,
-					},
-				})
-			}
-			t += dt
-		}
-	}
-	if len(oi) > 0 {
-		push()
-		(*contour)++
-	}
-
-	return oo
-}
-
-func f32Eq(a, b float32) bool {
-	const epsilon = 1e-10
-	return math.Abs(float64(a-b)) < epsilon
-}
-
-func f64Eq(a, b float64) bool {
-	const epsilon = 1e-10
-	return math.Abs(a-b) < epsilon
-}
-
-func invSpeedPolynomialChebyshevApprox(N int, gaussLegendre gaussLegendreFunc, fp func(float64) float64, tmin, tmax float64) (func(float64) float64, float64) {
-	// The TODOs below are copied verbatim from tdewolff/canvas:
-	//
-	// TODO: find better way to determine N. For Arc 10 seems fine, for some
-	// Quads 10 is too low, for Cube depending on inflection points is
-	// maybe not the best indicator
-	//
-	// TODO: track efficiency, how many times is fp called?
-	// Does a look-up table make more sense?
-	fLength := func(t float64) float64 {
-		return math.Abs(gaussLegendre(fp, tmin, t))
-	}
-	totalLength := fLength(tmax)
-	t := func(L float64) float64 {
-		return bisectionMethod(fLength, L, tmin, tmax)
-	}
-	return polynomialChebyshevApprox(N, t, 0.0, totalLength, tmin, tmax), totalLength
-}
-
-func polynomialChebyshevApprox(N int, f func(float64) float64, xmin, xmax, ymin, ymax float64) func(float64) float64 {
-	var (
-		invN = 1.0 / float64(N)
-		fs   = make([]float64, N)
-	)
-	for k := 0; k < N; k++ {
-		u := math.Cos(math.Pi * (float64(k+1) - 0.5) * invN)
-		fs[k] = f(xmin + 0.5*(xmax-xmin)*(u+1))
-	}
-
-	c := make([]float64, N)
-	for j := 0; j < N; j++ {
-		var a float64
-		for k := 0; k < N; k++ {
-			a += fs[k] * math.Cos(float64(j)*math.Pi*(float64(k+1)-0.5)/float64(N))
-		}
-		c[j] = 2 * invN * a
-	}
-
-	if ymax < ymin {
-		ymin, ymax = ymax, ymin
-	}
-	return func(x float64) float64 {
-		x = math.Min(xmax, math.Max(xmin, x))
-		u := (x-xmin)/(xmax-xmin)*2 - 1
-		var a float64
-		for j := 0; j < N; j++ {
-			a += c[j] * math.Cos(float64(j)*math.Acos(u))
-		}
-		y := -0.5*c[0] + a
-		if !math.IsNaN(ymin) && !math.IsNaN(ymax) {
-			y = math.Min(ymax, math.Max(ymin, y))
-		}
-		return y
-	}
-}
-
-// bisectionMethod finds the value x for which f(x) = y in the interval x
-// in [xmin, xmax] using the bisection method.
-func bisectionMethod(f func(float64) float64, y, xmin, xmax float64) float64 {
-	const (
-		maxIter   = 100
-		tolerance = 0.001 // 0.1%
-	)
-
-	var (
-		n    = 0
-		x    float64
-		tolX = math.Abs(xmax-xmin) * tolerance
-		tolY = math.Abs(f(xmax)-f(xmin)) * tolerance
-	)
-	for {
-		x = 0.5 * (xmin + xmax)
-		if n >= maxIter {
-			return x
-		}
-
-		dy := f(x) - y
-		switch {
-		case math.Abs(dy) < tolY, math.Abs(0.5*(xmax-xmin)) < tolX:
-			return x
-		case dy > 0:
-			xmax = x
-		default:
-			xmin = x
-		}
-		n++
-	}
-}
-
-type gaussLegendreFunc func(func(float64) float64, float64, float64) float64
-
-// Gauss-Legendre quadrature integration from a to b with n=7
-func gaussLegendre7(f func(float64) float64, a, b float64) float64 {
-	c := 0.5 * (b - a)
-	d := 0.5 * (a + b)
-	Qd1 := f(-0.949108*c + d)
-	Qd2 := f(-0.741531*c + d)
-	Qd3 := f(-0.405845*c + d)
-	Qd4 := f(d)
-	Qd5 := f(0.405845*c + d)
-	Qd6 := f(0.741531*c + d)
-	Qd7 := f(0.949108*c + d)
-	return c * (0.129485*(Qd1+Qd7) + 0.279705*(Qd2+Qd6) + 0.381830*(Qd3+Qd5) + 0.417959*Qd4)
-}
diff --git a/internal/stroke/stroke.go b/internal/stroke/stroke.go
index fda42dbd..95025eb8 100644
--- a/internal/stroke/stroke.go
+++ b/internal/stroke/stroke.go
@@ -40,26 +40,8 @@ import (
 // op/clip, eliminating the duplicate types.
 type StrokeStyle struct {
 	Width float32
-	Miter float32
-	Cap   StrokeCap
-	Join  StrokeJoin
 }
 
-type StrokeCap uint8
-
-const (
-	RoundCap StrokeCap = iota
-	FlatCap
-	SquareCap
-)
-
-type StrokeJoin uint8
-
-const (
-	RoundJoin StrokeJoin = iota
-	BevelJoin
-)
-
 // strokeTolerance is used to reconcile rounding errors arising
 // when splitting quads into smaller and smaller segments to approximate
 // them into straight lines, and when joining back segments.
@@ -97,12 +79,6 @@ func (qs *StrokeQuads) pen() f32.Point {
 	return (*qs)[len(*qs)-1].Quad.To
 }
 
-func (qs *StrokeQuads) closed() bool {
-	beg := (*qs)[0].Quad.From
-	end := (*qs)[len(*qs)-1].Quad.To
-	return f32Eq(beg.X, end.X) && f32Eq(beg.Y, end.Y)
-}
-
 func (qs *StrokeQuads) lineTo(pt f32.Point) {
 	end := qs.pen()
 	*qs = append(*qs, StrokeQuad{
@@ -155,11 +131,7 @@ func (qs StrokeQuads) split() []StrokeQuads {
 	return o
 }
 
-func (qs StrokeQuads) stroke(stroke StrokeStyle, dashes DashOp) StrokeQuads {
-	if !IsSolidLine(dashes) {
-		qs = qs.dash(dashes)
-	}
-
+func (qs StrokeQuads) stroke(stroke StrokeStyle) StrokeQuads {
 	var (
 		o  StrokeQuads
 		hw = 0.5 * stroke.Width
@@ -441,29 +413,6 @@ func quadBezierD2(p0, p1, p2 f32.Point, t float32) f32.Point {
 	return p.Mul(2)
 }
 
-// quadBezierLen returns the length of the Bézier curve.
-// See:
-//  https://malczak.linuxpl.com/blog/quadratic-bezier-curve-length/
-func quadBezierLen(p0, p1, p2 f32.Point) float32 {
-	a := p0.Sub(p1.Mul(2)).Add(p2)
-	b := p1.Mul(2).Sub(p0.Mul(2))
-	A := float64(4 * dotPt(a, a))
-	B := float64(4 * dotPt(a, b))
-	C := float64(dotPt(b, b))
-	if f64Eq(A, 0.0) {
-		// p1 is in the middle between p0 and p2,
-		// so it is a straight line from p0 to p2.
-		return lenPt(p2.Sub(p0))
-	}
-
-	Sabc := 2 * math.Sqrt(A+B+C)
-	A2 := math.Sqrt(A)
-	A32 := 2 * A * A2
-	C2 := 2 * math.Sqrt(C)
-	BA := B / A2
-	return float32((A32*Sabc + A2*B*(Sabc-C2) + (4*C*A-B*B)*math.Log((2*A2+BA+Sabc)/(BA+C2))) / (4 * A32))
-}
-
 func strokeQuadBezier(state strokeState, d, flatness float32) StrokeQuads {
 	// Gio strokes are only quadratic Bézier curves, w/o any inflection point.
 	// So we just have to flatten them.
@@ -549,27 +498,7 @@ func quadBezierSplit(p0, p1, p2 f32.Point, t float32) (f32.Point, f32.Point, f32
 // strokePathJoin joins the two paths rhs and lhs, according to the provided
 // stroke operation.
 func strokePathJoin(stroke StrokeStyle, rhs, lhs *StrokeQuads, hw float32, pivot, n0, n1 f32.Point, r0, r1 float32) {
-	if stroke.Miter > 0 {
-		strokePathMiterJoin(stroke, rhs, lhs, hw, pivot, n0, n1, r0, r1)
-		return
-	}
-	switch stroke.Join {
-	case BevelJoin:
-		strokePathBevelJoin(rhs, lhs, hw, pivot, n0, n1, r0, r1)
-	case RoundJoin:
-		strokePathRoundJoin(rhs, lhs, hw, pivot, n0, n1, r0, r1)
-	default:
-		panic("impossible")
-	}
-}
-
-func strokePathBevelJoin(rhs, lhs *StrokeQuads, hw float32, pivot, n0, n1 f32.Point, r0, r1 float32) {
-
-	rp := pivot.Add(n1)
-	lp := pivot.Sub(n1)
-
-	rhs.lineTo(rp)
-	lhs.lineTo(lp)
+	strokePathRoundJoin(rhs, lhs, hw, pivot, n0, n1, r0, r1)
 }
 
 func strokePathRoundJoin(rhs, lhs *StrokeQuads, hw float32, pivot, n0, n1 f32.Point, r0, r1 float32) {
@@ -594,79 +523,9 @@ func strokePathRoundJoin(rhs, lhs *StrokeQuads, hw float32, pivot, n0, n1 f32.Po
 	}
 }
 
-func strokePathMiterJoin(stroke StrokeStyle, rhs, lhs *StrokeQuads, hw float32, pivot, n0, n1 f32.Point, r0, r1 float32) {
-	if n0 == n1.Mul(-1) {
-		strokePathBevelJoin(rhs, lhs, hw, pivot, n0, n1, r0, r1)
-		return
-	}
-
-	// This is to handle nearly linear joints that would be clipped otherwise.
-	limit := math.Max(float64(stroke.Miter), 1.001)
-
-	cw := dotPt(rot90CW(n0), n1) >= 0.0
-	if cw {
-		// hw is used to calculate |R|.
-		// When running CW, n0 and n1 point the other way,
-		// so the sign of r0 and r1 is negated.
-		hw = -hw
-	}
-	hw64 := float64(hw)
-
-	cos := math.Sqrt(0.5 * (1 + float64(cosPt(n0, n1))))
-	d := hw64 / cos
-	if math.Abs(limit*hw64) < math.Abs(d) {
-		stroke.Miter = 0 // Set miter to zero to disable the miter joint.
-		strokePathJoin(stroke, rhs, lhs, hw, pivot, n0, n1, r0, r1)
-		return
-	}
-	mid := pivot.Add(normPt(n0.Add(n1), float32(d)))
-
-	rp := pivot.Add(n1)
-	lp := pivot.Sub(n1)
-	switch {
-	case cw:
-		// Path bends to the right, ie. CW.
-		lhs.lineTo(mid)
-	default:
-		// Path bends to the left, ie. CCW.
-		rhs.lineTo(mid)
-	}
-	rhs.lineTo(rp)
-	lhs.lineTo(lp)
-}
-
 // strokePathCap caps the provided path qs, according to the provided stroke operation.
 func strokePathCap(stroke StrokeStyle, qs *StrokeQuads, hw float32, pivot, n0 f32.Point) {
-	switch stroke.Cap {
-	case FlatCap:
-		strokePathFlatCap(qs, hw, pivot, n0)
-	case SquareCap:
-		strokePathSquareCap(qs, hw, pivot, n0)
-	case RoundCap:
-		strokePathRoundCap(qs, hw, pivot, n0)
-	default:
-		panic("impossible")
-	}
-}
-
-// strokePathFlatCap caps the start or end of a path with a flat cap.
-func strokePathFlatCap(qs *StrokeQuads, hw float32, pivot, n0 f32.Point) {
-	end := pivot.Sub(n0)
-	qs.lineTo(end)
-}
-
-// strokePathSquareCap caps the start or end of a path with a square cap.
-func strokePathSquareCap(qs *StrokeQuads, hw float32, pivot, n0 f32.Point) {
-	var (
-		e       = pivot.Add(rot90CCW(n0))
-		corner1 = e.Add(n0)
-		corner2 = e.Sub(n0)
-		end     = pivot.Sub(n0)
-	)
-
-	qs.lineTo(corner1)
-	qs.lineTo(corner2)
-	qs.lineTo(end)
+	strokePathRoundCap(qs, hw, pivot, n0)
 }
 
 // strokePathRoundCap caps the start or end of a path with a round cap.
@@ -763,9 +622,9 @@ func dist(p1, p2 f32.Point) float64 {
 	return math.Hypot(dx, dy)
 }
 
-func StrokePathCommands(style StrokeStyle, dashes DashOp, scene []byte) StrokeQuads {
+func StrokePathCommands(style StrokeStyle, scene []byte) StrokeQuads {
 	quads := decodeToStrokeQuads(scene)
-	return quads.stroke(style, dashes)
+	return quads.stroke(style)
 }
 
 // decodeToStrokeQuads decodes scene commands to quads ready to stroke.
diff --git a/op/clip/clip.go b/op/clip/clip.go
index 7a0a2f26..ad79e2db 100644
--- a/op/clip/clip.go
+++ b/op/clip/clip.go
@@ -21,8 +21,7 @@ type Op struct {
 	path PathSpec
 
 	outline bool
-	stroke  StrokeStyle
-	dashes  DashSpec
+	width   float32
 }
 
 // Stack represents an Op pushed on the clip stack.
@@ -54,17 +53,8 @@ func (p Op) Add(o *op.Ops) {
 }
 
 func (p Op) add(o *op.Ops, push bool) {
-	str := p.stroke
 	path := p.path
 	outline := p.outline
-	approx := str.Width > 0 && !(p.dashes == DashSpec{} && str.Miter == 0 && str.Join == RoundJoin && str.Cap == RoundCap)
-	if approx {
-		// If the stroke is not natively supported by the compute renderer, construct a filled path
-		// that approximates it.
-		path = p.approximateStroke(o)
-		str = StrokeStyle{}
-		outline = true
-	}
 
 	bo := binary.LittleEndian
 	if path.hasSegments {
@@ -75,9 +65,9 @@ func (p Op) add(o *op.Ops, push bool) {
 	}
 
 	bounds := path.bounds
-	if str.Width > 0 {
+	if p.width > 0 {
 		// Expand bounds to cover stroke.
-		half := int(str.Width*.5 + .5)
+		half := int(p.width*.5 + .5)
 		bounds.Min.X -= half
 		bounds.Min.Y -= half
 		bounds.Max.X += half
@@ -85,7 +75,7 @@ func (p Op) add(o *op.Ops, push bool) {
 		data := o.Internal.Write(ops.TypeStrokeLen)
 		data[0] = byte(ops.TypeStroke)
 		bo := binary.LittleEndian
-		bo.PutUint32(data[1:], math.Float32bits(str.Width))
+		bo.PutUint32(data[1:], math.Float32bits(p.width))
 	}
 
 	data := o.Internal.Write(ops.TypeClipLen)
@@ -108,66 +98,6 @@ func (s Stack) Pop() {
 	data[0] = byte(ops.TypePopClip)
 }
 
-func (p Op) approximateStroke(o *op.Ops) PathSpec {
-	if !p.path.hasSegments {
-		return PathSpec{}
-	}
-
-	var r ops.Reader
-	// Add path op for us to decode. Use a macro to omit it from later decodes.
-	ignore := op.Record(o)
-	r.ResetAt(&o.Internal, o.Internal.PC())
-	p.path.spec.Add(o)
-	ignore.Stop()
-	encOp, ok := r.Decode()
-	if !ok || ops.OpType(encOp.Data[0]) != ops.TypeAux {
-		panic("corrupt path data")
-	}
-	pathData := encOp.Data[ops.TypeAuxLen:]
-
-	// Decode dashes in a similar way.
-	var dashes stroke.DashOp
-	if p.dashes.phase != 0 || p.dashes.size > 0 {
-		ignore := op.Record(o)
-		r.ResetAt(&o.Internal, o.Internal.PC())
-		p.dashes.spec.Add(o)
-		ignore.Stop()
-		encOp, ok := r.Decode()
-		if !ok || ops.OpType(encOp.Data[0]) != ops.TypeAux {
-			panic("corrupt dash data")
-		}
-		dashes.Dashes = make([]float32, p.dashes.size)
-		dashData := encOp.Data[ops.TypeAuxLen:]
-		bo := binary.LittleEndian
-		for i := range dashes.Dashes {
-			dashes.Dashes[i] = math.Float32frombits(bo.Uint32(dashData[i*4:]))
-		}
-		dashes.Phase = p.dashes.phase
-	}
-
-	// Approximate and output path data.
-	var outline Path
-	outline.Begin(o)
-	ss := stroke.StrokeStyle{
-		Width: p.stroke.Width,
-		Miter: p.stroke.Miter,
-		Cap:   stroke.StrokeCap(p.stroke.Cap),
-		Join:  stroke.StrokeJoin(p.stroke.Join),
-	}
-	quads := stroke.StrokePathCommands(ss, dashes, pathData)
-	pen := f32.Pt(0, 0)
-	for _, quad := range quads {
-		q := quad.Quad
-		if q.From != pen {
-			pen = q.From
-			outline.MoveTo(pen)
-		}
-		outline.contour = int(quad.Contour)
-		outline.QuadTo(q.Ctrl, q.To)
-	}
-	return outline.End()
-}
-
 type PathSpec struct {
 	spec op.CallOp
 	// open is true if any path contour is not closed. A closed contour starts
@@ -382,6 +312,21 @@ func (p *Path) Close() {
 	p.end()
 }
 
+// Stroke represents a stroked path.
+type Stroke struct {
+	Path PathSpec
+	// Width of the stroked path.
+	Width float32
+}
+
+// Op returns a clip operation representing the stroke.
+func (s Stroke) Op() Op {
+	return Op{
+		path:  s.Path,
+		width: s.Width,
+	}
+}
+
 // Outline represents the area inside of a path, according to the
 // non-zero winding rule.
 type Outline struct {
diff --git a/op/clip/stroke.go b/op/clip/stroke.go
deleted file mode 100644
index 623d57a9..00000000
--- a/op/clip/stroke.go
+++ /dev/null
@@ -1,118 +0,0 @@
-// SPDX-License-Identifier: Unlicense OR MIT
-
-package clip
-
-import (
-	"encoding/binary"
-	"math"
-
-	"gioui.org/internal/ops"
-	"gioui.org/op"
-)
-
-// Stroke represents a stroked path.
-type Stroke struct {
-	Path  PathSpec
-	Style StrokeStyle
-
-	// Dashes specify the dashes of the stroke.
-	// The empty value denotes no dashes.
-	Dashes DashSpec
-}
-
-// Op returns a clip operation representing the stroke.
-func (s Stroke) Op() Op {
-	return Op{
-		path:   s.Path,
-		stroke: s.Style,
-		dashes: s.Dashes,
-	}
-}
-
-// StrokeStyle describes how a path should be stroked.
-type StrokeStyle struct {
-	Width float32 // Width of the stroked path.
-
-	// Miter is the limit to apply to a miter joint.
-	// The zero Miter disables the miter joint; setting Miter to +∞
-	// unconditionally enables the miter joint.
-	Miter float32
-	Cap   StrokeCap  // Cap describes the head or tail of a stroked path.
-	Join  StrokeJoin // Join describes how stroked paths are collated.
-}
-
-// StrokeCap describes the head or tail of a stroked path.
-type StrokeCap uint8
-
-const (
-	// RoundCap caps stroked paths with a round cap, joining the right-hand and
-	// left-hand sides of a stroked path with a half disc of diameter the
-	// stroked path's width.
-	RoundCap StrokeCap = iota
-
-	// FlatCap caps stroked paths with a flat cap, joining the right-hand
-	// and left-hand sides of a stroked path with a straight line.
-	FlatCap
-
-	// SquareCap caps stroked paths with a square cap, joining the right-hand
-	// and left-hand sides of a stroked path with a half square of length
-	// the stroked path's width.
-	SquareCap
-)
-
-// StrokeJoin describes how stroked paths are collated.
-type StrokeJoin uint8
-
-const (
-	// RoundJoin joins path segments with a round segment.
-	RoundJoin StrokeJoin = iota
-
-	// BevelJoin joins path segments with sharp bevels.
-	BevelJoin
-)
-
-// Dash records dashes' lengths and phase for a stroked path.
-type Dash struct {
-	ops   *ops.Ops
-	macro op.MacroOp
-	phase float32
-	size  uint8 // size of the pattern
-}
-
-func (d *Dash) Begin(o *op.Ops) {
-	d.ops = &o.Internal
-	d.macro = op.Record(o)
-	// Write the TypeAux opcode
-	data := d.ops.Write(ops.TypeAuxLen)
-	data[0] = byte(ops.TypeAux)
-}
-
-func (d *Dash) Phase(v float32) {
-	d.phase = v
-}
-
-func (d *Dash) Dash(length float32) {
-	if d.size == math.MaxUint8 {
-		panic("clip: dash pattern too large")
-	}
-	data := d.ops.Write(4)
-	bo := binary.LittleEndian
-	bo.PutUint32(data[0:], math.Float32bits(length))
-	d.size++
-}
-
-func (d *Dash) End() DashSpec {
-	c := d.macro.Stop()
-	return DashSpec{
-		spec:  c,
-		phase: d.phase,
-		size:  d.size,
-	}
-}
-
-// DashSpec describes a dashed pattern.
-type DashSpec struct {
-	spec  op.CallOp
-	phase float32
-	size  uint8 // size of the pattern
-}
diff --git a/widget/border.go b/widget/border.go
index 694c9281..8d1bcd10 100644
--- a/widget/border.go
+++ b/widget/border.go
@@ -35,7 +35,7 @@ func (b Border) Layout(gtx layout.Context, w layout.Widget) layout.Dimensions {
 		b.Color,
 		clip.Stroke{
 			Path:  clip.UniformRRect(r, rr).Path(gtx.Ops),
-			Style: clip.StrokeStyle{Width: width},
+			Width: width,
 		}.Op(),
 	)
 
diff --git a/widget/material/loader.go b/widget/material/loader.go
index 7a57bbe0..904a214d 100644
--- a/widget/material/loader.go
+++ b/widget/material/loader.go
@@ -74,10 +74,7 @@ func clipLoader(ops *op.Ops, startAngle, endAngle, radius float32) clip.Op {
 	p.Move(pen)
 	p.Arc(center, center, delta)
 	return clip.Stroke{
-		Path: p.End(),
-		Style: clip.StrokeStyle{
-			Width: width,
-			Cap:   clip.FlatCap,
-		},
+		Path:  p.End(),
+		Width: width,
 	}.Op()
 }