/// <summary> /// Returns a quat from component-wise application of Lerp (min * (1-a) + max * a). /// </summary> public static quat Lerp(float min, quat max, float a) => new quat(min * (1 - a) + max.x * a, min * (1 - a) + max.y * a, min * (1 - a) + max.z * a, min * (1 - a) + max.w * a);
/// <summary> /// Returns a bvec4 from component-wise application of GreaterThanEqual (lhs >= rhs). /// </summary> public static bvec4 GreaterThanEqual(quat lhs, quat rhs) => quat.GreaterThanEqual(lhs, rhs);
/// <summary> /// Returns the inner product (dot product, scalar product) of the two quaternions. /// </summary> public static float Dot(quat lhs, quat rhs) => quat.Dot(lhs, rhs);
/// <summary> /// Returns a bvec4 from component-wise application of LesserThan (lhs < rhs). /// </summary> public static bvec4 LesserThan(quat lhs, float rhs) => new bvec4(lhs.x < rhs, lhs.y < rhs, lhs.z < rhs, lhs.w < rhs);
/// <summary> /// Returns a bvec4 from component-wise application of Equal (lhs == rhs). /// </summary> public static bvec4 Equal(quat lhs, quat rhs) => quat.Equal(lhs, rhs);
/// <summary> /// Returns a bvec4 from component-wise application of GreaterThan (lhs > rhs). /// </summary> public static bvec4 GreaterThan(quat lhs, float rhs) => new bvec4(lhs.x > rhs, lhs.y > rhs, lhs.z > rhs, lhs.w > rhs);
/// <summary> /// Returns a bvec4 from component-wise application of GreaterThanEqual (lhs >= rhs). /// </summary> public static bvec4 GreaterThanEqual(float lhs, quat rhs) => new bvec4(lhs >= rhs.x, lhs >= rhs.y, lhs >= rhs.z, lhs >= rhs.w);
/// <summary> /// Returns the cross product between two quaternions. /// </summary> public static quat Cross(quat q1, quat q2) => new quat(q1.w * q2.x + q1.x * q2.w + q1.y * q2.z - q1.z * q2.y, q1.w * q2.y + q1.y * q2.w + q1.z * q2.x - q1.x * q2.z, q1.w * q2.z + q1.z * q2.w + q1.x * q2.y - q1.y * q2.x, q1.w * q2.w - q1.x * q2.x - q1.y * q2.y - q1.z * q2.z);
/// <summary> /// Applies squad interpolation of these quaternions /// </summary> public static quat Squad(quat q1, quat q2, quat s1, quat s2, float h) => Mix(Mix(q1, q2, h), Mix(s1, s2, h), 2 * (1 - h) * h);
/// <summary>
/// Tries to convert the string representation of the quaternion into a quaternion representation (using a designated separator and a number style and a format provider), returns false if string was invalid.
/// </summary>
public static bool TryParse(string s, string sep, NumberStyles style, IFormatProvider provider, out quat result)
{
result = Zero;
if (string.IsNullOrEmpty(s))
{
return(false);
}
var kvp = s.Split(new[] { sep }, StringSplitOptions.None);
if (kvp.Length != 4)
{
return(false);
}
float x = 0f, y = 0f, z = 0f, w = 0f;
var ok = ((float.TryParse(kvp[0].Trim(), style, provider, out x) && float.TryParse(kvp[1].Trim(), style, provider, out y)) && (float.TryParse(kvp[2].Trim(), style, provider, out z) && float.TryParse(kvp[3].Trim(), style, provider, out w)));
result = ok ? new quat(x, y, z, w) : Zero;
return(ok);
}
/// <summary> /// Returns the inner product (dot product, scalar product) of the two quaternions. /// </summary> public static float Dot(quat lhs, quat rhs) => ((lhs.x * rhs.x + lhs.y * rhs.y) + (lhs.z * rhs.z + lhs.w * rhs.w));
/// <summary> /// Tries to convert the string representation of the quaternion into a quaternion representation (using ', ' as a separator), returns false if string was invalid. /// </summary> public static bool TryParse(string s, out quat result) => TryParse(s, ", ", out result);
/// <summary> /// Returns true iff this equals rhs component-wise. /// </summary> public bool Equals(quat rhs) => ((x.Equals(rhs.x) && y.Equals(rhs.y)) && (z.Equals(rhs.z) && w.Equals(rhs.w)));
/// <summary> /// Returns a quat from component-wise application of Lerp (min * (1-a) + max * a). /// </summary> public static quat Lerp(float min, float max, quat a) => new quat(min * (1 - a.x) + max * a.x, min * (1 - a.y) + max * a.y, min * (1 - a.z) + max * a.z, min * (1 - a.w) + max * a.w);
/// <summary> /// Returns a bvec4 from component-wise application of NotEqual (lhs != rhs). /// </summary> public static bvec4 NotEqual(float lhs, quat rhs) => new bvec4(lhs != rhs.x, lhs != rhs.y, lhs != rhs.z, lhs != rhs.w);
/// <summary> /// Returns a bvec4 from component-wise application of IsFinite (!float.IsNaN(v) && !float.IsInfinity(v)). /// </summary> public static bvec4 IsFinite(quat v) => new bvec4(!float.IsNaN(v.x) && !float.IsInfinity(v.x), !float.IsNaN(v.y) && !float.IsInfinity(v.y), !float.IsNaN(v.z) && !float.IsInfinity(v.z), !float.IsNaN(v.w) && !float.IsInfinity(v.w));
/// <summary> /// Returns a bvec4 from component-wise application of GreaterThan (lhs > rhs). /// </summary> public static bvec4 GreaterThan(quat lhs, quat rhs) => new bvec4(lhs.x > rhs.x, lhs.y > rhs.y, lhs.z > rhs.z, lhs.w > rhs.w);
/// <summary> /// Returns a bvec4 from component-wise application of IsNaN (float.IsNaN(v)). /// </summary> public static bvec4 IsNaN(quat v) => new bvec4(float.IsNaN(v.x), float.IsNaN(v.y), float.IsNaN(v.z), float.IsNaN(v.w));
/// <summary> /// Returns a bvec4 from component-wise application of GreaterThanEqual (lhs >= rhs). /// </summary> public static bvec4 GreaterThanEqual(quat lhs, float rhs) => new bvec4(lhs.x >= rhs, lhs.y >= rhs, lhs.z >= rhs, lhs.w >= rhs);
/// <summary> /// Returns a bvec4 from component-wise application of IsPositiveInfinity (float.IsPositiveInfinity(v)). /// </summary> public static bvec4 IsPositiveInfinity(quat v) => new bvec4(float.IsPositiveInfinity(v.x), float.IsPositiveInfinity(v.y), float.IsPositiveInfinity(v.z), float.IsPositiveInfinity(v.w));
/// <summary> /// Returns a bvec4 from component-wise application of LesserThan (lhs < rhs). /// </summary> public static bvec4 LesserThan(quat lhs, quat rhs) => new bvec4(lhs.x < rhs.x, lhs.y < rhs.y, lhs.z < rhs.z, lhs.w < rhs.w);
/// <summary> /// Returns a bvec4 from component-wise application of Equal (lhs == rhs). /// </summary> public static bvec4 Equal(quat lhs, quat rhs) => new bvec4(lhs.x == rhs.x, lhs.y == rhs.y, lhs.z == rhs.z, lhs.w == rhs.w);
/// <summary> /// Returns a bvec4 from component-wise application of LesserThan (lhs < rhs). /// </summary> public static bvec4 LesserThan(float lhs, quat rhs) => new bvec4(lhs < rhs.x, lhs < rhs.y, lhs < rhs.z, lhs < rhs.w);
/// <summary> /// Returns a bvec4 from component-wise application of Equal (lhs == rhs). /// </summary> public static bvec4 Equal(quat lhs, float rhs) => new bvec4(lhs.x == rhs, lhs.y == rhs, lhs.z == rhs, lhs.w == rhs);
/// <summary> /// Returns a bvec4 from component-wise application of NotEqual (lhs != rhs). /// </summary> public static bvec4 NotEqual(quat lhs, quat rhs) => quat.NotEqual(lhs, rhs);
/// <summary> /// Returns a bvec4 from component-wise application of NotEqual (lhs != rhs). /// </summary> public static bvec4 NotEqual(quat lhs, quat rhs) => new bvec4(lhs.x != rhs.x, lhs.y != rhs.y, lhs.z != rhs.z, lhs.w != rhs.w);
/// <summary> /// Returns a bvec4 from component-wise application of LesserThanEqual (lhs <= rhs). /// </summary> public static bvec4 LesserThanEqual(quat lhs, quat rhs) => quat.LesserThanEqual(lhs, rhs);
/// <summary> /// Returns a bvec4 from component-wise application of NotEqual (lhs != rhs). /// </summary> public static bvec4 NotEqual(quat lhs, float rhs) => new bvec4(lhs.x != rhs, lhs.y != rhs, lhs.z != rhs, lhs.w != rhs);
/// <summary> /// Returns the euclidean length of this quaternion. /// </summary> public static float Length(quat q) => q.Length;
/// <summary> /// Returns a quat from component-wise application of Lerp (min * (1-a) + max * a). /// </summary> public static quat Lerp(quat min, float max, float a) => new quat(min.x * (1 - a) + max * a, min.y * (1 - a) + max * a, min.z * (1 - a) + max * a, min.w * (1 - a) + max * a);
