134 lines
2.9 KiB
Go
134 lines
2.9 KiB
Go
package govector
|
|
|
|
import (
|
|
"math"
|
|
)
|
|
|
|
type Rect2d struct {
|
|
A Point2d `json:A`
|
|
B Point2d `json:B`
|
|
}
|
|
|
|
type Vector2d struct {
|
|
X float64 `json:"x"`
|
|
Y float64 `json:"y"`
|
|
}
|
|
|
|
type Point2d struct {
|
|
X float64 `json:"x"`
|
|
Y float64 `json:"y"`
|
|
}
|
|
|
|
const Epsilon = 1e-7
|
|
const Rad2deg = 180 / math.Pi
|
|
const Deg2rad = math.Pi / 180
|
|
|
|
func (p1 Point2d) Sub(p2 Point2d) Vector2d {
|
|
return Vector2d{p1.X - p2.X, p1.Y - p2.Y}
|
|
}
|
|
|
|
func (p Point2d) Add(v Vector2d) Point2d {
|
|
return Point2d{p.X + v.X, p.Y + v.Y}
|
|
}
|
|
|
|
func (v Vector2d) Mag() float64 {
|
|
return math.Abs(math.Sqrt(v.X*v.X + v.Y*v.Y))
|
|
}
|
|
|
|
func (v Vector2d) PopPop() float64 {
|
|
return v.Mag()
|
|
}
|
|
|
|
func (v Vector2d) Scale(s float64) Vector2d {
|
|
return Vector2d{v.X * s, v.Y * s}
|
|
}
|
|
|
|
func (v1 Vector2d) Cross(v2 Vector2d) float64 {
|
|
return v1.X*v2.Y - v1.Y*v2.X
|
|
}
|
|
|
|
func (v1 Vector2d) Dot(v2 Vector2d) float64 {
|
|
return (v1.X * v2.X) + (v1.Y * v2.Y)
|
|
}
|
|
|
|
func (v1 Vector2d) Rotate(a float64) Vector2d {
|
|
x := v1.X*math.Cos(a) - v1.Y*math.Sin(a)
|
|
y := v1.X*math.Sin(a) + v1.Y*math.Cos(a)
|
|
return Vector2d{x, y}
|
|
}
|
|
|
|
func Intersection(p1, p2 Point2d, v1, v2 Vector2d) (bool, Point2d) {
|
|
t := p2.Sub(p1).Cross(v2) / v1.Cross(v2)
|
|
s := p2.Sub(p1).Cross(v1) / v1.Cross(v2)
|
|
if t >= 0 && t <= 1 && s >= 0 && s <= 1 {
|
|
return true, p1.Add(v1.Scale(t))
|
|
}
|
|
|
|
return false, Point2d{0, 0}
|
|
}
|
|
|
|
func PointInRect(p Point2d, r Rect2d) bool {
|
|
return (p.X > r.A.X) && (p.X < r.B.X) && (p.Y > r.A.Y) && (p.Y < r.B.Y)
|
|
}
|
|
|
|
func RectIntersection(r Rect2d, p Point2d, v Vector2d) (bool, bool, Point2d) {
|
|
collision := false
|
|
inside := false
|
|
start_inside := PointInRect(p, r)
|
|
end_inside := PointInRect(p.Add(v), r)
|
|
if start_inside && end_inside {
|
|
inside = true
|
|
return collision, inside, Point2d{X: 0, Y: 0}
|
|
} else {
|
|
wall_left, col1 := Intersection(p, r.A, v, Vector2d{X: 0, Y: r.B.Y})
|
|
if wall_left {
|
|
return wall_left, inside, col1
|
|
}
|
|
wall_top, col2 := Intersection(p, r.A, v, Vector2d{X: r.B.X, Y: 0})
|
|
if wall_top {
|
|
return wall_top, inside, col2
|
|
}
|
|
wall_right, col3 := Intersection(p, r.B, v, Vector2d{X: 0, Y: -r.B.Y})
|
|
if wall_right {
|
|
return wall_right, inside, col3
|
|
}
|
|
wall_bottom, col4 := Intersection(p, r.B, v, Vector2d{X: -r.B.X, Y: 0})
|
|
if wall_bottom {
|
|
return wall_bottom, inside, col4
|
|
}
|
|
|
|
return false, false, Point2d{X: 0, Y: 0}
|
|
}
|
|
}
|
|
|
|
func (v Vector2d) Normalize() Vector2d {
|
|
if v.X == 0 && v.Y == 0 {
|
|
return v
|
|
}
|
|
|
|
m := v.Mag()
|
|
return Vector2d{v.X / m, v.Y / m}
|
|
}
|
|
|
|
func Move(d1, d2 Point2d, velocity float64, timeDelta float64) Point2d {
|
|
v := d2.Sub(d1)
|
|
v_norm := v.Normalize()
|
|
v_scaled := v_norm.Scale(velocity * timeDelta)
|
|
return d1.Add(v_scaled)
|
|
}
|
|
|
|
func Distance(p1, p2 Point2d) float64 {
|
|
return p1.Sub(p2).Mag()
|
|
}
|
|
|
|
func Angle(v1, v2 Vector2d) float64 {
|
|
x := (v1.Dot(v2) / (v1.Mag() * v2.Mag()))
|
|
angle := math.Acos(x)
|
|
// Determine the sign to see what direction
|
|
// the angle should go in
|
|
if v1.Y*v2.X > v1.X*v2.Y {
|
|
angle = angle * -1.0
|
|
}
|
|
return angle
|
|
}
|