/// <summary>
/// Returns FP precison distanve between two vectors
/// </summary>
/// <param name="value1">
/// A <see cref="FPVector2"/>
/// </param>
/// <param name="value2">
/// A <see cref="FPVector2"/>
/// </param>
/// <returns>
/// A <see cref="System.Single"/>
/// </returns>
public static Fix64 Distance(FPVector2 value1, FPVector2 value2)
{
Fix64 result;
DistanceSquared(ref value1, ref value2, out result);
return((Fix64)Fix64.Sqrt(result));
}
/// <summary>
/// Normalizes the given vector.
/// </summary>
/// <param name="value">The vector which should be normalized.</param>
/// <param name="result">A normalized vector.</param>
public static void Normalize(ref FPVector value, out FPVector result)
{
Fix64 num2 = ((value.x * value.x) + (value.y * value.y)) + (value.z * value.z);
Fix64 num = Fix64.One / Fix64.Sqrt(num2);
result.x = value.x * num;
result.y = value.y * num;
result.z = value.z * num;
}
/// <summary>
/// Normalizes this vector.
/// </summary>
public void Normalize()
{
Fix64 num2 = ((this.x * this.x) + (this.y * this.y)) + (this.z * this.z);
Fix64 num = Fix64.One / Fix64.Sqrt(num2);
this.x *= num;
this.y *= num;
this.z *= num;
}
public static void Normalize(ref FPVector2 value, out FPVector2 result)
{
Fix64 factor;
DistanceSquared(ref value, ref zeroVector, out factor);
factor = 1f / (Fix64)Fix64.Sqrt(factor);
result.x = value.x * factor;
result.y = value.y * factor;
}
/// <summary>
/// Sets the length of the quaternion to one.
/// </summary>
#region public void Normalize()
public void Normalize()
{
Fix64 num2 = (((this.x * this.x) + (this.y * this.y)) + (this.z * this.z)) + (this.w * this.w);
Fix64 num = 1 / (Fix64.Sqrt(num2));
this.x *= num;
this.y *= num;
this.z *= num;
this.w *= num;
}
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);
}
/// <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 Fix64 Distance(FPVector v1, FPVector v2)
{
return(Fix64.Sqrt((v1.x - v2.x) * (v1.x - v2.x) + (v1.y - v2.y) * (v1.y - v2.y) + (v1.z - v2.z) * (v1.z - v2.z)));
}
public static void Distance(ref FPVector2 value1, ref FPVector2 value2, out Fix64 result)
{
DistanceSquared(ref value1, ref value2, out result);
result = (Fix64)Fix64.Sqrt(result);
}
