diff --git a/canvas.go b/canvas.go
index 9937ae7..282eec8 100644
--- a/canvas.go
+++ b/canvas.go
@@ -27,6 +27,7 @@ type Canvas struct {
 
 type pathPoint struct {
 	pos    lm.Vec2
+	tf     lm.Vec2
 	move   bool
 	next   lm.Vec2
 	attach bool
@@ -94,7 +95,16 @@ func (cv *Canvas) ptToGL(x, y float32) (fx, fy float32) {
 }
 
 func (cv *Canvas) vecToGL(v lm.Vec2) (fx, fy float32) {
+	return v[0]*2/cv.fw - 1, -v[1]*2/cv.fh + 1
+}
+
+func (cv *Canvas) tf(v lm.Vec2) lm.Vec2 {
 	v, _ = v.MulMat3x3(cv.state.transform)
+	return v
+}
+
+func (cv *Canvas) tfToGL(x, y float32) (fx, fy float32) {
+	v := cv.tf(lm.Vec2{x, y})
 	return v[0]*2/cv.fw - 1, -v[1]*2/cv.fh + 1
 }
 
@@ -304,10 +314,10 @@ func (cv *Canvas) FillRect(x, y, w, h float32) {
 
 	gli.UseProgram(sr.id)
 
-	x0f, y0f := cv.ptToGL(x, y)
-	x1f, y1f := cv.ptToGL(x, y+h)
-	x2f, y2f := cv.ptToGL(x+w, y+h)
-	x3f, y3f := cv.ptToGL(x+w, y)
+	x0f, y0f := cv.tfToGL(x, y)
+	x1f, y1f := cv.tfToGL(x, y+h)
+	x2f, y2f := cv.tfToGL(x+w, y+h)
+	x3f, y3f := cv.tfToGL(x+w, y)
 
 	gli.BindBuffer(gl_ARRAY_BUFFER, buf)
 	data := [8]float32{x0f, y0f, x1f, y1f, x2f, y2f, x3f, y3f}
diff --git a/images.go b/images.go
index c747f67..0f47296 100644
--- a/images.go
+++ b/images.go
@@ -158,10 +158,10 @@ func (cv *Canvas) DrawImage(img *Image, coords ...float32) {
 		dw, dh = coords[6], coords[7]
 	}
 
-	dx0, dy0 := cv.ptToGL(dx, dy)
-	dx1, dy1 := cv.ptToGL(dx, dy+dh)
-	dx2, dy2 := cv.ptToGL(dx+dw, dy+dh)
-	dx3, dy3 := cv.ptToGL(dx+dw, dy)
+	dx0, dy0 := cv.tfToGL(dx, dy)
+	dx1, dy1 := cv.tfToGL(dx, dy+dh)
+	dx2, dy2 := cv.tfToGL(dx+dw, dy+dh)
+	dx3, dy3 := cv.tfToGL(dx+dw, dy)
 	sx /= float32(img.w)
 	sy /= float32(img.h)
 	sw /= float32(img.w)
diff --git a/paths.go b/paths.go
index 97f4e6d..3acf79a 100644
--- a/paths.go
+++ b/paths.go
@@ -20,8 +20,9 @@ func (cv *Canvas) BeginPath() {
 }
 
 func (cv *Canvas) MoveTo(x, y float32) {
-	cv.linePath = append(cv.linePath, pathPoint{pos: lm.Vec2{x, y}, move: true})
-	cv.polyPath = append(cv.polyPath, pathPoint{pos: lm.Vec2{x, y}, move: true})
+	tf := cv.tf(lm.Vec2{x, y})
+	cv.linePath = append(cv.linePath, pathPoint{pos: lm.Vec2{x, y}, tf: tf, move: true})
+	cv.polyPath = append(cv.polyPath, pathPoint{pos: lm.Vec2{x, y}, tf: tf, move: true})
 }
 
 func (cv *Canvas) LineTo(x, y float32) {
@@ -52,24 +53,26 @@ func (cv *Canvas) LineTo(x, y float32) {
 			}
 
 			if draw {
-				cv.linePath[len(cv.linePath)-1].next = p
+				cv.linePath[len(cv.linePath)-1].next = cv.tf(p)
 				cv.linePath[len(cv.linePath)-1].attach = true
-				cv.linePath = append(cv.linePath, pathPoint{pos: p, move: false})
+				cv.linePath = append(cv.linePath, pathPoint{pos: p, tf: cv.tf(p), move: false})
 			} else {
-				cv.linePath = append(cv.linePath, pathPoint{pos: p, move: true})
+				cv.linePath = append(cv.linePath, pathPoint{pos: p, tf: cv.tf(p), move: true})
 			}
 
 			lp = p
 			v = tp.Sub(lp)
 		}
 	} else {
-		cv.linePath[len(cv.linePath)-1].next = lm.Vec2{x, y}
+		tf := cv.tf(lm.Vec2{x, y})
+		cv.linePath[len(cv.linePath)-1].next = tf
 		cv.linePath[len(cv.linePath)-1].attach = true
-		cv.linePath = append(cv.linePath, pathPoint{pos: lm.Vec2{x, y}, move: false})
+		cv.linePath = append(cv.linePath, pathPoint{pos: lm.Vec2{x, y}, tf: tf, move: false})
 	}
-	cv.polyPath[len(cv.polyPath)-1].next = lm.Vec2{x, y}
+	tf := cv.tf(lm.Vec2{x, y})
+	cv.polyPath[len(cv.polyPath)-1].next = tf
 	cv.polyPath[len(cv.polyPath)-1].attach = true
-	cv.polyPath = append(cv.polyPath, pathPoint{pos: lm.Vec2{x, y}, move: false})
+	cv.polyPath = append(cv.polyPath, pathPoint{pos: lm.Vec2{x, y}, tf: tf, move: false})
 }
 
 func (cv *Canvas) Arc(x, y, radius, startAngle, endAngle float32, anticlockwise bool) {
@@ -105,10 +108,10 @@ func (cv *Canvas) ClosePath() {
 	}
 	cv.linePath[len(cv.linePath)-1].next = cv.linePath[0].pos
 	cv.linePath[len(cv.linePath)-1].attach = true
-	cv.linePath = append(cv.linePath, pathPoint{pos: cv.linePath[0].pos, move: false, next: cv.linePath[1].pos, attach: true})
+	cv.linePath = append(cv.linePath, pathPoint{pos: cv.linePath[0].pos, move: false, tf: cv.linePath[0].tf, next: cv.linePath[1].pos, attach: true})
 	cv.polyPath[len(cv.polyPath)-1].next = cv.polyPath[0].pos
 	cv.polyPath[len(cv.polyPath)-1].attach = true
-	cv.polyPath = append(cv.polyPath, pathPoint{pos: cv.polyPath[0].pos, move: false, next: cv.polyPath[1].pos, attach: true})
+	cv.polyPath = append(cv.polyPath, pathPoint{pos: cv.polyPath[0].pos, move: false, tf: cv.linePath[0].tf, next: cv.polyPath[1].pos, attach: true})
 }
 
 func (cv *Canvas) Stroke() {
@@ -138,11 +141,11 @@ func (cv *Canvas) Stroke() {
 	var p0 lm.Vec2
 	for _, p := range cv.linePath {
 		if p.move {
-			p0 = p.pos
+			p0 = p.tf
 			start = true
 			continue
 		}
-		p1 := p.pos
+		p1 := p.tf
 
 		v0 := p1.Sub(p0).Norm()
 		v1 := lm.Vec2{v0[1], -v0[0]}.MulF(cv.state.stroke.lineWidth * 0.5)
diff --git a/triangulation.go b/triangulation.go
index be1ab9a..e2d1581 100644
--- a/triangulation.go
+++ b/triangulation.go
@@ -65,7 +65,7 @@ func triangulatePath(path []pathPoint, target []float32) []float32 {
 	var buf [500]lm.Vec2
 	polygon := buf[:0]
 	for _, p := range path {
-		polygon = append(polygon, p.pos)
+		polygon = append(polygon, p.tf)
 	}
 
 	for len(polygon) > 2 {