99 lines
3.3 KiB
Swift
99 lines
3.3 KiB
Swift
import Foundation
|
|
#if USE_SIMD
|
|
import simd
|
|
#endif
|
|
|
|
|
|
#if USE_SIMD
|
|
public typealias Vector2 = SIMD2
|
|
#else
|
|
|
|
public struct Vector2<T: FloatingPoint>: Equatable
|
|
{
|
|
public typealias Scalar = T
|
|
|
|
public var x, y: T
|
|
|
|
public init() { self.x = 0; self.y = 0 }
|
|
public init(_ x: T, _ y: T) { self.x = x; self.y = y }
|
|
}
|
|
|
|
public extension Vector2
|
|
{
|
|
// constants
|
|
@inline(__always) static var zero: Self { Self(0, 0) }
|
|
@inline(__always) static var one: Self { Self(1, 1) }
|
|
|
|
subscript(index: Int) -> T
|
|
{
|
|
get
|
|
{
|
|
switch index
|
|
{
|
|
case 0: x
|
|
case 1: y
|
|
default: fatalError()
|
|
}
|
|
}
|
|
}
|
|
|
|
// relational
|
|
@inline(__always) static func == (lhs: Self, rhs: Self) -> Bool { lhs.x == rhs.x && lhs.y == rhs.y }
|
|
@inline(__always) static func != (lhs: Self, rhs: Self) -> Bool { rhs.x != rhs.x || lhs.y != rhs.y }
|
|
|
|
// arithmetic
|
|
@inline(__always) static func + (lhs: Self, rhs: Self) -> Self { Self(lhs.x + rhs.x, lhs.y + rhs.y) }
|
|
@inline(__always) static func - (lhs: Self, rhs: Self) -> Self { Self(lhs.x - rhs.x, lhs.y - rhs.y) }
|
|
@inline(__always) static func * (lhs: Self, rhs: Self) -> Self { Self(lhs.x * rhs.x, lhs.y * rhs.y) }
|
|
@inline(__always) static func / (lhs: Self, rhs: Self) -> Self { Self(lhs.x / rhs.x, lhs.y / rhs.y) }
|
|
|
|
// scalar arithmetic
|
|
@inline(__always) static func * (lhs: Self, rhs: T) -> Self { Self(lhs.x * rhs, lhs.y * rhs) }
|
|
@inline(__always) static func / (lhs: Self, rhs: T) -> Self { Self(lhs.x / rhs, lhs.y / rhs) }
|
|
@inline(__always) static func * (lhs: T, rhs: Self) -> Self { Self(lhs * rhs.x, lhs * rhs.y) }
|
|
@inline(__always) static func / (lhs: T, rhs: Self) -> Self { Self(lhs / rhs.x, lhs / rhs.y) }
|
|
|
|
// compound arithmetic
|
|
@inline(__always) static func += (lhs: inout Self, rhs: Self) { lhs.x += rhs.x; lhs.y += rhs.y }
|
|
@inline(__always) static func -= (lhs: inout Self, rhs: Self) { lhs.x -= rhs.x; lhs.y -= rhs.y }
|
|
@inline(__always) static func *= (lhs: inout Self, rhs: Self) { lhs.x *= rhs.x; lhs.y *= rhs.y }
|
|
@inline(__always) static func /= (lhs: inout Self, rhs: Self) { lhs.x /= rhs.x; lhs.y /= rhs.y }
|
|
|
|
// compound scalar arithmetic
|
|
@inline(__always) static func *= (lhs: inout Self, rhs: T) { lhs.x *= rhs; lhs.y *= rhs }
|
|
@inline(__always) static func /= (lhs: inout Self, rhs: T) { lhs.x /= rhs; lhs.y /= rhs }
|
|
|
|
// unary
|
|
@inline(__always) static prefix func + (vec: Self) -> Self { vec }
|
|
@inline(__always) static prefix func - (vec: Self) -> Self { Self(-vec.x, -vec.y) }
|
|
}
|
|
|
|
#endif
|
|
|
|
public extension Vector2 where Scalar: FloatingPoint
|
|
{
|
|
@inline(__always) var len2: Scalar { x * x + y * y }
|
|
@inline(__always) var len: Scalar { len2.squareRoot() }
|
|
@inline(__always) var normalised: Self { let invLen = 1 / len; return self * invLen }
|
|
|
|
@inline(__always) mutating func normalise() { let invLen = 1 / len; self *= invLen }
|
|
|
|
@inline(__always) func dot(_ b: Self) -> Scalar { x * b.x + y * b.y }
|
|
@inline(__always) func reflect(_ n: Self) -> Self { self - (n * 2 * self.dot(n)) }
|
|
@inline(__always) func project(_ n: Self) -> Self { n * self.dot(n) }
|
|
|
|
@inline(__always) func cross(_ b: Self) -> Scalar { x * b.y - y * b.x }
|
|
|
|
@inline(__always) func lerp(_ b: Self, _ x: Scalar) -> Self
|
|
{
|
|
let invX = 1 - x
|
|
return Self(self.x * invX + b.x * x, self.y * invX + b.y * x)
|
|
}
|
|
|
|
@inline(__always) func distance(_ b: Self) -> Scalar { return (b - self).len }
|
|
}
|
|
|
|
|
|
public typealias Vec2f = Vector2<Float>
|
|
public typealias Vec2d = Vector2<Double>
|