freetype/raster: Rename Fixed and Fixed64 to Fix32 and Fix64.
R=rsc CC=golang-dev, rog http://codereview.appspot.com/1686048
This commit is contained in:
Nigel Tao
parent
4d90648d2c
commit
3e38a96419
7 changed files with 76 additions and 76 deletions
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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) {
|
||||
|
|
|
|||
|
|
@ -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) {
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
Loading…
Reference in a new issue