/// <summary> /// Multiply two quaternions. /// </summary> /// <param name="quaternion1">The first quaternion.</param> /// <param name="quaternion2">The second quaternion.</param> /// <returns>The product of both quaternions.</returns> #region public static JQuaternion Multiply(JQuaternion quaternion1, JQuaternion quaternion2) public static FPQuaternion Multiply(FPQuaternion quaternion1, FPQuaternion quaternion2) { FPQuaternion result; FPQuaternion.Multiply(ref quaternion1, ref quaternion2, out result); return(result); }
/// <summary> /// Quaternions are subtracted. /// </summary> /// <param name="quaternion1">The first quaternion.</param> /// <param name="quaternion2">The second quaternion.</param> /// <param name="result">The difference of both quaternions.</param> public static void Subtract(ref FPQuaternion quaternion1, ref FPQuaternion quaternion2, out FPQuaternion result) { result.x = quaternion1.x - quaternion2.x; result.y = quaternion1.y - quaternion2.y; result.z = quaternion1.z - quaternion2.z; result.w = quaternion1.w - quaternion2.w; }
/// <summary> /// Scale a quaternion /// </summary> /// <param name="quaternion1">The quaternion to scale.</param> /// <param name="scaleFactor">Scale factor.</param> /// <returns>The scaled quaternion.</returns> #region public static JQuaternion Multiply(JQuaternion quaternion1, FP scaleFactor) public static FPQuaternion Multiply(FPQuaternion quaternion1, Fix64 scaleFactor) { FPQuaternion result; FPQuaternion.Multiply(ref quaternion1, scaleFactor, out result); return(result); }
/// <summary> /// Creates a quaternion from a matrix. /// </summary> /// <param name="matrix">A matrix representing an orientation.</param> /// <returns>JQuaternion representing an orientation.</returns> #region public static JQuaternion CreateFromMatrix(JMatrix matrix) public static FPQuaternion CreateFromMatrix(FPMatrix matrix) { FPQuaternion result; FPQuaternion.CreateFromMatrix(ref matrix, out result); return(result); }
/// <summary> /// Scale a quaternion /// </summary> /// <param name="quaternion1">The quaternion to scale.</param> /// <param name="scaleFactor">Scale factor.</param> /// <param name="result">The scaled quaternion.</param> public static void Multiply(ref FPQuaternion quaternion1, Fix64 scaleFactor, out FPQuaternion result) { result.x = quaternion1.x * scaleFactor; result.y = quaternion1.y * scaleFactor; result.z = quaternion1.z * scaleFactor; result.w = quaternion1.w * scaleFactor; }
/// <summary> /// Quaternions are added. /// </summary> /// <param name="quaternion1">The first quaternion.</param> /// <param name="quaternion2">The second quaternion.</param> /// <param name="result">The sum of both quaternions.</param> public static void Add(ref FPQuaternion quaternion1, ref FPQuaternion quaternion2, out FPQuaternion result) { result.x = quaternion1.x + quaternion2.x; result.y = quaternion1.y + quaternion2.y; result.z = quaternion1.z + quaternion2.z; result.w = quaternion1.w + quaternion2.w; }
/// <summary> /// Multiply two quaternions. /// </summary> /// <param name="value1">The first quaternion.</param> /// <param name="value2">The second quaternion.</param> /// <returns>The product of both quaternions.</returns> #region public static FP operator *(JQuaternion value1, JQuaternion value2) public static FPQuaternion operator *(FPQuaternion value1, FPQuaternion value2) { FPQuaternion result; FPQuaternion.Multiply(ref value1, ref value2, out result); return(result); }
/// <summary> /// Add two quaternions. /// </summary> /// <param name="value1">The first quaternion.</param> /// <param name="value2">The second quaternion.</param> /// <returns>The sum of both quaternions.</returns> #region public static FP operator +(JQuaternion value1, JQuaternion value2) public static FPQuaternion operator +(FPQuaternion value1, FPQuaternion value2) { FPQuaternion result; FPQuaternion.Add(ref value1, ref value2, out result); return(result); }
/// <summary> /// Quaternions are added. /// </summary> /// <param name="quaternion1">The first quaternion.</param> /// <param name="quaternion2">The second quaternion.</param> /// <returns>The sum of both quaternions.</returns> #region public static JQuaternion Add(JQuaternion quaternion1, JQuaternion quaternion2) public static FPQuaternion Add(FPQuaternion quaternion1, FPQuaternion quaternion2) { FPQuaternion result; FPQuaternion.Add(ref quaternion1, ref quaternion2, out result); return(result); }
/// <summary> /// Subtract two quaternions. /// </summary> /// <param name="value1">The first quaternion.</param> /// <param name="value2">The second quaternion.</param> /// <returns>The difference of both quaternions.</returns> #region public static FP operator -(JQuaternion value1, JQuaternion value2) public static FPQuaternion operator -(FPQuaternion value1, FPQuaternion value2) { FPQuaternion result; FPQuaternion.Subtract(ref value1, ref value2, out result); return(result); }
/// <summary> /// Quaternions are subtracted. /// </summary> /// <param name="quaternion1">The first quaternion.</param> /// <param name="quaternion2">The second quaternion.</param> /// <returns>The difference of both quaternions.</returns> #region public static JQuaternion Subtract(JQuaternion quaternion1, JQuaternion quaternion2) public static FPQuaternion Subtract(FPQuaternion quaternion1, FPQuaternion quaternion2) { FPQuaternion result; FPQuaternion.Subtract(ref quaternion1, ref quaternion2, out result); return(result); }
public static FPQuaternion LerpUnclamped(FPQuaternion a, FPQuaternion b, Fix64 t) { FPQuaternion result = FPQuaternion.Multiply(a, (1 - t)) + FPQuaternion.Multiply(b, t); result.Normalize(); return(result); }
public static FPQuaternion FromToRotation(FPVector fromVector, FPVector toVector) { FPVector w = FPVector.Cross(fromVector, toVector); FPQuaternion q = new FPQuaternion(w.x, w.y, w.z, FPVector.Dot(fromVector, toVector)); q.w += Fix64.Sqrt(fromVector.sqrMagnitude * toVector.sqrMagnitude); q.Normalize(); return(q); }
public static FPQuaternion Conjugate(FPQuaternion value) { FPQuaternion quaternion; quaternion.x = -value.x; quaternion.y = -value.y; quaternion.z = -value.z; quaternion.w = value.w; return(quaternion); }
public static FPQuaternion Euler(Fix64 x, Fix64 y, Fix64 z) { x *= Fix64.Deg2Rad; y *= Fix64.Deg2Rad; z *= Fix64.Deg2Rad; FPQuaternion rotation; FPQuaternion.CreateFromYawPitchRoll(y, x, z, out rotation); return(rotation); }
public static Fix64 Angle(FPQuaternion a, FPQuaternion b) { FPQuaternion aInv = FPQuaternion.Inverse(a); FPQuaternion f = b * aInv; Fix64 angle = Fix64.Acos(f.w) * 2 * Fix64.Rad2Deg; if (angle > 180) { angle = 360 - angle; } return(angle); }
public static FPQuaternion Slerp(FPQuaternion from, FPQuaternion to, Fix64 t) { t = FPMath.Clamp(t, 0, 1); Fix64 dot = Dot(from, to); if (dot < 0.0f) { to = Multiply(to, -1); dot = -dot; } Fix64 halfTheta = Fix64.Acos(dot); return(Multiply(Multiply(from, Fix64.Sin((1 - t) * halfTheta)) + Multiply(to, Fix64.Sin(t * halfTheta)), 1 / Fix64.Sin(halfTheta))); }
public void Rotate(FPVector axis, Fix64 angle, Space relativeTo) { FPQuaternion result = FPQuaternion.identity; if (relativeTo == Space.Self) { result = this.rotation * FPQuaternion.AngleAxis(angle, axis); } else { result = FPQuaternion.AngleAxis(angle, axis) * this.rotation; } result.Normalize(); this.rotation = result; }
public void Rotate(FPVector eulerAngles, Space relativeTo) { FPQuaternion result = FPQuaternion.identity; if (relativeTo == Space.Self) { result = this.rotation * FPQuaternion.Euler(eulerAngles); } else { result = FPQuaternion.Euler(eulerAngles) * this.rotation; } result.Normalize(); this.rotation = result; }
/// <summary> /// Multiply two quaternions. /// </summary> /// <param name="quaternion1">The first quaternion.</param> /// <param name="quaternion2">The second quaternion.</param> /// <param name="result">The product of both quaternions.</param> public static void Multiply(ref FPQuaternion quaternion1, ref FPQuaternion quaternion2, out FPQuaternion result) { Fix64 x = quaternion1.x; Fix64 y = quaternion1.y; Fix64 z = quaternion1.z; Fix64 w = quaternion1.w; Fix64 num4 = quaternion2.x; Fix64 num3 = quaternion2.y; Fix64 num2 = quaternion2.z; Fix64 num = quaternion2.w; Fix64 num12 = (y * num2) - (z * num3); Fix64 num11 = (z * num4) - (x * num2); Fix64 num10 = (x * num3) - (y * num4); Fix64 num9 = ((x * num4) + (y * num3)) + (z * num2); result.x = ((x * num) + (num4 * w)) + num12; result.y = ((y * num) + (num3 * w)) + num11; result.z = ((z * num) + (num2 * w)) + num10; result.w = (w * num) - num9; }
/// <summary> /// Creates a quaternion from a matrix. /// </summary> /// <param name="matrix">A matrix representing an orientation.</param> /// <param name="result">JQuaternion representing an orientation.</param> public static void CreateFromMatrix(ref FPMatrix matrix, out FPQuaternion result) { Fix64 num8 = (matrix.M11 + matrix.M22) + matrix.M33; if (num8 > Fix64.Zero) { Fix64 num = Fix64.Sqrt((num8 + Fix64.One)); result.w = num * Fix64.Half; num = Fix64.Half / num; result.x = (matrix.M23 - matrix.M32) * num; result.y = (matrix.M31 - matrix.M13) * num; result.z = (matrix.M12 - matrix.M21) * num; } else if ((matrix.M11 >= matrix.M22) && (matrix.M11 >= matrix.M33)) { Fix64 num7 = Fix64.Sqrt((((Fix64.One + matrix.M11) - matrix.M22) - matrix.M33)); Fix64 num4 = Fix64.Half / num7; result.x = Fix64.Half * num7; result.y = (matrix.M12 + matrix.M21) * num4; result.z = (matrix.M13 + matrix.M31) * num4; result.w = (matrix.M23 - matrix.M32) * num4; } else if (matrix.M22 > matrix.M33) { Fix64 num6 = Fix64.Sqrt((((Fix64.One + matrix.M22) - matrix.M11) - matrix.M33)); Fix64 num3 = Fix64.Half / num6; result.x = (matrix.M21 + matrix.M12) * num3; result.y = Fix64.Half * num6; result.z = (matrix.M32 + matrix.M23) * num3; result.w = (matrix.M31 - matrix.M13) * num3; } else { Fix64 num5 = Fix64.Sqrt((((Fix64.One + matrix.M33) - matrix.M11) - matrix.M22)); Fix64 num2 = Fix64.Half / num5; result.x = (matrix.M31 + matrix.M13) * num2; result.y = (matrix.M32 + matrix.M23) * num2; result.z = Fix64.Half * num5; result.w = (matrix.M12 - matrix.M21) * num2; } }
public static FPQuaternion RotateTowards(FPQuaternion from, FPQuaternion to, Fix64 maxDegreesDelta) { Fix64 dot = Dot(from, to); if (dot < 0.0f) { to = Multiply(to, -1); dot = -dot; } Fix64 halfTheta = Fix64.Acos(dot); Fix64 theta = halfTheta * 2; maxDegreesDelta *= Fix64.Deg2Rad; if (maxDegreesDelta >= theta) { return(to); } maxDegreesDelta /= theta; return(Multiply(Multiply(from, Fix64.Sin((1 - maxDegreesDelta) * halfTheta)) + Multiply(to, Fix64.Sin(maxDegreesDelta * halfTheta)), 1 / Fix64.Sin(halfTheta))); }
public void SetFromToRotation(FPVector fromDirection, FPVector toDirection) { FPQuaternion targetRotation = FPQuaternion.FromToRotation(fromDirection, toDirection); this.Set(targetRotation.x, targetRotation.y, targetRotation.z, targetRotation.w); }
public void LookAt(FPVector target) { this.rotation = FPQuaternion.CreateFromMatrix(FPMatrix.CreateFromLookAt(position, target)); }
public static void CreateFromYawPitchRoll(Fix64 yaw, Fix64 pitch, Fix64 roll, out FPQuaternion result) { Fix64 num9 = roll * Fix64.Half; Fix64 num6 = Fix64.Sin(num9); Fix64 num5 = Fix64.Cos(num9); Fix64 num8 = pitch * Fix64.Half; Fix64 num4 = Fix64.Sin(num8); Fix64 num3 = Fix64.Cos(num8); Fix64 num7 = yaw * Fix64.Half; Fix64 num2 = Fix64.Sin(num7); Fix64 num = Fix64.Cos(num7); result.x = ((num * num4) * num5) + ((num2 * num3) * num6); result.y = ((num2 * num3) * num5) - ((num * num4) * num6); result.z = ((num * num3) * num6) - ((num2 * num4) * num5); result.w = ((num * num3) * num5) + ((num2 * num4) * num6); }
static FPQuaternion() { identity = new FPQuaternion(0, 0, 0, 1); }
public static Fix64 Dot(FPQuaternion a, FPQuaternion b) { return(a.w * b.w + a.x * b.x + a.y * b.y + a.z * b.z); }
public static FPQuaternion Inverse(FPQuaternion rotation) { Fix64 invNorm = Fix64.One / ((rotation.x * rotation.x) + (rotation.y * rotation.y) + (rotation.z * rotation.z) + (rotation.w * rotation.w)); return(FPQuaternion.Multiply(FPQuaternion.Conjugate(rotation), invNorm)); }
public static FPQuaternion Lerp(FPQuaternion a, FPQuaternion b, Fix64 t) { t = FPMath.Clamp(t, Fix64.Zero, Fix64.One); return(LerpUnclamped(a, b, t)); }