// Normalize normalizes the vector to unit length.
func (vec *T) Normalize() *T {
sl := vec.LengthSqr()
if sl == 0 || sl == 1 {
return vec
}
return vec.Scale(1 / math.Sqrt(sl))
}
// Vec3Diff returns the rotation quaternion between two vectors.
func Vec3Diff(a, b *vec3.T) T {
cr := vec3.Cross(a, b)
sr := math.Sqrt(2 * (1 + vec3.Dot(a, b)))
oosr := 1 / sr
q := T{cr[0] * oosr, cr[1] * oosr, cr[2] * oosr, sr * 0.5}
return q.Normalized()
}
// Normalize normalizes to a unit quaternation.
func (quat *T) Normalize() *T {
norm := quat.Norm()
if norm != 1 && norm != 0 {
ool := 1 / math.Sqrt(norm)
quat[0] *= ool
quat[1] *= ool
quat[2] *= ool
quat[3] *= ool
}
return quat
}
// Normalized returns a copy normalized to a unit quaternation.
func (quat *T) Normalized() T {
norm := quat.Norm()
if norm != 1 && norm != 0 {
ool := 1 / math.Sqrt(norm)
return T{
quat[0] * ool,
quat[1] * ool,
quat[2] * ool,
quat[3] * ool,
}
} else {
return *quat
}
}
// Quaternion extracts a quaternion from the rotation part of the matrix.
func (mat *T) Quaternion() quaternion.T {
tr := mat.Trace()
s := math.Sqrt(tr + 1)
w := s * 0.5
s = 0.5 / s
q := quaternion.T{
(mat[1][2] - mat[2][1]) * s,
(mat[2][0] - mat[0][2]) * s,
(mat[0][1] - mat[1][0]) * s,
w,
}
return q.Normalized()
}
// AxisAngle extracts the rotation in form of an axis and a rotation angle.
func (quat *T) AxisAngle() (axis vec3.T, angle float32) {
cos := quat[3]
sin := math.Sqrt(1 - cos*cos)
angle = math.Acos(cos)
var ooSin float32
if math.Abs(sin) < 0.0005 {
ooSin = 1
} else {
ooSin = 1 / sin
}
axis[0] = quat[0] * ooSin
axis[1] = quat[1] * ooSin
axis[2] = quat[2] * ooSin
return axis, angle
}
// Length returns the length of the vector.
// See also LengthSqr and Normalize.
func (vec *T) Length() float32 {
return float32(math.Sqrt(vec.LengthSqr()))
}
func HSLMap(x, y, z float32) color.NRGBA {
s := fmath.Sqrt(x*x + y*y + z*z)
l := 0.5*z + 0.5
h := float32(math.Atan2(float64(y), float64(x)))
return HSL(h, s, l)
}