restructure Text writing for more flexibility and consistency

text/text.go

@@ -43,6 +43,7 @@ type Text struct {
 	lineHeight float64
 	tabWidth   float64
 
+	buf    []byte
 	prevR  rune
 	bounds pixel.Rect
 	glyph  pixel.TrianglesData
@@ -131,106 +132,85 @@ func (txt *Text) Clear() {
 }
 
 func (txt *Text) Write(p []byte) (n int, err error) {
-	n, err = len(p), nil // always returns this
+	txt.buf = append(txt.buf, p...)
-
+	txt.drawBuf()
-	if len(p) == 0 {
+	return len(p), nil
-		return
-	}
-
-	for len(p) > 0 {
-		r, size := utf8.DecodeRune(p)
-		p = p[size:]
-		txt.WriteRune(r)
-	}
-
-	return
 }
 
 func (txt *Text) WriteString(s string) (n int, err error) {
-	if len(s) == 0 {
+	txt.buf = append(txt.buf, s...)
-		return
+	txt.drawBuf()
-	}
-
-	for _, r := range s {
-		txt.WriteRune(r)
-	}
-
 	return len(s), nil
 }
 
 func (txt *Text) WriteByte(c byte) error {
-	//FIXME: this is not correct, what if I want to write a 4-byte rune byte by byte?
+	txt.buf = append(txt.buf, c)
-	_, err := txt.WriteRune(rune(c))
+	txt.drawBuf()
-	return err
+	return nil
 }
 
 func (txt *Text) WriteRune(r rune) (n int, err error) {
-	n, err = utf8.RuneLen(r), nil // always returns this
+	var b [4]byte
+	n = utf8.EncodeRune(b[:], r)
+	txt.buf = append(txt.buf, b[:n]...)
+	txt.drawBuf()
+	return n, nil
+}
 
-	switch r {
+func (txt *Text) drawBuf() {
-	case '\n':
+	for utf8.FullRune(txt.buf) {
-		txt.Dot -= pixel.Y(txt.lineHeight)
+		r, size := utf8.DecodeRune(txt.buf)
-		txt.Dot = txt.Dot.WithX(txt.Orig.X())
+		txt.buf = txt.buf[size:]
-		return
+
-	case '\r':
+		switch r {
-		txt.Dot = txt.Dot.WithX(txt.Orig.X())
+		case '\n':
-		return
+			txt.Dot -= pixel.Y(txt.lineHeight)
-	case '\t':
+			txt.Dot = txt.Dot.WithX(txt.Orig.X())
-		rem := math.Mod(txt.Dot.X()-txt.Orig.X(), txt.tabWidth)
+			continue
-		rem = math.Mod(rem, rem+txt.tabWidth)
+		case '\r':
-		if rem == 0 {
+			txt.Dot = txt.Dot.WithX(txt.Orig.X())
-			rem = txt.tabWidth
+			continue
+		case '\t':
+			rem := math.Mod(txt.Dot.X()-txt.Orig.X(), txt.tabWidth)
+			rem = math.Mod(rem, rem+txt.tabWidth)
+			if rem == 0 {
+				rem = txt.tabWidth
+			}
+			txt.Dot += pixel.X(rem)
+			continue
 		}
-		txt.Dot += pixel.X(rem)
-		return
-	}
 
-	if !txt.atlas.Contains(r) {
+		var rect, frame, bounds pixel.Rect
-		r = unicode.ReplacementChar
+		rect, frame, bounds, txt.Dot = txt.Atlas().DrawRune(txt.prevR, r, txt.Dot)
-	}
-	if !txt.atlas.Contains(unicode.ReplacementChar) {
-		return
-	}
 
-	glyph := txt.atlas.Glyph(r)
+		txt.prevR = r
 
-	if txt.prevR >= 0 {
+		rv := [...]pixel.Vec{pixel.V(rect.Min.X(), rect.Min.Y()),
-		txt.Dot += pixel.X(txt.atlas.Kern(txt.prevR, r))
+			pixel.V(rect.Max.X(), rect.Min.Y()),
-	}
+			pixel.V(rect.Max.X(), rect.Max.Y()),
+			pixel.V(rect.Min.X(), rect.Max.Y()),
+		}
+
+		fv := [...]pixel.Vec{pixel.V(frame.Min.X(), frame.Min.Y()),
+			pixel.V(frame.Max.X(), frame.Min.Y()),
+			pixel.V(frame.Max.X(), frame.Max.Y()),
+			pixel.V(frame.Min.X(), frame.Max.Y()),
+		}
+
+		for i, j := range [...]int{0, 1, 2, 0, 2, 3} {
+			txt.glyph[i].Position = rv[j]
+			txt.glyph[i].Picture = fv[j]
+		}
+
+		txt.tris = append(txt.tris, txt.glyph...)
+		txt.dirty = true
 
-	glyphBounds := glyph.Frame.Moved(txt.Dot - glyph.Orig)
-	if glyphBounds.W()*glyphBounds.H() != 0 {
-		glyphBounds = pixel.R(
-			glyphBounds.Min.X(),
-			txt.Dot.Y()-txt.Atlas().Descent(),
-			glyphBounds.Max.X(),
-			txt.Dot.Y()+txt.Atlas().Ascent(),
-		)
 		if txt.bounds.W()*txt.bounds.H() == 0 {
-			txt.bounds = glyphBounds
+			txt.bounds = bounds
 		} else {
-			txt.bounds = txt.bounds.Union(glyphBounds)
+			txt.bounds = txt.bounds.Union(bounds)
 		}
 	}
-
-	a := pixel.V(glyph.Frame.Min.X(), glyph.Frame.Min.Y())
-	b := pixel.V(glyph.Frame.Max.X(), glyph.Frame.Min.Y())
-	c := pixel.V(glyph.Frame.Max.X(), glyph.Frame.Max.Y())
-	d := pixel.V(glyph.Frame.Min.X(), glyph.Frame.Max.Y())
-
-	for i, v := range []pixel.Vec{a, b, c, a, c, d} {
-		txt.glyph[i].Position = v - glyph.Orig + txt.Dot
-		txt.glyph[i].Picture = v
-	}
-
-	txt.tris = append(txt.tris, txt.glyph...)
-
-	txt.Dot += pixel.X(glyph.Advance)
-	txt.prevR = r
-
-	txt.dirty = true
-
-	return
 }
 
 func (txt *Text) Draw(t pixel.Target) {