vector.go

package glm

import (
	"fmt"

	"github.com/EngoEngine/math"
)

// Vec2 is the representation of a vector with 2 components.
type Vec2 [2]float32

// Vec3 is the representation of a vector with 3 components.
type Vec3 [3]float32

// Vec4 is the representation of a vector with 4 components.
type Vec4 [4]float32

// String returns a pretty string for this vector. eg.
// {-1.00000, 0.00000}
func (v1 *Vec2) String() string {
	ret := "{"
	for n := 0; n < len(v1); n++ {
		if v1[n] >= 0 {
			ret += " "
		}
		ret += fmt.Sprintf("%.6f", v1[n])
		if n < len(v1)-1 {
			ret += ", "
		}
	}
	return ret + "}"
}

// String returns a pretty string for this vector. eg.
// {-1.00000, 0.00000, 0.00000}
func (v1 *Vec3) String() string {
	ret := "{"
	for n := 0; n < len(v1); n++ {
		if v1[n] >= 0 {
			ret += " "
		}
		ret += fmt.Sprintf("%.6f", v1[n])
		if n < len(v1)-1 {
			ret += ", "
		}
	}
	return ret + "}"
}

// String returns a pretty string for this vector. eg.
// {-1.00000, 0.00000, 0.00000, 0.00000}
func (v1 *Vec4) String() string {
	ret := "{"
	for n := 0; n < len(v1); n++ {
		if v1[n] >= 0 {
			ret += " "
		}
		ret += fmt.Sprintf("%.6f", v1[n])
		if n < len(v1)-1 {
			ret += ", "
		}
	}
	return ret + "}"
}

// Vec3 return a Vec3 from this Vec2 with {z}. Similar to GLSL
//    vec3(v2, z);
func (v1 *Vec2) Vec3(z float32) Vec3 {
	return Vec3{v1[0], v1[1], z}
}

// Vec4 return a Vec4 from this Vec2 with {z,w}. Similar to GLSL
//    vec4(v2, z, w);
func (v1 *Vec2) Vec4(z, w float32) Vec4 {
	return Vec4{v1[0], v1[1], z, w}
}

// Vec2 return a Vec2 from the first 2 components of this Vec3. Similar to GLSL
//    vec2(v3);
func (v1 *Vec3) Vec2() Vec2 {
	return Vec2{v1[0], v1[1]}
}

// Vec4 return a Vec4 from this Vec3 with {w}. Similar to GLSL
//    vec4(v3, w);
func (v1 *Vec3) Vec4(w float32) Vec4 {
	return Vec4{v1[0], v1[1], v1[2], w}
}

// Vec2 return a Vec2 from the first 2 components of this Vec4. Similar to GLSL
//    vec2(v4);
func (v1 *Vec4) Vec2() Vec2 {
	return Vec2{v1[0], v1[1]}
}

// Vec3 return a Vec3 from the first 3 components of this Vec4. Similar to GLSL
//    vec3(v4);
func (v1 *Vec4) Vec3() Vec3 {
	return Vec3{v1[0], v1[1], v1[2]}
}

// Elem extracts the elements of the vector for direct value assignment.
func (v1 Vec2) Elem() (x, y float32) {
	return v1[0], v1[1]
}

// Elem extracts the elements of the vector for direct value assignment.
func (v1 Vec3) Elem() (x, y, z float32) {
	return v1[0], v1[1], v1[2]
}

// Elem extracts the elements of the vector for direct value assignment.
func (v1 Vec4) Elem() (x, y, z, w float32) {
	return v1[0], v1[1], v1[2], v1[3]
}

// Perp returns the vector perpendicular to v1
func (v1 *Vec2) Perp() Vec2 {
	return Vec2{-v1[1], v1[0]}
}

// SetPerp sets this vector to its perpendicular
func (v1 *Vec2) SetPerp() {
	v1[0], v1[1] = -v1[1], v1[0]
}

// Cross computes the pseudo 2D cross product, Dot(Perp(u), v)
func (v1 *Vec2) Cross(v2 *Vec2) float32 {
	return v1[0]*v2[1] - v1[1]*v2[0]
}

// Cross is an operation only defined on 3D vectors, commonly referred to as
// "the cross product". It is equivalent to
// Vec3{v1[1]*v2[2]-v1[2]*v2[1], v1[2]*v2[0]-v1[0]*v2[2], v1[0]*v2[1] - v1[1]*v2[0]}.
// Another interpretation is that it's the vector whose magnitude is
// |v1||v2|sin(theta) where theta is the angle between v1 and v2.
//
// The cross product is most often used for finding surface normals. The cross
// product of vectors will generate a vector that is perpendicular to the plane
// they form.
//
// Technically, a generalized cross product exists as an "(N-1)ary" operation
// (that is, the 4D cross product requires 3 4D vectors). But the binary
// 3D (and 7D) cross product is the most important. It can be considered
// the area of a parallelogram with sides v1 and v2.
//
// Like the dot product, the cross product is roughly a measure of
// directionality. Two normalized perpendicular vectors will return a vector
// with a magnitude of 1.0 or -1.0 and two parallel vectors will return a vector
// with magnitude 0.0. The cross product is "anticommutative" meaning
// v1.Cross(v2) = -v2.Cross(v1), this property can be useful to know when
// finding normals, as taking the wrong cross product can lead to the opposite
// normal of the one you want.
//
// https://en.wikipedia.org/wiki/Cross_product
func (v1 *Vec3) Cross(v2 *Vec3) Vec3 {
	return Vec3{v1[1]*v2[2] - v1[2]*v2[1], v1[2]*v2[0] - v1[0]*v2[2], v1[0]*v2[1] - v1[1]*v2[0]}
}

// CrossOf is the same as Cross but with destination vector. v1 = v2 X v3.
func (v1 *Vec3) CrossOf(v2, v3 *Vec3) {
	v1[0] = v2[1]*v3[2] - v2[2]*v3[1]
	v1[1] = v2[2]*v3[0] - v2[0]*v3[2]
	v1[2] = v2[0]*v3[1] - v2[1]*v3[0]
}

// CrossWith is the same as cross except it stores the result in v1.
func (v1 *Vec3) CrossWith(v2 *Vec3) {
	vx, vy, vz := v1[0], v1[1], v1[2]
	v1[0] = vy*v2[2] - vz*v2[1]
	v1[1] = vz*v2[0] - vx*v2[2]
	v1[2] = vx*v2[1] - vy*v2[0]
}

// ScalarTripleProduct returns Dot(v1, Cross(v2,v3)), its also called the box or
// mixed product.
//
// https://en.wikipedia.org/wiki/Triple_product
func ScalarTripleProduct(v0, v1, v2 *Vec3) float32 {
	return v0[0]*(v1[1]*v2[2]-v1[2]*v2[1]) +
		v0[1]*(v1[2]*v2[0]-v1[0]*v2[2]) +
		v0[2]*(v1[0]*v2[1]-v1[1]*v2[0])
}

// Add is equivalent to v3 := v1+v2
func (v1 *Vec2) Add(v2 *Vec2) Vec2 {
	return Vec2{v1[0] + v2[0], v1[1] + v2[1]}
}

// AddOf is equivalent to v1 = v2+v3
func (v1 *Vec2) AddOf(v2, v3 *Vec2) {
	v1[0], v1[1] = v2[0]+v3[0], v2[1]+v3[1]
}

// AddWith is equivalent to v1+=v2
func (v1 *Vec2) AddWith(v2 *Vec2) {
	v1[0] += v2[0]
	v1[1] += v2[1]
}

// AddScaledVec is a shortcut for v1 += c*v2
func (v1 *Vec2) AddScaledVec(c float32, v2 *Vec2) {
	v1[0] += c * v2[0]
	v1[1] += c * v2[1]
}

// Sub is equivalent to v3 := v1-v2
func (v1 *Vec2) Sub(v2 *Vec2) Vec2 {
	return Vec2{v1[0] - v2[0], v1[1] - v2[1]}
}

// SubOf is equivalent to v1 = v2-v3
func (v1 *Vec2) SubOf(v2, v3 *Vec2) {
	v1[0], v1[1] = v2[0]-v3[0], v2[1]-v3[1]
}

// SubWith is equivalent to v1-=v2
func (v1 *Vec2) SubWith(v2 *Vec2) {
	v1[0] -= v2[0]
	v1[1] -= v2[1]
}

// Mul is equivalent to v3 := c*v1
func (v1 *Vec2) Mul(c float32) Vec2 {
	return Vec2{v1[0] * c, v1[1] * c}
}

// MulOf is equivalent to v1 = c*v2
func (v1 *Vec2) MulOf(c float32, v2 *Vec2) {
	v1[0], v1[1] = c*v2[0], c*v2[1]
}

// MulWith is equivalent to v1*=c
func (v1 *Vec2) MulWith(c float32) {
	v1[0] *= c
	v1[1] *= c
}

// ComponentProduct returns {v1[0]*v2[0],v1[1]*v2[1], ... v1[n]*v2[n]}. It's
// equivalent to v3 := v1 * v2
func (v1 *Vec2) ComponentProduct(v2 *Vec2) Vec2 {
	return Vec2{v1[0] * v2[0], v1[1] * v2[1]}
}

// ComponentProductOf is equivalent to v1 = v2*v3
func (v1 *Vec2) ComponentProductOf(v2, v3 *Vec2) {
	v1[0] = v2[0] * v3[0]
	v1[1] = v2[1] * v3[1]
}

// ComponentProductWith is equivalent to v1 = v1*v2
func (v1 *Vec2) ComponentProductWith(v2 *Vec2) {
	v1[0] = v1[0] * v2[0]
	v1[1] = v1[1] * v2[1]
}

// Dot returns the dot product of this vector with another. There are multiple
// ways to describe this value. One is the multiplication of their lengths and
// cos(theta) where theta is the angle between the vectors:
// v1.v2 = |v1||v2|cos(theta).
//
// The other (and what is actually done) is the sum of the element-wise
// multiplication of all elements. So for instance, two Vec3s would yield
// v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2].
//
// This means that the dot product of a vector and itself is the square of its
// Len (within the bounds of floating points error).
//
// The dot product is roughly a measure of how closely two vectors are to
// pointing in the same direction. If both vectors are normalized, the value
// will be -1 for opposite pointing, one for same pointing, and 0 for
// perpendicular vectors.
func (v1 *Vec2) Dot(v2 *Vec2) float32 {
	return v1[0]*v2[0] + v1[1]*v2[1]
}

// Len returns the vector's length. Note that this is NOT the dimension of
// the vector (len(v)), but the mathematical length. This is equivalent to the
// square root of the sum of the squares of all elements. E.G. for a Vec2 it's
// math.Hypot(v[0], v[1]).
func (v1 *Vec2) Len() float32 {
	return math.Hypot(v1[0], v1[1])
}

// Len2 returns the square of the length, this function is used when optimising
// out the sqrt operation.
func (v1 *Vec2) Len2() float32 {
	return v1[0]*v1[0] + v1[1]*v1[1]
}

// Invert changes the sign of every component of this vector.
func (v1 *Vec2) Invert() {
	v1[0] = -v1[0]
	v1[1] = -v1[1]
}

// Inverse return a new vector with invert sign for every component
func (v1 *Vec2) Inverse() Vec2 {
	return Vec2{-v1[0], -v1[1]}
}

// Zero sets this vector to all zero components.
func (v1 *Vec2) Zero() {
	v1[0], v1[1] = 0, 0
}

// Normalized normalizes the vector. Normalization is (1/|v|)*v,
// making this equivalent to v.Scale(1/v.Len()). If the len is 0.0,
// this function will return an infinite value for all elements due
// to how floating point division works in Go (n/0.0 = math.Inf(Sign(n))).
//
// Normalization makes a vector's Len become 1.0 (within the margin of floating
// point error),
// while maintaining its directionality.
//
// (Can be seen here: http://play.golang.org/p/Aaj7SnbqIp )
func (v1 *Vec2) Normalized() Vec2 {
	l := 1.0 / v1.Len()
	return Vec2{v1[0] * l, v1[1] * l}
}

// Normalize is the same as Normalize but doesn't return a new vector.
func (v1 *Vec2) Normalize() {
	l := 1.0 / v1.Len()
	v1[0] *= l
	v1[1] *= l
}

// NormalizeVec2 normalizes given vector. shortcut for when you don't want to
// use pointers.
func NormalizeVec2(v Vec2) Vec2 {
	l := 1.0 / v.Len()
	v[0] *= l
	v[1] *= l
	return v
}

// Equal takes in a vector and does an element-wise
// approximate float comparison as if FloatEqual had been used
func (v1 *Vec2) Equal(v2 *Vec2) bool {
	return FloatEqual(v1[0], v2[0]) && FloatEqual(v1[1], v2[1])
}

// EqualThreshold takes in a threshold for comparing two floats, and uses
// it to do an element-wise comparison of the vector to another.
func (v1 *Vec2) EqualThreshold(v2 *Vec2, threshold float32) bool {
	return FloatEqualThreshold(v1[0], v2[0], threshold) && FloatEqualThreshold(v1[1], v2[1], threshold)
}

// X is an element access func, it is equivalent to v[n] where
// n is some valid index. The mappings are XYZW (X=0, Y=1 etc). Benchmarks
// show that this is more or less as fast as direct acces, probably due to
// inlining, so use v[0] or v.X() depending on personal preference.
func (v1 Vec2) X() float32 {
	return v1[0]
}

// Y is an element access func, it is equivalent to v[n] where
// n is some valid index. The mappings are XYZW (X=0, Y=1 etc). Benchmarks
// show that this is more or less as fast as direct acces, probably due to
// inlining, so use v[0] or v.X() depending on personal preference.
func (v1 Vec2) Y() float32 {
	return v1[1]
}

// OuterProd2 does the vector outer product
// of two vectors. The outer product produces an
// 2x2 matrix. E.G. a Vec2 * Vec2 = Mat2.
//
// The outer product can be thought of as the "opposite"
// of the Dot product. The Dot product treats both vectors like matrices
// oriented such that the left one has N columns and the right has N rows.
// So Vec3.Vec3 = Mat1x3*Mat3x1 = Mat1 = Scalar.
//
// The outer product orients it so they're facing "outward": Vec2*Vec3
// = Mat2x1*Mat1x3 = Mat2x3.
func (v1 *Vec2) OuterProd2(v2 *Vec2) Mat2 {
	return Mat2{v1[0] * v2[0], v1[1] * v2[0], v1[0] * v2[1], v1[1] * v2[1]}
}

// Add is equivalent to v3 := v1+v2
func (v1 *Vec3) Add(v2 *Vec3) Vec3 {
	return Vec3{v1[0] + v2[0], v1[1] + v2[1], v1[2] + v2[2]}
}

// AddOf is equivalent to v1 = v2+v3
func (v1 *Vec3) AddOf(v2, v3 *Vec3) {
	v1[0] = v2[0] + v3[0]
	v1[1] = v2[1] + v3[1]
	v1[2] = v2[2] + v3[2]

}

// AddWith is equivalent to v1+=v2
func (v1 *Vec3) AddWith(v2 *Vec3) {
	v1[0] += v2[0]
	v1[1] += v2[1]
	v1[2] += v2[2]
}

// AddScaledVec is a shortcut for v1 += c*v2
func (v1 *Vec3) AddScaledVec(c float32, v2 *Vec3) {
	v1[0] += c * v2[0]
	v1[1] += c * v2[1]
	v1[2] += c * v2[2]
}

// Sub is equivalent to v3 := v1-v2
func (v1 *Vec3) Sub(v2 *Vec3) Vec3 {
	return Vec3{v1[0] - v2[0], v1[1] - v2[1], v1[2] - v2[2]}
}

// SubOf is equivalent to v1 = v2-v3
func (v1 *Vec3) SubOf(v2, v3 *Vec3) {
	v1[0], v1[1], v1[2] = v2[0]-v3[0], v2[1]-v3[1], v2[2]-v3[2]
}

// SubWith is equivalent to v1-=v2
func (v1 *Vec3) SubWith(v2 *Vec3) {
	v1[0] -= v2[0]
	v1[1] -= v2[1]
	v1[2] -= v2[2]
}

// Mul is equivalent to v3 := c*v1
func (v1 *Vec3) Mul(c float32) Vec3 {
	return Vec3{v1[0] * c, v1[1] * c, v1[2] * c}
}

// MulOf is equivalent to v1 = c*v2
func (v1 *Vec3) MulOf(c float32, v2 *Vec3) {
	v1[0] = c * v2[0]
	v1[1] = c * v2[1]
	v1[2] = c * v2[2]
}

// MulWith is equivalent to v1*=c
func (v1 *Vec3) MulWith(c float32) {
	v1[0] *= c
	v1[1] *= c
	v1[2] *= c
}

// ComponentProduct returns {v1[0]*v2[0],v1[1]*v2[1], ... v1[n]*v2[n]}. It's
// equivalent to v3 := v1 * v2
func (v1 *Vec3) ComponentProduct(v2 *Vec3) Vec3 {
	return Vec3{v1[0] * v2[0], v1[1] * v2[1], v1[2] * v2[2]}
}

// ComponentProductOf is equivalent to v1 = v2*v3
func (v1 *Vec3) ComponentProductOf(v2, v3 *Vec3) {
	v1[0] = v2[0] * v3[0]
	v1[1] = v2[1] * v3[1]
	v1[2] = v2[2] * v3[2]
}

// ComponentProductWith is equivalent to v1 = v1*v2
func (v1 *Vec3) ComponentProductWith(v2 *Vec3) {
	v1[0] = v1[0] * v2[0]
	v1[1] = v1[1] * v2[1]
	v1[2] = v1[2] * v2[2]
}

// Dot returns the dot product of this vector with another. There are multiple
// ways to describe this value. One is the multiplication of their lengths and
// cos(theta) where theta is the angle between the vectors: v1.v2 = |v1||v2|cos(theta).
//
// The other (and what is actually done) is the sum of the element-wise
// multiplication of all elements. So for instance, two Vec3s would yield
// v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2].
//
// This means that the dot product of a vector and itself is the square of its
// Len (within the bounds of floating points error).
//
// The dot product is roughly a measure of how closely two vectors are to
// pointing in the same direction. If both vectors are normalized, the value
// will be -1 for opposite pointing, one for same pointing, and 0 for
// perpendicular vectors.
func (v1 *Vec3) Dot(v2 *Vec3) float32 {
	return v1[0]*v2[0] + v1[1]*v2[1] + v1[2]*v2[2]
}

// Len returns the vector's length. Note that this is NOT the dimension of
// the vector (len(v)), but the mathematical length. This is equivalent to the
// square root of the sum of the squares of all elements. E.G. for a Vec2 it's
// math.Hypot(v[0], v[1]).
func (v1 *Vec3) Len() float32 {
	return math.Sqrt(v1[0]*v1[0] + v1[1]*v1[1] + v1[2]*v1[2])
}

// Len2 returns the square of the length, this function is used when optimising
// out the sqrt operation.
func (v1 *Vec3) Len2() float32 {
	return v1[0]*v1[0] + v1[1]*v1[1] + v1[2]*v1[2]
}

// Invert changes the sign of every component of this vector.
func (v1 *Vec3) Invert() {
	v1[0] = -v1[0]
	v1[1] = -v1[1]
	v1[2] = -v1[2]
}

// Inverse return a new vector with invert sign for every component
func (v1 *Vec3) Inverse() Vec3 {
	return Vec3{-v1[0], -v1[1], -v1[2]}
}

// Zero sets this vector to all zero components.
func (v1 *Vec3) Zero() {
	v1[0], v1[1], v1[2] = 0, 0, 0
}

// Normalized normalizes the vector. Normalization is (1/|v|)*v,
// making this equivalent to v.Scale(1/v.Len()). If the len is 0.0,
// this function will return an infinite value for all elements due
// to how floating point division works in Go (n/0.0 = math.Inf(Sign(n))).
//
// Normalization makes a vector's Len become 1.0 (within the margin of floating
// point error), while maintaining its directionality.
//
// (Can be seen here: http://play.golang.org/p/Aaj7SnbqIp )
func (v1 *Vec3) Normalized() Vec3 {
	l := 1.0 / v1.Len()
	return Vec3{v1[0] * l, v1[1] * l, v1[2] * l}
}

// Normalize is the same as Normalize but doesn't return a new vector.
func (v1 *Vec3) Normalize() {
	l := 1.0 / v1.Len()
	v1[0] *= l
	v1[1] *= l
	v1[2] *= l
}

// NormalizeVec3 normalizes given vector. shortcut for when you don't want to
// use pointers.
func NormalizeVec3(v Vec3) Vec3 {
	l := 1.0 / v.Len()
	v[0] *= l
	v[1] *= l
	v[2] *= l
	return v
}

// Equal takes in a vector and does an element-wise
// approximate float comparison as if FloatEqual had been used
func (v1 *Vec3) Equal(v2 *Vec3) bool {
	return FloatEqual(v1[0], v2[0]) && FloatEqual(v1[1], v2[1]) && FloatEqual(v1[2], v2[2])
}

// EqualThreshold takes in a threshold for comparing two floats, and uses
// it to do an element-wise comparison of the vector to another.
func (v1 *Vec3) EqualThreshold(v2 *Vec3, threshold float32) bool {
	return FloatEqualThreshold(v1[0], v2[0], threshold) && FloatEqualThreshold(v1[1], v2[1], threshold) && FloatEqualThreshold(v1[2], v2[2], threshold)
}

// X is an element access func, it is equivalent to v[n] where
// n is some valid index. The mappings are XYZW (X=0, Y=1 etc). Benchmarks
// show that this is more or less as fast as direct acces, probably due to
// inlining, so use v[0] or v.X() depending on personal preference.
func (v1 Vec3) X() float32 {
	return v1[0]
}

// Y is an element access func, it is equivalent to v[n] where
// n is some valid index. The mappings are XYZW (X=0, Y=1 etc). Benchmarks
// show that this is more or less as fast as direct acces, probably due to
// inlining, so use v[0] or v.X() depending on personal preference.
func (v1 Vec3) Y() float32 {
	return v1[1]
}

// Z is an element access func, it is equivalent to v[n] where
// n is some valid index. The mappings are XYZW (X=0, Y=1 etc). Benchmarks
// show that this is more or less as fast as direct acces, probably due to
// inlining, so use v[0] or v.X() depending on personal preference.
func (v1 Vec3) Z() float32 {
	return v1[2]
}

// OuterProd3 does the vector outer product
// of two vectors. The outer product produces an
// 3x3 matrix. E.G. a Vec3 * Vec3 = Mat3.
//
// The outer product can be thought of as the "opposite"
// of the Dot product. The Dot product treats both vectors like matrices
// oriented such that the left one has N columns and the right has N rows.
// So Vec3.Vec3 = Mat1x3*Mat3x1 = Mat1 = Scalar.
//
// The outer product orients it so they're facing "outward": Vec2*Vec3
// = Mat2x1*Mat1x3 = Mat2x3.
func (v1 *Vec3) OuterProd3(v2 *Vec3) Mat3 {
	return Mat3{v1[0] * v2[0], v1[1] * v2[0], v1[2] * v2[0], v1[0] * v2[1], v1[1] * v2[1], v1[2] * v2[1], v1[0] * v2[2], v1[1] * v2[2], v1[2] * v2[2]}
}

// Add is equivalent to v3 := v1+v2
func (v1 *Vec4) Add(v2 *Vec4) Vec4 {
	return Vec4{v1[0] + v2[0], v1[1] + v2[1], v1[2] + v2[2], v1[3] + v2[3]}
}

// AddOf is equivalent to v1 = v2+v3
func (v1 *Vec4) AddOf(v2, v3 *Vec4) {
	v1[0] = v2[0] + v3[0]
	v1[1] = v2[1] + v3[1]
	v1[2] = v2[2] + v3[2]
	v1[3] = v2[3] + v3[3]
}

// AddWith is equivalent to v1+=v2
func (v1 *Vec4) AddWith(v2 *Vec4) {
	v1[0] += v2[0]
	v1[1] += v2[1]
	v1[2] += v2[2]
	v1[3] += v2[3]
}

// AddScaledVec is a shortcut for v1 += c*v2
func (v1 *Vec4) AddScaledVec(c float32, v2 *Vec4) {
	v1[0] += c * v2[0]
	v1[1] += c * v2[1]
	v1[2] += c * v2[2]
	v1[3] += c * v2[3]
}

// Sub is equivalent to v3 := v1-v2
func (v1 *Vec4) Sub(v2 *Vec4) Vec4 {
	return Vec4{v1[0] - v2[0], v1[1] - v2[1], v1[2] - v2[2], v1[3] - v2[3]}
}

// SubOf is equivalent to v1 = v2-v3
func (v1 *Vec4) SubOf(v2, v3 *Vec4) {
	v1[0], v1[1], v1[2], v1[3] = v2[0]-v3[0], v2[1]-v3[1], v2[2]-v3[2], v2[3]-v3[3]
}

// SubWith is equivalent to v1-=v2
func (v1 *Vec4) SubWith(v2 *Vec4) {
	v1[0] -= v2[0]
	v1[1] -= v2[1]
	v1[2] -= v2[2]
	v1[3] -= v2[3]
}

// Mul is equivalent to v3 := c*v1
func (v1 *Vec4) Mul(c float32) Vec4 {
	return Vec4{v1[0] * c, v1[1] * c, v1[2] * c, v1[3] * c}
}

// MulOf is equivalent to v1 = c*v2
func (v1 *Vec4) MulOf(c float32, v2 *Vec4) {
	v1[0], v1[1], v1[2], v1[3] = c*v2[0], c*v2[1], c*v2[2], c*v2[3]
}

// MulWith is equivalent to v1*=c
func (v1 *Vec4) MulWith(c float32) {
	v1[0] *= c
	v1[1] *= c
	v1[2] *= c
	v1[3] *= c
}

// ComponentProduct returns {v1[0]*v2[0],v1[1]*v2[1], ... v1[n]*v2[n]}. It's
// equivalent to v3 := v1 * v2
func (v1 *Vec4) ComponentProduct(v2 *Vec4) Vec4 {
	return Vec4{v1[0] * v2[0], v1[1] * v2[1], v1[2] * v2[2], v1[3] * v2[3]}
}

// ComponentProductOf is equivalent to v1 = v2*v3
func (v1 *Vec4) ComponentProductOf(v2, v3 *Vec4) {
	v1[0] = v2[0] * v3[0]
	v1[1] = v2[1] * v3[1]
	v1[2] = v2[2] * v3[2]
	v1[3] = v2[3] * v3[3]
}

// ComponentProductWith is equivalent to v1 = v1*v2
func (v1 *Vec4) ComponentProductWith(v2 *Vec4) {
	v1[0] = v1[0] * v2[0]
	v1[1] = v1[1] * v2[1]
	v1[2] = v1[2] * v2[2]
	v1[3] = v1[3] * v2[3]
}

// Dot returns the dot product of this vector with another. There are multiple
// ways to describe this value. One is the multiplication of their lengths and
// cos(theta) where theta is the angle between the vectors: v1.v2 = |v1||v2|cos(theta).
//
// The other (and what is actually done) is the sum of the element-wise
// multiplication of all elements. So for instance, two Vec3s would yield
// v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2].
//
// This means that the dot product of a vector and itself is the square of its
// Len (within the bounds of floating points error).
//
// The dot product is roughly a measure of how closely two vectors are to
// pointing in the same direction. If both vectors are normalized, the value
// will be -1 for opposite pointing, one for same pointing, and 0 for
// perpendicular vectors.
func (v1 *Vec4) Dot(v2 *Vec4) float32 {
	return v1[0]*v2[0] + v1[1]*v2[1] + v1[2]*v2[2] + v1[3]*v2[3]
}

// Len returns the vector's length. Note that this is NOT the dimension of
// the vector (len(v)), but the mathematical length. This is equivalent to the
// square root of the sum of the squares of all elements. E.G. for a Vec2 it's
// math.Hypot(v[0], v[1]).
func (v1 *Vec4) Len() float32 {
	return math.Sqrt(v1[0]*v1[0] + v1[1]*v1[1] + v1[2]*v1[2] + v1[3]*v1[3])
}

// Len2 returns the square of the length, this function is used when optimising
// out the sqrt operation.
func (v1 *Vec4) Len2() float32 {
	return v1[0]*v1[0] + v1[1]*v1[1] + v1[2]*v1[2] + v1[3]*v1[3]
}

// Invert changes the sign of every component of this vector.
func (v1 *Vec4) Invert() {
	v1[0] = -v1[0]
	v1[1] = -v1[1]
	v1[2] = -v1[2]
	v1[3] = -v1[3]
}

// Inverse return a new vector with invert sign for every component
func (v1 *Vec4) Inverse() Vec4 {
	return Vec4{-v1[0], -v1[1], -v1[2], -v1[3]}
}

// Zero sets this vector to all zero components.
func (v1 *Vec4) Zero() {
	v1[0], v1[1], v1[2], v1[3] = 0, 0, 0, 0
}

// Normalized normalizes the vector. Normalization is (1/|v|)*v,
// making this equivalent to v.Scale(1/v.Len()). If the len is 0.0,
// this function will return an infinite value for all elements due
// to how floating point division works in Go (n/0.0 = math.Inf(Sign(n))).
//
// Normalization makes a vector's Len become 1.0 (within the margin of floating
// point error), while maintaining its directionality.
//
// (Can be seen here: http://play.golang.org/p/Aaj7SnbqIp )
func (v1 *Vec4) Normalized() Vec4 {
	l := 1.0 / v1.Len()
	return Vec4{v1[0] * l, v1[1] * l, v1[2] * l, v1[3] * l}
}

// Normalize is the same as Normalize but doesn't return a new vector.
func (v1 *Vec4) Normalize() {
	l := 1.0 / v1.Len()
	v1[0] *= l
	v1[1] *= l
	v1[2] *= l
	v1[3] *= l
}

// NormalizeVec4 normalizes given vector. shortcut for when you don't want to
// use pointers.
func NormalizeVec4(v Vec4) Vec4 {
	l := 1.0 / v.Len()
	v[0] *= l
	v[1] *= l
	v[2] *= l
	v[3] *= l
	return v
}

// Equal takes in a vector and does an element-wise
// approximate float comparison as if FloatEqual had been used
func (v1 *Vec4) Equal(v2 *Vec4) bool {
	return FloatEqual(v1[0], v2[0]) && FloatEqual(v1[1], v2[1]) && FloatEqual(v1[2], v2[2]) && FloatEqual(v1[3], v2[3])
}

// EqualThreshold takes in a threshold for comparing two floats, and uses
// it to do an element-wise comparison of the vector to another.
func (v1 *Vec4) EqualThreshold(v2 *Vec4, threshold float32) bool {
	return FloatEqualThreshold(v1[0], v2[0], threshold) && FloatEqualThreshold(v1[1], v2[1], threshold) && FloatEqualThreshold(v1[2], v2[2], threshold) && FloatEqualThreshold(v1[3], v2[3], threshold)
}

// X is an element access func, it is equivalent to v[n] where
// n is some valid index. The mappings are XYZW (X=0, Y=1 etc). Benchmarks
// show that this is more or less as fast as direct acces, probably due to
// inlining, so use v[0] or v.X() depending on personal preference.
func (v1 Vec4) X() float32 {
	return v1[0]
}

// Y is an element access func, it is equivalent to v[n] where
// n is some valid index. The mappings are XYZW (X=0, Y=1 etc). Benchmarks
// show that this is more or less as fast as direct acces, probably due to
// inlining, so use v[0] or v.X() depending on personal preference.
func (v1 Vec4) Y() float32 {
	return v1[1]
}

// Z is an element access func, it is equivalent to v[n] where
// n is some valid index. The mappings are XYZW (X=0, Y=1 etc). Benchmarks
// show that this is more or less as fast as direct acces, probably due to
// inlining, so use v[0] or v.X() depending on personal preference.
func (v1 Vec4) Z() float32 {
	return v1[2]
}

// W is an element access func, it is equivalent to v[n] where
// n is some valid index. The mappings are XYZW (X=0, Y=1 etc). Benchmarks
// show that this is more or less as fast as direct acces, probably due to
// inlining, so use v[0] or v.X() depending on personal preference.
func (v1 Vec4) W() float32 {
	return v1[3]
}

// SetNormalizeOf sets this vector as v2 normalized. v1 = normalize(v2).
func (v1 *Vec2) SetNormalizeOf(v2 *Vec2) {
	l := 1.0 / v2.Len()
	v1[0] = l * v2[0]
	v1[1] = l * v2[1]
}

// SetNormalizeOf sets this vector as v2 normalized. v1 = normalize(v2).
func (v1 *Vec3) SetNormalizeOf(v2 *Vec3) {
	l := 1.0 / v2.Len()
	v1[0] = l * v2[0]
	v1[1] = l * v2[1]
	v1[2] = l * v2[2]
}

// SetNormalizeOf sets this vector as v2 normalized. v1 = normalize(v2).
func (v1 *Vec4) SetNormalizeOf(v2 *Vec4) {
	l := 1.0 / v2.Len()
	v1[0] = l * v2[0]
	v1[1] = l * v2[1]
	v1[2] = l * v2[2]
	v1[3] = l * v2[3]
}

// Dotf is the same as Dot but takes 2 float32 as input instead (API convinience
// function)
func (v1 *Vec2) Dotf(x, y float32) float32 {
	return v1[0]*x + v1[1]*y
}

// Dotf is the same as Dot but takes 3 float32 as input instead (API convinience
// function)
func (v1 *Vec3) Dotf(x, y, z float32) float32 {
	return v1[0]*x + v1[1]*y + v1[2]*z
}

// Dotf is the same as Dot but takes 4 float32 as input instead (API convinience
// function)
func (v1 *Vec4) Dotf(x, y, z, w float32) float32 {
	return v1[0]*x + v1[1]*y + v1[2]*z + v1[3]*w
}