mth/ebiten
1
0
Fork 0
mirror of https://github.com/hajimehoshi/ebiten.git synced 2024-11-10 04:57:26 +01:00
Code Issues Packages Projects Releases Wiki Activity

vector: refactoring

Browse Source
This commit is contained in:
Hajime Hoshi 2022-10-14 22:36:31 +09:00
parent a1a598471b
commit 04680ff761
1 changed files with 81 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

144
vector/path.go
View File

@ -69,7 +69,7 @@ func (p *Path) LineTo(x, y float32) {
// //
// QuadTo updates the current position to (x2, y2). // QuadTo updates the current position to (x2, y2).
func (p *Path) QuadTo(x1, y1, x2, y2 float32) { func (p *Path) QuadTo(x1, y1, x2, y2 float32) {
p.quadTo(x1, y1, x2, y2, 0) p.quadTo(point{x: x1, y: y1}, point{x: x2, y: y2}, 0)
} }
// lineForTwoPoints returns parameters for a line passing through p0 and p1. // lineForTwoPoints returns parameters for a line passing through p0 and p1.
@ -82,12 +82,12 @@ func lineForTwoPoints(p0, p1 point) (a, b, c float32) {
} }
// isPointCloseToSegment detects the distance between a segment (x0, y0)-(x1, y1) and a point (x, y) is less than allow. // isPointCloseToSegment detects the distance between a segment (x0, y0)-(x1, y1) and a point (x, y) is less than allow.
func isPointCloseToSegment(x, y, x0, y0, x1, y1 float32, allow float32) bool { func isPointCloseToSegment(p, p0, p1 point, allow float32) bool {
a, b, c := lineForTwoPoints(point{x: x0, y: y0}, point{x: x1, y: y1}) a, b, c := lineForTwoPoints(p0, p1)
// The distance between a line ax+by+c=0 and (x0, y0) is // The distance between a line ax+by+c=0 and (x0, y0) is
// |ax0 + by0 + c| / √(a² + b²) // |ax0 + by0 + c| / √(a² + b²)
return allow*allow*(a*a+b*b) > (a*x+b*y+c)*(a*x+b*y+c) return allow*allow*(a*a+b*b) > (a*p.x+b*p.y+c)*(a*p.x+b*p.y+c)
} }
// crossingPointForTwoLines returns a crossing point for two lines. // crossingPointForTwoLines returns a crossing point for two lines.
@ -101,26 +101,31 @@ func crossingPointForTwoLines(p00, p01, p10, p11 point) point {
} }
} }
func (p *Path) quadTo(x1, y1, x2, y2 float32, level int) { func (p *Path) quadTo(p1, p2 point, level int) {
if level > 10 { if level > 10 {
return return
} }
x0 := p.cur.x p0 := p.cur
y0 := p.cur.y if isPointCloseToSegment(p1, p0, p2, 0.5) {
if isPointCloseToSegment(x1, y1, x0, y0, x2, y2, 0.5) { p.LineTo(p2.x, p2.y)
p.LineTo(x2, y2)
return return
} }
x01 := (x0 + x1) / 2 p01 := point{
y01 := (y0 + y1) / 2 x: (p0.x + p1.x) / 2,
x12 := (x1 + x2) / 2 y: (p0.y + p1.y) / 2,
y12 := (y1 + y2) / 2 }
x012 := (x01 + x12) / 2 p12 := point{
y012 := (y01 + y12) / 2 x: (p1.x + p2.x) / 2,
p.quadTo(x01, y01, x012, y012, level+1) y: (p1.y + p2.y) / 2,
p.quadTo(x12, y12, x2, y2, level+1) }
p012 := point{
x: (p01.x + p12.x) / 2,
y: (p01.y + p12.y) / 2,
}
p.quadTo(p01, p012, level+1)
p.quadTo(p12, p2, level+1)
} }
// CubicTo adds a cubic Bézier curve to the path. // CubicTo adds a cubic Bézier curve to the path.
@ -128,61 +133,74 @@ func (p *Path) quadTo(x1, y1, x2, y2 float32, level int) {
// //
// CubicTo updates the current position to (x3, y3). // CubicTo updates the current position to (x3, y3).
func (p *Path) CubicTo(x1, y1, x2, y2, x3, y3 float32) { func (p *Path) CubicTo(x1, y1, x2, y2, x3, y3 float32) {
p.cubicTo(x1, y1, x2, y2, x3, y3, 0) p.cubicTo(point{x: x1, y: y1}, point{x: x2, y: y2}, point{x: x3, y: y3}, 0)
} }
func (p *Path) cubicTo(x1, y1, x2, y2, x3, y3 float32, level int) { func (p *Path) cubicTo(p1, p2, p3 point, level int) {
if level > 10 { if level > 10 {
return return
} }
x0 := p.cur.x p0 := p.cur
y0 := p.cur.y if isPointCloseToSegment(p1, p0, p3, 0.5) && isPointCloseToSegment(p2, p0, p3, 0.5) {
if isPointCloseToSegment(x1, y1, x0, y0, x3, y3, 0.5) && isPointCloseToSegment(x2, y2, x0, y0, x3, y3, 0.5) { p.LineTo(p3.x, p3.y)
p.LineTo(x3, y3)
return return
} }
x01 := (x0 + x1) / 2 p01 := point{
y01 := (y0 + y1) / 2 x: (p0.x + p1.x) / 2,
x12 := (x1 + x2) / 2 y: (p0.y + p1.y) / 2,
y12 := (y1 + y2) / 2 }
x23 := (x2 + x3) / 2 p12 := point{
y23 := (y2 + y3) / 2 x: (p1.x + p2.x) / 2,
x012 := (x01 + x12) / 2 y: (p1.y + p2.y) / 2,
y012 := (y01 + y12) / 2 }
x123 := (x12 + x23) / 2 p23 := point{
y123 := (y12 + y23) / 2 x: (p2.x + p3.x) / 2,
x0123 := (x012 + x123) / 2 y: (p2.y + p3.y) / 2,
y0123 := (y012 + y123) / 2 }
p.cubicTo(x01, y01, x012, y012, x0123, y0123, level+1) p012 := point{
p.cubicTo(x123, y123, x23, y23, x3, y3, level+1) x: (p01.x + p12.x) / 2,
y: (p01.y + p12.y) / 2,
}
p123 := point{
x: (p12.x + p23.x) / 2,
y: (p12.y + p23.y) / 2,
}
p0123 := point{
x: (p012.x + p123.x) / 2,
y: (p012.y + p123.y) / 2,
}
p.cubicTo(p01, p012, p0123, level+1)
p.cubicTo(p123, p23, p3, level+1)
} }
func normalize(x, y float32) (float32, float32) { func normalize(p point) point {
len := float32(math.Hypot(float64(x), float64(y))) len := float32(math.Hypot(float64(p.x), float64(p.y)))
return x / len, y / len return point{x: p.x / len, y: p.y / len}
} }
func cross(x0, y0, x1, y1 float32) float32 { func cross(p0, p1 point) float32 {
return x0*y1 - x1*y0 return p0.x*p1.y - p1.x*p0.y
} }
// ArcTo adds an arc curve to the path. (x1, y1) is the control point, and (x2, y2) is the destination. // ArcTo adds an arc curve to the path. (x1, y1) is the control point, and (x2, y2) is the destination.
// //
// ArcTo updates the current position to (x2, y2). // ArcTo updates the current position to (x2, y2).
func (p *Path) ArcTo(x1, y1, x2, y2, radius float32) { func (p *Path) ArcTo(x1, y1, x2, y2, radius float32) {
x0 := p.cur.x d0 := point{
y0 := p.cur.y x: p.cur.x - x1,
dx0 := x0 - x1 y: p.cur.y - y1,
dy0 := y0 - y1 }
dx1 := x2 - x1 d1 := point{
dy1 := y2 - y1 x: x2 - x1,
dx0, dy0 = normalize(dx0, dy0) y: y2 - y1,
dx1, dy1 = normalize(dx1, dy1) }
d0 = normalize(d0)
d1 = normalize(d1)
// theta is the angle between two vectors (dx0, dy0) and (dx1, dy1). // theta is the angle between two vectors d0 and d1.
theta := math.Acos(float64(dx0*dx1 + dy0*dy1)) theta := math.Acos(float64(d0.x*d1.x + d0.y*d1.y))
// TODO: When theta is bigger than π/2, the arc should be split into two. // TODO: When theta is bigger than π/2, the arc should be split into two.
// dist is the distance between the control point and the arc's begenning and ending points. // dist is the distance between the control point and the arc's begenning and ending points.
@ -191,22 +209,22 @@ func (p *Path) ArcTo(x1, y1, x2, y2, radius float32) {
// TODO: What if dist is too big? // TODO: What if dist is too big?
// (ax0, ay0) is the start of the arc. // (ax0, ay0) is the start of the arc.
ax0 := x1 + dx0*dist ax0 := x1 + d0.x*dist
ay0 := y1 + dy0*dist ay0 := y1 + d0.y*dist
var cx, cy, a0, a1 float32 var cx, cy, a0, a1 float32
var dir Direction var dir Direction
if cross(dx0, dy0, dx1, dy1) >= 0 { if cross(d0, d1) >= 0 {
cx = ax0 - dy0*radius cx = ax0 - d0.y*radius
cy = ay0 + dx0*radius cy = ay0 + d0.x*radius
a0 = float32(math.Atan2(float64(-dx0), float64(dy0))) a0 = float32(math.Atan2(float64(-d0.x), float64(d0.y)))
a1 = float32(math.Atan2(float64(dx1), float64(-dy1))) a1 = float32(math.Atan2(float64(d1.x), float64(-d1.y)))
dir = CounterClockwise dir = CounterClockwise
} else { } else {
cx = ax0 + dy0*radius cx = ax0 + d0.y*radius
cy = ay0 - dx0*radius cy = ay0 - d0.x*radius
a0 = float32(math.Atan2(float64(dx0), float64(-dy0))) a0 = float32(math.Atan2(float64(d0.x), float64(-d0.y)))
a1 = float32(math.Atan2(float64(-dx1), float64(dy1))) a1 = float32(math.Atan2(float64(-d1.x), float64(d1.y)))
dir = Clockwise dir = Clockwise
} }
p.Arc(cx, cy, radius, a0, a1, dir) p.Arc(cx, cy, radius, a0, a1, dir)