public static Quaternion Negate(Quaternion value)
{
Quaternion result;
result.W = -value.W;
result.X = -value.X;
result.Y = -value.Y;
result.Z = -value.Z;
return result;
}
public static void Negate(ref Quaternion value)
{
Negate(ref value, out value);
}
public static Quaternion Subtract(Quaternion left, Quaternion right)
{
Quaternion result;
result.W = left.W - right.W;
result.X = left.X - right.X;
result.Y = left.Y - right.Y;
result.Z = left.Z - right.Z;
return result;
}
public static void Subtract(ref Quaternion left,ref Quaternion right, out Quaternion result)
{
result.W = left.W - right.W;
result.X = left.X - right.X;
result.Y = left.Y - right.Y;
result.Z = left.Z - right.Z;
}
public static Quaternion Add(Quaternion left, Quaternion right)
{
Quaternion result;
result.W = left.W + right.W;
result.X = left.X + right.X;
result.Y = left.Y + right.Y;
result.Z = left.Z + right.Z;
return result;
}
public static void Add(ref Quaternion left,ref Quaternion right, out Quaternion result)
{
result.W = left.W + right.W;
result.X = left.X + right.X;
result.Y = left.Y + right.Y;
result.Z = left.Z + right.Z;
}
public static Quaternion Multiply(Quaternion left, Scalar scalar)
{
Quaternion result;
result.W = left.W * scalar;
result.X = left.X * scalar;
result.Y = left.Y * scalar;
result.Z = left.Z * scalar;
return result;
}
/// <summary>
/// Creates a Quaternion from a supplied angle and aXis.
/// </summary>
/// <param name="angle">Value of an angle in radians.</param>
/// <param name="aXis">ArbitrarY aXis vector.</param>
/// <returns></returns>
public static Quaternion FromAngleAxis(Scalar angle, Vector3D aXis)
{
Quaternion quat = new Quaternion();
Scalar halfAngle = 0.5f * angle;
Scalar sin = MathHelper.Sin(halfAngle);
quat.W = MathHelper.Cos(halfAngle);
quat.X = sin * aXis.X;
quat.Y = sin * aXis.Y;
quat.Z = sin * aXis.Z;
return quat;
}
public static Quaternion Multiply(Quaternion left, Quaternion right)
{
Quaternion result;
result.W = left.W * right.W - left.X * right.X - left.Y * right.Y - left.Z * right.Z;
result.X = left.W * right.X + left.X * right.W + left.Y * right.Z - left.Z * right.Y;
result.Y = left.W * right.Y + left.Y * right.W + left.Z * right.X - left.X * right.Z;
result.Z = left.W * right.Z + left.Z * right.W + left.X * right.Y - left.Y * right.X;
return result;
}
public static void Multiply(ref Quaternion left,ref Quaternion right,out Quaternion result)
{
Scalar W = left.W * right.W - left.X * right.X - left.Y * right.Y - left.Z * right.Z;
Scalar X = left.W * right.X + left.X * right.W + left.Y * right.Z - left.Z * right.Y;
Scalar Y = left.W * right.Y + left.Y * right.W + left.Z * right.X - left.X * right.Z;
result.Z = left.W * right.Z + left.Z * right.W + left.X * right.Y - left.Y * right.X;
result.W = W;
result.X = X;
result.Y = Y;
}
/// <summary>
/// Performs a Dot Product operation on 2 Quaternions.
/// </summary>
/// <param name="quat"></param>
/// <returns></returns>
public Scalar Dot(Quaternion quat)
{
return this.W * quat.W + this.X * quat.X + this.Y * quat.Y + this.Z * quat.Z;
}
/// <summary>
/// Performs spherical quadratic interpolation.
/// </summary>
/// <param name="t"></param>
/// <param name="p"></param>
/// <param name="a"></param>
/// <param name="b"></param>
/// <param name="q"></param>
/// <returns></returns>
public static Quaternion Squad(Scalar t, Quaternion p, Quaternion a, Quaternion b, Quaternion q, bool useShortestPath)
{
Scalar slerpT = 2.0f * t * (1.0f - t);
// use spherical linear interpolation
Quaternion slerpP = Slerp(t, p, q, useShortestPath);
Quaternion slerpQ = Slerp(t, a, b);
// run another Slerp on the returnvalues of the first 2, and return the returnvalues
return Slerp(slerpT, slerpP, slerpQ);
}
public static Quaternion Squad(Scalar t, Quaternion p, Quaternion a, Quaternion b, Quaternion q)
{
return Squad(t, p, a, b, q, false);
}
public static void Negate(ref Quaternion value, out Quaternion result)
{
result.W = -value.W;
result.X = -value.X;
result.Y = -value.Y;
result.Z = -value.Z;
}
public static void Multiply(ref Quaternion left,ref Scalar scalar, out Quaternion result)
{
result.W = left.W * scalar;
result.X = left.X * scalar;
result.Y = left.Y * scalar;
result.Z = left.Z * scalar;
}
public static Quaternion Slerp(Scalar time, Quaternion quatA, Quaternion quatB)
{
return Slerp(time, quatA, quatB, false);
}
/// <summary>
///
/// </summary>
/// <param name="time"></param>
/// <param name="quatA"></param>
/// <param name="quatB"></param>
/// <param name="useShortestPath"></param>
/// <returns></returns>
public static Quaternion Slerp(Scalar time, Quaternion quatA, Quaternion quatB, bool useShortestPath)
{
Scalar cos = quatA.Dot(quatB);
Scalar angle = MathHelper.Acos(cos);
if (MathHelper.Abs(angle) < MathHelper.EPSILON)
{
return quatA;
}
Scalar sin = MathHelper.Sin(angle);
Scalar inverseSin = 1.0f / sin;
Scalar coeff0 = MathHelper.Sin((1.0f - time) * angle) * inverseSin;
Scalar coeff1 = MathHelper.Sin(time * angle) * inverseSin;
Quaternion returnvalue;
if (cos < 0.0f && useShortestPath)
{
coeff0 = -coeff0;
// taking the complement requires renormalisation
Quaternion t = coeff0 * quatA + coeff1 * quatB;
t.Normalize();
returnvalue = t;
}
else
{
returnvalue = (coeff0 * quatA + coeff1 * quatB);
}
return returnvalue;
}
