aw/golang-freetype
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

freetype/raster: Rename Fixed and Fixed64 to Fix32 and Fix64.

Browse Source 
R=rsc
CC=golang-dev, rog
http://codereview.appspot.com/1686048
This commit is contained in:
Nigel Tao 2010-07-01 09:42:43 +10:00
parent 4d90648d2c
commit 3e38a96419
7 changed files with 76 additions and 76 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
example/freetype/main.go
View File

@ -111,7 +111,7 @@ func main() {
log.Stderr(err)
return
}
pt.Y += c.PointToFixed(*size * *spacing)
pt.Y += c.PointToFix32(*size * *spacing)
}
// Save that RGBA image to disk.

2
example/gamma/main.go
View File

@ -18,7 +18,7 @@ import (
)
func p(x, y int) raster.Point {
return raster.Point{raster.Fixed(x * 256), raster.Fixed(y * 256)}
return raster.Point{raster.Fix32(x * 256), raster.Fix32(y * 256)}
}
func clear(m *image.Alpha) {

2
example/raster/main.go
View File

@ -83,7 +83,7 @@ var inside = []node{
func p(n node) raster.Point {
x, y := 20+n.x/4, 380-n.y/4
return raster.Point{raster.Fixed(x * 256), raster.Fixed(y * 256)}
return raster.Point{raster.Fix32(x * 256), raster.Fix32(y * 256)}
}
func contour(r *raster.Rasterizer, ns []node) {

22
example/round/main.go
View File

@ -27,8 +27,8 @@ func main() {
n = 17
r = 256 * 80
)
s := raster.Fixed(r * math.Sqrt(2) / 2)
t := raster.Fixed(r * math.Tan(math.Pi/8))
s := raster.Fix32(r * math.Sqrt(2) / 2)
t := raster.Fix32(r * math.Tan(math.Pi/8))
m := image.NewRGBA(800, 600)
for y := 0; y < m.Height(); y++ {
@ -41,12 +41,12 @@ func main() {
z := raster.NewRasterizer(800, 600)
for i := 0; i < n; i++ {
cx := raster.Fixed(25600 + 51200*(i%4))
cy := raster.Fixed(2560 + 32000*(i/4))
cx := raster.Fix32(25600 + 51200*(i%4))
cy := raster.Fix32(2560 + 32000*(i/4))
c := raster.Point{cx, cy}
theta := math.Pi * (0.5 + 0.5*float64(i)/(n-1))
dx := raster.Fixed(r * math.Cos(theta))
dy := raster.Fixed(r * math.Sin(theta))
dx := raster.Fix32(r * math.Cos(theta))
dy := raster.Fix32(r * math.Sin(theta))
d := raster.Point{dx, dy}
// Draw a quarter-circle approximated by two quadratic segments,
// with each segment spanning 45 degrees.
@ -58,7 +58,7 @@ func main() {
// For an explanation of the magic constants 22, 150, 181 and 256, read the
// comments in the freetype/raster package.
dot := 256 * d.Dot(raster.Point{0, r}) / (r * r)
multiple := raster.Fixed(150 - 22*(dot-181)/(256-181))
multiple := raster.Fix32(150 - 22*(dot-181)/(256-181))
z.Add2(c.Add(raster.Point{dx, r + dy}.Mul(multiple)), c.Add(d))
// Close the curve.
z.Add1(c)
@ -66,12 +66,12 @@ func main() {
z.Rasterize(mp)
for i := 0; i < n; i++ {
cx := raster.Fixed(25600 + 51200*(i%4))
cy := raster.Fixed(2560 + 32000*(i/4))
cx := raster.Fix32(25600 + 51200*(i%4))
cy := raster.Fix32(2560 + 32000*(i/4))
for j := 0; j < n; j++ {
theta := math.Pi * float64(j) / (n - 1)
dx := raster.Fixed(r * math.Cos(theta))
dy := raster.Fixed(r * math.Sin(theta))
dx := raster.Fix32(r * math.Cos(theta))
dy := raster.Fix32(r * math.Sin(theta))
m.Set(int((cx+dx)/256), int((cy+dy)/256), image.Yellow)
}
}

38
freetype/freetype.go
View File

@ -22,9 +22,9 @@ func ParseFont(b []byte) (*truetype.Font, os.Error) {
}
// Pt converts from a co-ordinate pair measured in pixels to a raster.Point
// co-ordinate pair measured in raster.Fixed units.
// co-ordinate pair measured in raster.Fix32 units.
func Pt(x, y int) raster.Point {
return raster.Point{raster.Fixed(x << 8), raster.Fixed(y << 8)}
return raster.Point{raster.Fix32(x << 8), raster.Fix32(y << 8)}
}
// A Context holds the state for drawing text in a given font and size.
@ -53,10 +53,10 @@ type Context struct {
scale int
}
// FUnitToFixed converts the given number of FUnits into fixed point units,
// FUnitToFix32 converts the given number of FUnits into fixed point units,
// rounding to nearest.
func (c *Context) FUnitToFixed(x int) raster.Fixed {
return raster.Fixed((x*c.scale + 128) >> 8)
func (c *Context) FUnitToFix32(x int) raster.Fix32 {
return raster.Fix32((x*c.scale + 128) >> 8)
}
// FUnitToPixelRD converts the given number of FUnits into pixel units,
@ -71,14 +71,14 @@ func (c *Context) FUnitToPixelRU(x int) int {
return (x*c.scale + 0xffff) >> 16
}
// PointToFixed converts the given number of points (as in ``a 12 point font'')
// PointToFix32 converts the given number of points (as in ``a 12 point font'')
// into fixed point units.
func (c *Context) PointToFixed(x float) raster.Fixed {
return raster.Fixed(x * float(c.dpi) * (256.0 / 72.0))
func (c *Context) PointToFix32(x float) raster.Fix32 {
return raster.Fix32(x * float(c.dpi) * (256.0 / 72.0))
}
// drawContour draws the given closed contour with the given offset.
func (c *Context) drawContour(ps []truetype.Point, dx, dy raster.Fixed) {
func (c *Context) drawContour(ps []truetype.Point, dx, dy raster.Fix32) {
if len(ps) == 0 {
return
}
@ -86,15 +86,15 @@ func (c *Context) drawContour(ps []truetype.Point, dx, dy raster.Fixed) {
// start is the same thing measured in fixed point units and positive Y
// going downwards, and offset by (dx, dy)
start := raster.Point{
dx + c.FUnitToFixed(int(ps[0].X)),
dy + c.FUnitToFixed(c.upe-int(ps[0].Y)),
dx + c.FUnitToFix32(int(ps[0].X)),
dy + c.FUnitToFix32(c.upe-int(ps[0].Y)),
}
c.r.Start(start)
q0, on0 := start, true
for _, p := range ps[1:] {
q := raster.Point{
dx + c.FUnitToFixed(int(p.X)),
dy + c.FUnitToFixed(c.upe-int(p.Y)),
dx + c.FUnitToFix32(int(p.X)),
dy + c.FUnitToFix32(c.upe-int(p.Y)),
}
on := p.Flags&0x01 != 0
if on {
@ -134,13 +134,13 @@ func (c *Context) DrawText(p raster.Painter, pt raster.Point, s string) (err os.
if c.font == nil {
return os.NewError("freetype: DrawText called with a nil font")
}
// pt.X, pt.Y, x, y, dx, dy and x0 are measured in raster.Fixed units,
// pt.X, pt.Y, x, y, dx, dy and x0 are measured in raster.Fix32 units,
// c.r.Dx, c.r.Dy, c.xmin and c.ymin are measured in pixels, and
// advance is measured in FUnits.
var x, y raster.Fixed
var x, y raster.Fix32
advance, x0 := 0, pt.X
dx := raster.Fixed(-c.xmin << 8)
dy := raster.Fixed(-c.ymin << 8)
dx := raster.Fix32(-c.xmin << 8)
dy := raster.Fix32(-c.ymin << 8)
c.r.Dy, y = c.ymin+int(pt.Y>>8), pt.Y&0xff
y += dy
prev, hasPrev := truetype.Index(0), false
@ -162,8 +162,8 @@ func (c *Context) DrawText(p raster.Painter, pt raster.Point, s string) (err os.
return
}
}
// Convert the advance from FUnits to raster.Fixed units.
x = x0 + c.FUnitToFixed(advance)
// Convert the advance from FUnits to raster.Fix32 units.
x = x0 + c.FUnitToFix32(advance)
// Break the co-ordinate down into an integer pixel part and a
// sub-pixel part, making sure that the latter is non-negative.
c.r.Dx, x = c.xmin+int(x>>8), x&0xff

60
freetype/raster/geom.go
View File

@ -10,15 +10,15 @@ import (
"math"
)
// A Fixed is a 24.8 fixed point number.
type Fixed int32
// A Fix32 is a 24.8 fixed point number.
type Fix32 int32
// A Fixed64 is a 48.16 fixed point number.
type Fixed64 int64
// A Fix64 is a 48.16 fixed point number.
type Fix64 int64
// String returns a human-readable representation of a 24.8 fixed point number.
// For example, the number one-and-a-quarter becomes "1:064".
func (x Fixed) String() string {
func (x Fix32) String() string {
i, f := x/256, x%256
if f < 0 {
f = -f
@ -28,7 +28,7 @@ func (x Fixed) String() string {
// String returns a human-readable representation of a 48.16 fixed point number.
// For example, the number one-and-a-quarter becomes "1:00064".
func (x Fixed64) String() string {
func (x Fix64) String() string {
i, f := x/65536, x%65536
if f < 0 {
f = -f
@ -37,7 +37,7 @@ func (x Fixed64) String() string {
}
// maxAbs returns the maximum of abs(a) and abs(b).
func maxAbs(a, b Fixed) Fixed {
func maxAbs(a, b Fix32) Fix32 {
if a < 0 {
a = -a
}
@ -53,7 +53,7 @@ func maxAbs(a, b Fixed) Fixed {
// A Point represents a two-dimensional point or vector, in 24.8 fixed point
// format.
type Point struct {
X, Y Fixed
X, Y Fix32
}
// Add returns the vector p + q.
@ -67,7 +67,7 @@ func (p Point) Sub(q Point) Point {
}
// Mul returns the vector k * p.
func (p Point) Mul(k Fixed) Point {
func (p Point) Mul(k Fix32) Point {
return Point{p.X * k / 256, p.Y * k / 256}
}
@ -77,23 +77,23 @@ func (p Point) Neg() Point {
}
// Dot returns the dot product p·q.
func (p Point) Dot(q Point) Fixed64 {
func (p Point) Dot(q Point) Fix64 {
px, py := int64(p.X), int64(p.Y)
qx, qy := int64(q.X), int64(q.Y)
return Fixed64(px*qx + py*qy)
return Fix64(px*qx + py*qy)
}
// Len returns the length of the vector p.
func (p Point) Len() Fixed {
func (p Point) Len() Fix32 {
// TODO(nigeltao): use fixed point math.
x := float64(p.X)
y := float64(p.Y)
return Fixed(math.Sqrt(x*x + y*y))
return Fix32(math.Sqrt(x*x + y*y))
}
// Norm returns the vector p normalized to the given length, or the zero Point
// if p is degenerate.
func (p Point) Norm(length Fixed) Point {
func (p Point) Norm(length Fix32) Point {
d := p.Len()
if d == 0 {
return Point{0, 0}
@ -101,7 +101,7 @@ func (p Point) Norm(length Fixed) Point {
s, t := int64(length), int64(d)
x := int64(p.X) * s / t
y := int64(p.Y) * s / t
return Point{Fixed(x), Fixed(y)}
return Point{Fix32(x), Fix32(y)}
}
// Rot45CW returns the vector p rotated clockwise by 45 degrees.
@ -111,7 +111,7 @@ func (p Point) Rot45CW() Point {
px, py := int64(p.X), int64(p.Y)
qx := (+px - py) * 181 / 256
qy := (+px + py) * 181 / 256
return Point{Fixed(qx), Fixed(qy)}
return Point{Fix32(qx), Fix32(qy)}
}
// Rot90CW returns the vector p rotated clockwise by 90 degrees.
@ -127,7 +127,7 @@ func (p Point) Rot135CW() Point {
px, py := int64(p.X), int64(p.Y)
qx := (-px - py) * 181 / 256
qy := (+px - py) * 181 / 256
return Point{Fixed(qx), Fixed(qy)}
return Point{Fix32(qx), Fix32(qy)}
}
// Rot45CCW returns the vector p rotated counter-clockwise by 45 degrees.
@ -137,7 +137,7 @@ func (p Point) Rot45CCW() Point {
px, py := int64(p.X), int64(p.Y)
qx := (+px + py) * 181 / 256
qy := (-px + py) * 181 / 256
return Point{Fixed(qx), Fixed(qy)}
return Point{Fix32(qx), Fix32(qy)}
}
// Rot90CCW returns the vector p rotated counter-clockwise by 90 degrees.
@ -153,7 +153,7 @@ func (p Point) Rot135CCW() Point {
px, py := int64(p.X), int64(p.Y)
qx := (-px + py) * 181 / 256
qy := (-px - py) * 181 / 256
return Point{Fixed(qx), Fixed(qy)}
return Point{Fix32(qx), Fix32(qy)}
}
// An Adder accumulates points on a curve.
@ -170,7 +170,7 @@ type Adder interface {
// A Path is a sequence of curves, and a curve is a start point followed by a
// sequence of linear, quadratic or cubic segments.
type Path []Fixed
type Path []Fix32
// String returns a human-readable representation of a Path.
func (p Path) String() string {
@ -181,16 +181,16 @@ func (p Path) String() string {
}
switch p[i] {
case 0:
s += "S0" + fmt.Sprint([]Fixed(p[i+1:i+3]))
s += "S0" + fmt.Sprint([]Fix32(p[i+1:i+3]))
i += 4
case 1:
s += "A1" + fmt.Sprint([]Fixed(p[i+1:i+3]))
s += "A1" + fmt.Sprint([]Fix32(p[i+1:i+3]))
i += 4
case 2:
s += "A2" + fmt.Sprint([]Fixed(p[i+1:i+5]))
s += "A2" + fmt.Sprint([]Fix32(p[i+1:i+5]))
i += 6
case 3:
s += "A3" + fmt.Sprint([]Fixed(p[i+1:i+7]))
s += "A3" + fmt.Sprint([]Fix32(p[i+1:i+7]))
i += 8
default:
panic("freetype/raster: bad path")
@ -204,7 +204,7 @@ func (p *Path) grow(n int) {
n += len(*p)
if n > cap(*p) {
old := *p
*p = make([]Fixed, n, 2*n+8)
*p = make([]Fix32, n, 2*n+8)
copy(*p, old)
return
}
@ -291,13 +291,13 @@ const (
)
// AddStroke adds a stroked Path.
func (p *Path) AddStroke(q Path, width Fixed, cap Cap, join Join) {
func (p *Path) AddStroke(q Path, width Fix32, cap Cap, join Join) {
Stroke(p, q, width, cap, join)
}
// Stroke adds the stroked Path q to p. The resultant stroked path is typically
// self-intersecting and should be rasterized with UseNonZeroWinding.
func Stroke(p Adder, q Path, width Fixed, cap Cap, join Join) {
func Stroke(p Adder, q Path, width Fix32, cap Cap, join Join) {
if len(q) == 0 {
return
}
@ -446,17 +446,17 @@ func addArc(p Adder, pivot, n0, n1 Point) {
// d is the normalized dot product between s and n1. Since the angle ranges
// between 0 and 45 degrees then d ranges between 256/256 and 181/256.
d := 256 * s.Dot(n1) / r2
multiple := Fixed(150 - 22*(d-181)/(256-181))
multiple := Fix32(150 - 22*(d-181)/(256-181))
p.Add2(pivot.Add(s.Add(n1).Mul(multiple)), pivot.Add(n1))
}
// stroke adds the stroked Path q to p, where q consists of exactly one curve.
func stroke(p Adder, q Path, width Fixed, cap Cap, join Join) {
func stroke(p Adder, q Path, width Fix32, cap Cap, join Join) {
// Stroking is implemented by deriving two paths each width/2 apart from q.
// The left-hand-side path is added immediately to p; the right-hand-side
// path is accumulated in r, and once we've finished adding the LHS to p
// we add the RHS in reverse order.
r := Path(make([]Fixed, 0, len(q)))
r := Path(make([]Fix32, 0, len(q)))
var start, anorm Point
a := Point{q[1], q[2]}
i := 4

26
freetype/raster/raster.go
View File

@ -116,12 +116,12 @@ func (r *Rasterizer) setCell(xi, yi int) {
// scan accumulates area/coverage for the yi'th scanline, going from
// x0 to x1 in the horizontal direction (in 24.8 fixed point co-ordinates)
// and from y0f to y1f fractional vertical units within that scanline.
func (r *Rasterizer) scan(yi int, x0, y0f, x1, y1f Fixed) {
func (r *Rasterizer) scan(yi int, x0, y0f, x1, y1f Fix32) {
// Break the 24.8 fixed point X co-ordinates into integral and fractional parts.
x0i := int(x0) / 256
x0f := x0 - Fixed(256*x0i)
x0f := x0 - Fix32(256*x0i)
x1i := int(x1) / 256
x1f := x1 - Fixed(256*x1i)
x1f := x1 - Fix32(256*x1i)
// A perfectly horizontal scan.
if y0f == y1f {
@ -139,7 +139,7 @@ func (r *Rasterizer) scan(yi int, x0, y0f, x1, y1f Fixed) {
// all intermediate cells go through the full width of the cell,
// or 256 units in 24.8 fixed point format.
var (
p, q, edge0, edge1 Fixed
p, q, edge0, edge1 Fix32
xiDelta int
)
if dx > 0 {
@ -201,9 +201,9 @@ func (r *Rasterizer) Add1(b Point) {
dx, dy := x1-x0, y1-y0
// Break the 24.8 fixed point Y co-ordinates into integral and fractional parts.
y0i := int(y0) / 256
y0f := y0 - Fixed(256*y0i)
y0f := y0 - Fix32(256*y0i)
y1i := int(y1) / 256
y1f := y1 - Fixed(256*y1i)
y1f := y1 - Fix32(256*y1i)
if y0i == y1i {
// There is only one scanline.
@ -213,7 +213,7 @@ func (r *Rasterizer) Add1(b Point) {
// This is a vertical line segment. We avoid calling r.scan and instead
// manipulate r.area and r.cover directly.
var (
edge0, edge1 Fixed
edge0, edge1 Fix32
yiDelta int
)
if dy > 0 {
@ -250,7 +250,7 @@ func (r *Rasterizer) Add1(b Point) {
// all intermediate scanlines go through the full height of the row, or 256
// units in 24.8 fixed point format.
var (
p, q, edge0, edge1 Fixed
p, q, edge0, edge1 Fix32
yiDelta int
)
if dy > 0 {
@ -302,7 +302,7 @@ func (r *Rasterizer) Add1(b Point) {
func (r *Rasterizer) Add2(b, c Point) {
// Calculate nSplit (the number of recursive decompositions) based on how `curvy' it is.
// Specifically, how much the middle point b deviates from (a+c)/2.
dev := maxAbs(r.a.X-2*b.X+c.X, r.a.Y-2*b.Y+c.Y) / Fixed(r.splitScale2)
dev := maxAbs(r.a.X-2*b.X+c.X, r.a.Y-2*b.Y+c.Y) / Fix32(r.splitScale2)
nsplit := 0
for dev > 0 {
dev /= 4
@ -357,8 +357,8 @@ func (r *Rasterizer) Add2(b, c Point) {
// Add3 adds a cubic segment to the current curve.
func (r *Rasterizer) Add3(b, c, d Point) {
// Calculate nSplit (the number of recursive decompositions) based on how `curvy' it is.
dev2 := maxAbs(r.a.X-3*(b.X+c.X)+d.X, r.a.Y-3*(b.Y+c.Y)+d.Y) / Fixed(r.splitScale2)
dev3 := maxAbs(r.a.X-2*b.X+d.X, r.a.Y-2*b.Y+d.Y) / Fixed(r.splitScale3)
dev2 := maxAbs(r.a.X-3*(b.X+c.X)+d.X, r.a.Y-3*(b.Y+c.Y)+d.Y) / Fix32(r.splitScale2)
dev3 := maxAbs(r.a.X-2*b.X+d.X, r.a.Y-2*b.Y+d.Y) / Fix32(r.splitScale3)
nsplit := 0
for dev2 > 0 || dev3 > 0 {
dev2 /= 8
@ -443,7 +443,7 @@ func (r *Rasterizer) AddPath(p Path) {
}
// AddStroke adds a stroked Path.
func (r *Rasterizer) AddStroke(q Path, width Fixed, cap Cap, join Join) {
func (r *Rasterizer) AddStroke(q Path, width Fix32, cap Cap, join Join) {
Stroke(r, q, width, cap, join)
}
@ -541,7 +541,7 @@ func (r *Rasterizer) Clear() {
}
// SetBounds sets the maximum width and height of the rasterized image and
// calls Clear. The width and height are in pixels, not Fixed units.
// calls Clear. The width and height are in pixels, not Fix32 units.
func (r *Rasterizer) SetBounds(width, height int) {
if width < 0 {
width = 0