mirror of
https://github.com/space-wizards/RobustToolbox.git
synced 2026-02-15 03:30:53 +01:00
9cbdd1058c
update a bunch of packages and use JetBrains.Annotations as private asset as needed mark some hot math methods agg inline to benefit from loop opts use FMA for interp use canny min/max/clamp make Quaternion NormalizeAngle fixed time and faster clean up YamlDotNet references
1192 lines
43 KiB
C#
1192 lines
43 KiB
C#
#region --- License ---
|
|
|
|
/*
|
|
Copyright (c) 2006 - 2008 The Open Toolkit library.
|
|
Copyright 2013 Xamarin Inc
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy of
|
|
this software and associated documentation files (the "Software"), to deal in
|
|
the Software without restriction, including without limitation the rights to
|
|
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
|
|
of the Software, and to permit persons to whom the Software is furnished to do
|
|
so, subject to the following conditions:
|
|
|
|
The above copyright notice and this permission notice shall be included in all
|
|
copies or substantial portions of the Software.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
SOFTWARE.
|
|
*/
|
|
|
|
#endregion
|
|
|
|
using System;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Runtime.InteropServices;
|
|
using System.Xml.Serialization;
|
|
using Math = CannyFastMath.Math;
|
|
using MathF = CannyFastMath.MathF;
|
|
|
|
namespace Robust.Shared.Maths
|
|
{
|
|
/// <summary>
|
|
/// Represents a 3D vector using three single-precision floating-point numbers.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The Vector3 structure is suitable for interoperation with unmanaged code requiring three consecutive floats.
|
|
/// </remarks>
|
|
[Serializable]
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public struct Vector3 : IEquatable<Vector3>
|
|
{
|
|
#region Fields
|
|
|
|
/// <summary>
|
|
/// The X component of the Vector3.
|
|
/// </summary>
|
|
public float X;
|
|
|
|
/// <summary>
|
|
/// The Y component of the Vector3.
|
|
/// </summary>
|
|
public float Y;
|
|
|
|
/// <summary>
|
|
/// The Z component of the Vector3.
|
|
/// </summary>
|
|
public float Z;
|
|
|
|
#endregion
|
|
|
|
#region Constructors
|
|
|
|
/// <summary>
|
|
/// Constructs a new instance.
|
|
/// </summary>
|
|
/// <param name="value">The value that will initialize this instance.</param>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public Vector3(float value)
|
|
{
|
|
X = value;
|
|
Y = value;
|
|
Z = value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Constructs a new Vector3.
|
|
/// </summary>
|
|
/// <param name="x">The x component of the Vector3.</param>
|
|
/// <param name="y">The y component of the Vector3.</param>
|
|
/// <param name="z">The z component of the Vector3.</param>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public Vector3(float x, float y, float z)
|
|
{
|
|
X = x;
|
|
Y = y;
|
|
Z = z;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Constructs a new Vector3 from the given Vector2.
|
|
/// </summary>
|
|
/// <param name="v">The Vector2 to copy components from.</param>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public Vector3(Vector2 v)
|
|
{
|
|
X = v.X;
|
|
Y = v.Y;
|
|
Z = 0.0f;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Constructs a new Vector3 from the given Vector3.
|
|
/// </summary>
|
|
/// <param name="v">The Vector3 to copy components from.</param>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public Vector3(Vector3 v)
|
|
{
|
|
X = v.X;
|
|
Y = v.Y;
|
|
Z = v.Z;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Constructs a new Vector3 from the given Vector4.
|
|
/// </summary>
|
|
/// <param name="v">The Vector4 to copy components from.</param>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public Vector3(Vector4 v)
|
|
{
|
|
X = v.X;
|
|
Y = v.Y;
|
|
Z = v.Z;
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public void Deconstruct(out float x, out float y, out float z)
|
|
{
|
|
x = X;
|
|
y = Y;
|
|
z = Z;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Public Members
|
|
|
|
#region Instance
|
|
|
|
#region public float Length
|
|
|
|
/// <summary>
|
|
/// Gets the length (magnitude) of the vector.
|
|
/// </summary>
|
|
/// <seealso cref="LengthSquared"/>
|
|
public float Length
|
|
{
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
get => MathF.Sqrt(LengthSquared);
|
|
}
|
|
#endregion
|
|
|
|
#region public float LengthSquared
|
|
|
|
/// <summary>
|
|
/// Gets the square of the vector length (magnitude).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// This property avoids the costly square root operation required by the Length property. This makes it more suitable
|
|
/// for comparisons.
|
|
/// </remarks>
|
|
/// <see cref="Length"/>
|
|
public float LengthSquared
|
|
{
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
get => X * X + Y * Y + Z * Z;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region public void Normalize()
|
|
|
|
/// <summary>
|
|
/// Scales the Vector3 to unit length.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public void Normalize()
|
|
{
|
|
var scale = 1.0f / Length;
|
|
X *= scale;
|
|
Y *= scale;
|
|
Z *= scale;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region Static
|
|
|
|
#region Fields
|
|
|
|
/// <summary>
|
|
/// Defines a unit-length Vector3 that points towards the X-axis.
|
|
/// </summary>
|
|
public static readonly Vector3 UnitX = new Vector3(1, 0, 0);
|
|
|
|
/// <summary>
|
|
/// Defines a unit-length Vector3 that points towards the Y-axis.
|
|
/// </summary>
|
|
public static readonly Vector3 UnitY = new Vector3(0, 1, 0);
|
|
|
|
/// <summary>
|
|
/// /// Defines a unit-length Vector3 that points towards the Z-axis.
|
|
/// </summary>
|
|
public static readonly Vector3 UnitZ = new Vector3(0, 0, 1);
|
|
|
|
/// <summary>
|
|
/// Defines a zero-length Vector3.
|
|
/// </summary>
|
|
public static readonly Vector3 Zero = new Vector3(0, 0, 0);
|
|
|
|
/// <summary>
|
|
/// Defines an instance with all components set to 1.
|
|
/// </summary>
|
|
public static readonly Vector3 One = new Vector3(1, 1, 1);
|
|
|
|
/// <summary>
|
|
/// Defines the size of the Vector3 struct in bytes.
|
|
/// </summary>
|
|
public static readonly int SizeInBytes = Marshal.SizeOf(new Vector3());
|
|
|
|
#endregion
|
|
|
|
#region Add
|
|
|
|
/// <summary>
|
|
/// Adds two vectors.
|
|
/// </summary>
|
|
/// <param name="a">Left operand.</param>
|
|
/// <param name="b">Right operand.</param>
|
|
/// <returns>Result of operation.</returns>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static Vector3 Add(Vector3 a, Vector3 b)
|
|
{
|
|
Add(ref a, ref b, out a);
|
|
return a;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds two vectors.
|
|
/// </summary>
|
|
/// <param name="a">Left operand.</param>
|
|
/// <param name="b">Right operand.</param>
|
|
/// <param name="result">Result of operation.</param>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static void Add(ref Vector3 a, ref Vector3 b, out Vector3 result)
|
|
{
|
|
result = new Vector3(a.X + b.X, a.Y + b.Y, a.Z + b.Z);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Subtract
|
|
|
|
/// <summary>
|
|
/// Subtract one Vector from another
|
|
/// </summary>
|
|
/// <param name="a">First operand</param>
|
|
/// <param name="b">Second operand</param>
|
|
/// <returns>Result of subtraction</returns>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static Vector3 Subtract(Vector3 a, Vector3 b)
|
|
{
|
|
Subtract(ref a, ref b, out a);
|
|
return a;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Subtract one Vector from another
|
|
/// </summary>
|
|
/// <param name="a">First operand</param>
|
|
/// <param name="b">Second operand</param>
|
|
/// <param name="result">Result of subtraction</param>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static void Subtract(ref Vector3 a, ref Vector3 b, out Vector3 result)
|
|
{
|
|
result = new Vector3(a.X - b.X, a.Y - b.Y, a.Z - b.Z);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Multiply
|
|
|
|
/// <summary>
|
|
/// Multiplies a vector by a scalar.
|
|
/// </summary>
|
|
/// <param name="vector">Left operand.</param>
|
|
/// <param name="scale">Right operand.</param>
|
|
/// <returns>Result of the operation.</returns>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static Vector3 Multiply(Vector3 vector, float scale)
|
|
{
|
|
Multiply(ref vector, scale, out vector);
|
|
return vector;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Multiplies a vector by a scalar.
|
|
/// </summary>
|
|
/// <param name="vector">Left operand.</param>
|
|
/// <param name="scale">Right operand.</param>
|
|
/// <param name="result">Result of the operation.</param>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static void Multiply(ref Vector3 vector, float scale, out Vector3 result)
|
|
{
|
|
result = new Vector3(vector.X * scale, vector.Y * scale, vector.Z * scale);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Multiplies a vector by the components a vector (scale).
|
|
/// </summary>
|
|
/// <param name="vector">Left operand.</param>
|
|
/// <param name="scale">Right operand.</param>
|
|
/// <returns>Result of the operation.</returns>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static Vector3 Multiply(Vector3 vector, Vector3 scale)
|
|
{
|
|
Multiply(ref vector, ref scale, out vector);
|
|
return vector;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Multiplies a vector by the components of a vector (scale).
|
|
/// </summary>
|
|
/// <param name="vector">Left operand.</param>
|
|
/// <param name="scale">Right operand.</param>
|
|
/// <param name="result">Result of the operation.</param>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static void Multiply(ref Vector3 vector, ref Vector3 scale, out Vector3 result)
|
|
{
|
|
result = new Vector3(vector.X * scale.X, vector.Y * scale.Y, vector.Z * scale.Z);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Divide
|
|
|
|
/// <summary>
|
|
/// Divides a vector by a scalar.
|
|
/// </summary>
|
|
/// <param name="vector">Left operand.</param>
|
|
/// <param name="scale">Right operand.</param>
|
|
/// <returns>Result of the operation.</returns>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static Vector3 Divide(Vector3 vector, float scale)
|
|
{
|
|
Divide(ref vector, scale, out vector);
|
|
return vector;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Divides a vector by a scalar.
|
|
/// </summary>
|
|
/// <param name="vector">Left operand.</param>
|
|
/// <param name="scale">Right operand.</param>
|
|
/// <param name="result">Result of the operation.</param>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static void Divide(ref Vector3 vector, float scale, out Vector3 result)
|
|
{
|
|
Multiply(ref vector, 1 / scale, out result);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Divides a vector by the components of a vector (scale).
|
|
/// </summary>
|
|
/// <param name="vector">Left operand.</param>
|
|
/// <param name="scale">Right operand.</param>
|
|
/// <returns>Result of the operation.</returns>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static Vector3 Divide(Vector3 vector, Vector3 scale)
|
|
{
|
|
Divide(ref vector, ref scale, out vector);
|
|
return vector;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Divide a vector by the components of a vector (scale).
|
|
/// </summary>
|
|
/// <param name="vector">Left operand.</param>
|
|
/// <param name="scale">Right operand.</param>
|
|
/// <param name="result">Result of the operation.</param>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static void Divide(ref Vector3 vector, ref Vector3 scale, out Vector3 result)
|
|
{
|
|
result = new Vector3(vector.X / scale.X, vector.Y / scale.Y, vector.Z / scale.Z);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ComponentMin
|
|
|
|
/// <summary>
|
|
/// Calculate the component-wise minimum of two vectors
|
|
/// </summary>
|
|
/// <param name="a">First operand</param>
|
|
/// <param name="b">Second operand</param>
|
|
/// <returns>The component-wise minimum</returns>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static Vector3 ComponentMin(Vector3 a, Vector3 b)
|
|
{
|
|
a.X = MathF.Min(a.X, b.X);
|
|
a.Y = MathF.Min(a.Y, b.Y);
|
|
a.Z = MathF.Min(a.Z, b.Z);
|
|
return a;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Calculate the component-wise minimum of two vectors
|
|
/// </summary>
|
|
/// <param name="a">First operand</param>
|
|
/// <param name="b">Second operand</param>
|
|
/// <param name="result">The component-wise minimum</param>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static void ComponentMin(ref Vector3 a, ref Vector3 b, out Vector3 result)
|
|
{
|
|
result.X = MathF.Min(a.X, b.X);
|
|
result.Y = MathF.Min(a.Y, b.Y);
|
|
result.Z = MathF.Min(a.Z, b.Z);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ComponentMax
|
|
|
|
/// <summary>
|
|
/// Calculate the component-wise maximum of two vectors
|
|
/// </summary>
|
|
/// <param name="a">First operand</param>
|
|
/// <param name="b">Second operand</param>
|
|
/// <returns>The component-wise maximum</returns>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static Vector3 ComponentMax(Vector3 a, Vector3 b)
|
|
{
|
|
a.X = MathF.Max(a.X, b.X);
|
|
a.Y = MathF.Max(a.Y, b.Y);
|
|
a.Z = MathF.Max(a.Z, b.Z);
|
|
return a;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Calculate the component-wise maximum of two vectors
|
|
/// </summary>
|
|
/// <param name="a">First operand</param>
|
|
/// <param name="b">Second operand</param>
|
|
/// <param name="result">The component-wise maximum</param>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static void ComponentMax(ref Vector3 a, ref Vector3 b, out Vector3 result)
|
|
{
|
|
result.X = MathF.Max(a.X, b.X);
|
|
result.Y = MathF.Max(a.Y, b.Y);
|
|
result.Z = MathF.Max(a.Z, b.Z);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Min
|
|
|
|
/// <summary>
|
|
/// Returns the Vector3 with the minimum magnitude
|
|
/// </summary>
|
|
/// <param name="left">Left operand</param>
|
|
/// <param name="right">Right operand</param>
|
|
/// <returns>The minimum Vector3</returns>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static Vector3 Min(Vector3 left, Vector3 right)
|
|
{
|
|
return left.LengthSquared < right.LengthSquared ? left : right;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Max
|
|
|
|
/// <summary>
|
|
/// Returns the Vector3 with the minimum magnitude
|
|
/// </summary>
|
|
/// <param name="left">Left operand</param>
|
|
/// <param name="right">Right operand</param>
|
|
/// <returns>The minimum Vector3</returns>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static Vector3 Max(Vector3 left, Vector3 right)
|
|
{
|
|
return left.LengthSquared >= right.LengthSquared ? left : right;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Clamp
|
|
|
|
/// <summary>
|
|
/// Clamp a vector to the given minimum and maximum vectors
|
|
/// </summary>
|
|
/// <param name="vec">Input vector</param>
|
|
/// <param name="min">Minimum vector</param>
|
|
/// <param name="max">Maximum vector</param>
|
|
/// <returns>The clamped vector</returns>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static Vector3 Clamp(Vector3 vec, Vector3 min, Vector3 max)
|
|
{
|
|
vec.X = MathF.Clamp(vec.X, min.X, max.X);
|
|
vec.Y = MathF.Clamp(vec.Y, min.Y, max.Y);
|
|
vec.Z = MathF.Clamp(vec.Z, min.Z, max.Z);
|
|
return vec;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Clamp a vector to the given minimum and maximum vectors
|
|
/// </summary>
|
|
/// <param name="vec">Input vector</param>
|
|
/// <param name="min">Minimum vector</param>
|
|
/// <param name="max">Maximum vector</param>
|
|
/// <param name="result">The clamped vector</param>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static void Clamp(ref Vector3 vec, ref Vector3 min, ref Vector3 max, out Vector3 result)
|
|
{
|
|
result.X = MathF.Clamp(vec.X, min.X, max.X);
|
|
result.Y = MathF.Clamp(vec.Y, min.Y, max.Y);
|
|
result.Z = MathF.Clamp(vec.Z, min.Z, max.Z);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Normalize
|
|
|
|
/// <summary>
|
|
/// Scale a vector to unit length
|
|
/// </summary>
|
|
/// <param name="vec">The input vector</param>
|
|
/// <returns>The normalized vector</returns>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static Vector3 Normalize(Vector3 vec)
|
|
{
|
|
var scale = 1.0f / vec.Length;
|
|
vec.X *= scale;
|
|
vec.Y *= scale;
|
|
vec.Z *= scale;
|
|
return vec;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Scale a vector to unit length
|
|
/// </summary>
|
|
/// <param name="vec">The input vector</param>
|
|
/// <param name="result">The normalized vector</param>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static void Normalize(ref Vector3 vec, out Vector3 result)
|
|
{
|
|
var scale = 1.0f / vec.Length;
|
|
result.X = vec.X * scale;
|
|
result.Y = vec.Y * scale;
|
|
result.Z = vec.Z * scale;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Dot
|
|
|
|
/// <summary>
|
|
/// Calculate the dot (scalar) product of two vectors
|
|
/// </summary>
|
|
/// <param name="left">First operand</param>
|
|
/// <param name="right">Second operand</param>
|
|
/// <returns>The dot product of the two inputs</returns>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static float Dot(Vector3 left, Vector3 right)
|
|
{
|
|
return left.X * right.X + left.Y * right.Y + left.Z * right.Z;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Calculate the dot (scalar) product of two vectors
|
|
/// </summary>
|
|
/// <param name="left">First operand</param>
|
|
/// <param name="right">Second operand</param>
|
|
/// <param name="result">The dot product of the two inputs</param>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static void Dot(ref Vector3 left, ref Vector3 right, out float result)
|
|
{
|
|
result = left.X * right.X + left.Y * right.Y + left.Z * right.Z;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Cross
|
|
|
|
/// <summary>
|
|
/// Caclulate the cross (vector) product of two vectors
|
|
/// </summary>
|
|
/// <param name="left">First operand</param>
|
|
/// <param name="right">Second operand</param>
|
|
/// <returns>The cross product of the two inputs</returns>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static Vector3 Cross(Vector3 left, Vector3 right)
|
|
{
|
|
Cross(ref left, ref right, out var result);
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Caclulate the cross (vector) product of two vectors
|
|
/// </summary>
|
|
/// <param name="left">First operand</param>
|
|
/// <param name="right">Second operand</param>
|
|
/// <returns>The cross product of the two inputs</returns>
|
|
/// <param name="result">The cross product of the two inputs</param>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static void Cross(ref Vector3 left, ref Vector3 right, out Vector3 result)
|
|
{
|
|
result = new Vector3(left.Y * right.Z - left.Z * right.Y,
|
|
left.Z * right.X - left.X * right.Z,
|
|
left.X * right.Y - left.Y * right.X);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Lerp
|
|
|
|
/// <summary>
|
|
/// Returns a new Vector that is the linear blend of the 2 given Vectors
|
|
/// </summary>
|
|
/// <param name="a">First input vector</param>
|
|
/// <param name="b">Second input vector</param>
|
|
/// <param name="blend">The blend factor. a when blend=0, b when blend=1.</param>
|
|
/// <returns>a when blend=0, b when blend=1, and a linear combination otherwise</returns>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static Vector3 Lerp(Vector3 a, Vector3 b, float blend)
|
|
{
|
|
a.X = MathF.Interpolate(a.X, b.X, blend);
|
|
a.Y = MathF.Interpolate(a.Y, b.Y, blend);
|
|
a.Z = MathF.Interpolate(a.Z, b.Z, blend);
|
|
return a;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a new Vector that is the linear blend of the 2 given Vectors
|
|
/// </summary>
|
|
/// <param name="a">First input vector</param>
|
|
/// <param name="b">Second input vector</param>
|
|
/// <param name="blend">The blend factor. a when blend=0, b when blend=1.</param>
|
|
/// <param name="result">a when blend=0, b when blend=1, and a linear combination otherwise</param>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static void Lerp(ref Vector3 a, ref Vector3 b, float blend, out Vector3 result)
|
|
{
|
|
result.X = MathF.Interpolate(a.X, b.X, blend);
|
|
result.Y = MathF.Interpolate(a.Y, b.Y, blend);
|
|
result.Z = MathF.Interpolate(a.Z, b.Z, blend);
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static Vector3 InterpolateCubic(Vector3 preA, Vector3 a, Vector3 b, Vector3 postB, float t)
|
|
{
|
|
return a +
|
|
(b - preA + (preA * 2.0f - a * 5.0f + b * 4.0f - postB + ((a - b) * 3.0f + postB - preA) * t) * t) *
|
|
t * 0.5f;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Barycentric
|
|
|
|
/// <summary>
|
|
/// Interpolate 3 Vectors using Barycentric coordinates
|
|
/// </summary>
|
|
/// <param name="a">First input Vector</param>
|
|
/// <param name="b">Second input Vector</param>
|
|
/// <param name="c">Third input Vector</param>
|
|
/// <param name="u">First Barycentric Coordinate</param>
|
|
/// <param name="v">Second Barycentric Coordinate</param>
|
|
/// <returns>a when u=v=0, b when u=1,v=0, c when u=0,v=1, and a linear combination of a,b,c otherwise</returns>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static Vector3 BaryCentric(Vector3 a, Vector3 b, Vector3 c, float u, float v)
|
|
{
|
|
return a + u * (b - a) + v * (c - a);
|
|
}
|
|
|
|
/// <summary>Interpolate 3 Vectors using Barycentric coordinates</summary>
|
|
/// <param name="a">First input Vector.</param>
|
|
/// <param name="b">Second input Vector.</param>
|
|
/// <param name="c">Third input Vector.</param>
|
|
/// <param name="u">First Barycentric Coordinate.</param>
|
|
/// <param name="v">Second Barycentric Coordinate.</param>
|
|
/// <param name="result">Output Vector. a when u=v=0, b when u=1,v=0, c when u=0,v=1, and a linear combination of a,b,c otherwise</param>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static void BaryCentric(ref Vector3 a, ref Vector3 b, ref Vector3 c, float u, float v, out Vector3 result)
|
|
{
|
|
result = a; // copy
|
|
|
|
var temp = b; // copy
|
|
Subtract(ref temp, ref a, out temp);
|
|
Multiply(ref temp, u, out temp);
|
|
Add(ref result, ref temp, out result);
|
|
|
|
temp = c; // copy
|
|
Subtract(ref temp, ref a, out temp);
|
|
Multiply(ref temp, v, out temp);
|
|
Add(ref result, ref temp, out result);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Transform
|
|
|
|
/// <summary>Transform a direction vector by the given Matrix
|
|
/// Assumes the matrix has a bottom row of (0,0,0,1), that is the translation part is ignored.
|
|
/// </summary>
|
|
/// <param name="vec">The vector to transform</param>
|
|
/// <param name="mat">The desired transformation</param>
|
|
/// <returns>The transformed vector</returns>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static Vector3 TransformVector(Vector3 vec, Matrix4 mat)
|
|
{
|
|
Vector3 v;
|
|
v.X = Dot(vec, new Vector3(mat.Column0));
|
|
v.Y = Dot(vec, new Vector3(mat.Column1));
|
|
v.Z = Dot(vec, new Vector3(mat.Column2));
|
|
return v;
|
|
}
|
|
|
|
/// <summary>Transform a direction vector by the given Matrix
|
|
/// Assumes the matrix has a bottom row of (0,0,0,1), that is the translation part is ignored.
|
|
/// </summary>
|
|
/// <param name="vec">The vector to transform</param>
|
|
/// <param name="mat">The desired transformation</param>
|
|
/// <param name="result">The transformed vector</param>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static void TransformVector(ref Vector3 vec, ref Matrix4 mat, out Vector3 result)
|
|
{
|
|
result.X = vec.X * mat.Row0.X +
|
|
vec.Y * mat.Row1.X +
|
|
vec.Z * mat.Row2.X;
|
|
|
|
result.Y = vec.X * mat.Row0.Y +
|
|
vec.Y * mat.Row1.Y +
|
|
vec.Z * mat.Row2.Y;
|
|
|
|
result.Z = vec.X * mat.Row0.Z +
|
|
vec.Y * mat.Row1.Z +
|
|
vec.Z * mat.Row2.Z;
|
|
}
|
|
|
|
/// <summary>Transform a Normal by the given Matrix</summary>
|
|
/// <remarks>
|
|
/// This calculates the inverse of the given matrix, use TransformNormalInverse if you
|
|
/// already have the inverse to avoid this extra calculation
|
|
/// </remarks>
|
|
/// <param name="norm">The normal to transform</param>
|
|
/// <param name="mat">The desired transformation</param>
|
|
/// <returns>The transformed normal</returns>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static Vector3 TransformNormal(Vector3 norm, Matrix4 mat)
|
|
{
|
|
mat.Invert();
|
|
return TransformNormalInverse(norm, mat);
|
|
}
|
|
|
|
/// <summary>Transform a Normal by the given Matrix</summary>
|
|
/// <remarks>
|
|
/// This calculates the inverse of the given matrix, use TransformNormalInverse if you
|
|
/// already have the inverse to avoid this extra calculation
|
|
/// </remarks>
|
|
/// <param name="norm">The normal to transform</param>
|
|
/// <param name="mat">The desired transformation</param>
|
|
/// <param name="result">The transformed normal</param>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static void TransformNormal(ref Vector3 norm, ref Matrix4 mat, out Vector3 result)
|
|
{
|
|
var inverse = Matrix4.Invert(mat);
|
|
TransformNormalInverse(ref norm, ref inverse, out result);
|
|
}
|
|
|
|
/// <summary>Transform a Normal by the (transpose of the) given Matrix</summary>
|
|
/// <remarks>
|
|
/// This version doesn't calculate the inverse matrix.
|
|
/// Use this version if you already have the inverse of the desired transform to hand
|
|
/// </remarks>
|
|
/// <param name="norm">The normal to transform</param>
|
|
/// <param name="invMat">The inverse of the desired transformation</param>
|
|
/// <returns>The transformed normal</returns>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static Vector3 TransformNormalInverse(Vector3 norm, Matrix4 invMat)
|
|
{
|
|
Vector3 n;
|
|
n.X = Dot(norm, new Vector3(invMat.Row0));
|
|
n.Y = Dot(norm, new Vector3(invMat.Row1));
|
|
n.Z = Dot(norm, new Vector3(invMat.Row2));
|
|
return n;
|
|
}
|
|
|
|
/// <summary>Transform a Normal by the (transpose of the) given Matrix</summary>
|
|
/// <remarks>
|
|
/// This version doesn't calculate the inverse matrix.
|
|
/// Use this version if you already have the inverse of the desired transform to hand
|
|
/// </remarks>
|
|
/// <param name="norm">The normal to transform</param>
|
|
/// <param name="invMat">The inverse of the desired transformation</param>
|
|
/// <param name="result">The transformed normal</param>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static void TransformNormalInverse(ref Vector3 norm, ref Matrix4 invMat, out Vector3 result)
|
|
{
|
|
result.X = norm.X * invMat.Row0.X +
|
|
norm.Y * invMat.Row0.Y +
|
|
norm.Z * invMat.Row0.Z;
|
|
|
|
result.Y = norm.X * invMat.Row1.X +
|
|
norm.Y * invMat.Row1.Y +
|
|
norm.Z * invMat.Row1.Z;
|
|
|
|
result.Z = norm.X * invMat.Row2.X +
|
|
norm.Y * invMat.Row2.Y +
|
|
norm.Z * invMat.Row2.Z;
|
|
}
|
|
|
|
/// <summary>Transform a Position by the given Matrix</summary>
|
|
/// <param name="pos">The position to transform</param>
|
|
/// <param name="mat">The desired transformation</param>
|
|
/// <returns>The transformed position</returns>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static Vector3 TransformPosition(Vector3 pos, Matrix4 mat)
|
|
{
|
|
Vector3 p;
|
|
p.X = Dot(pos, new Vector3(mat.Column0)) + mat.Row3.X;
|
|
p.Y = Dot(pos, new Vector3(mat.Column1)) + mat.Row3.Y;
|
|
p.Z = Dot(pos, new Vector3(mat.Column2)) + mat.Row3.Z;
|
|
return p;
|
|
}
|
|
|
|
/// <summary>Transform a Position by the given Matrix</summary>
|
|
/// <param name="pos">The position to transform</param>
|
|
/// <param name="mat">The desired transformation</param>
|
|
/// <param name="result">The transformed position</param>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static void TransformPosition(ref Vector3 pos, ref Matrix4 mat, out Vector3 result)
|
|
{
|
|
result.X = pos.X * mat.Row0.X +
|
|
pos.Y * mat.Row1.X +
|
|
pos.Z * mat.Row2.X +
|
|
mat.Row3.X;
|
|
|
|
result.Y = pos.X * mat.Row0.Y +
|
|
pos.Y * mat.Row1.Y +
|
|
pos.Z * mat.Row2.Y +
|
|
mat.Row3.Y;
|
|
|
|
result.Z = pos.X * mat.Row0.Z +
|
|
pos.Y * mat.Row1.Z +
|
|
pos.Z * mat.Row2.Z +
|
|
mat.Row3.Z;
|
|
}
|
|
|
|
/// <summary>Transform a Vector by the given Matrix</summary>
|
|
/// <param name="vec">The vector to transform</param>
|
|
/// <param name="mat">The desired transformation</param>
|
|
/// <returns>The transformed vector</returns>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static Vector3 Transform(Vector3 vec, Matrix4 mat)
|
|
{
|
|
Transform(ref vec, ref mat, out Vector3 result);
|
|
return result;
|
|
}
|
|
|
|
/// <summary>Transform a Vector by the given Matrix</summary>
|
|
/// <param name="vec">The vector to transform</param>
|
|
/// <param name="mat">The desired transformation</param>
|
|
/// <param name="result">The transformed vector</param>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static void Transform(ref Vector3 vec, ref Matrix4 mat, out Vector4 result)
|
|
{
|
|
var v4 = new Vector4(vec.X, vec.Y, vec.Z, 1.0f);
|
|
Vector4.Transform(ref v4, ref mat, out result);
|
|
}
|
|
|
|
/// <summary>Transform a Vector by the given Matrix</summary>
|
|
/// <param name="vec">The vector to transform</param>
|
|
/// <param name="mat">The desired transformation</param>
|
|
/// <param name="result">The transformed vector</param>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static void Transform(ref Vector3 vec, ref Matrix4 mat, out Vector3 result)
|
|
{
|
|
var v4 = new Vector4(vec.X, vec.Y, vec.Z, 1.0f);
|
|
Vector4.Transform(ref v4, ref mat, out v4);
|
|
result = v4.Xyz;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Transforms a vector by a quaternion rotation.
|
|
/// </summary>
|
|
/// <param name="vec">The vector to transform.</param>
|
|
/// <param name="quat">The quaternion to rotate the vector by.</param>
|
|
/// <returns>The result of the operation.</returns>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static Vector3 Transform(Vector3 vec, Quaternion quat)
|
|
{
|
|
Transform(ref vec, ref quat, out var result);
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Transforms a vector by a quaternion rotation.
|
|
/// </summary>
|
|
/// <param name="vec">The vector to transform.</param>
|
|
/// <param name="quat">The quaternion to rotate the vector by.</param>
|
|
/// <param name="result">The result of the operation.</param>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static void Transform(ref Vector3 vec, ref Quaternion quat, out Vector3 result)
|
|
{
|
|
// Since vec.W == 0, we can optimize quat * vec * quat^-1 as follows:
|
|
// vec + 2.0 * cross(quat.xyz, cross(quat.xyz, vec) + quat.w * vec)
|
|
var xyz = quat.Xyz;
|
|
Cross(ref xyz, ref vec, out var temp);
|
|
Multiply(ref vec, quat.W, out var temp2);
|
|
Add(ref temp, ref temp2, out temp);
|
|
Cross(ref xyz, ref temp, out temp);
|
|
Multiply(ref temp, 2, out temp);
|
|
Add(ref vec, ref temp, out result);
|
|
}
|
|
|
|
/// <summary>Transform a Vector3 by the given Matrix, and project the resulting Vector4 back to a Vector3</summary>
|
|
/// <param name="vec">The vector to transform</param>
|
|
/// <param name="mat">The desired transformation</param>
|
|
/// <returns>The transformed vector</returns>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static Vector3 TransformPerspective(Vector3 vec, Matrix4 mat)
|
|
{
|
|
TransformPerspective(ref vec, ref mat, out var result);
|
|
return result;
|
|
}
|
|
|
|
/// <summary>Transform a Vector3 by the given Matrix, and project the resulting Vector4 back to a Vector3</summary>
|
|
/// <param name="vec">The vector to transform</param>
|
|
/// <param name="mat">The desired transformation</param>
|
|
/// <param name="result">The transformed vector</param>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static void TransformPerspective(ref Vector3 vec, ref Matrix4 mat, out Vector3 result)
|
|
{
|
|
var v = new Vector4(vec, 1);
|
|
Vector4.Transform(ref v, ref mat, out v);
|
|
result.X = v.X / v.W;
|
|
result.Y = v.Y / v.W;
|
|
result.Z = v.Z / v.W;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region CalculateAngle
|
|
|
|
/// <summary>
|
|
/// Calculates the angle (in radians) between two vectors.
|
|
/// </summary>
|
|
/// <param name="first">The first vector.</param>
|
|
/// <param name="second">The second vector.</param>
|
|
/// <returns>Angle (in radians) between the vectors.</returns>
|
|
/// <remarks>Note that the returned angle is never bigger than the constant Pi.</remarks>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static float CalculateAngle(Vector3 first, Vector3 second)
|
|
{
|
|
return (float) MathF.Acos(Dot(first, second) / (first.Length * second.Length));
|
|
}
|
|
|
|
/// <summary>Calculates the angle (in radians) between two vectors.</summary>
|
|
/// <param name="first">The first vector.</param>
|
|
/// <param name="second">The second vector.</param>
|
|
/// <param name="result">Angle (in radians) between the vectors.</param>
|
|
/// <remarks>Note that the returned angle is never bigger than the constant Pi.</remarks>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static void CalculateAngle(ref Vector3 first, ref Vector3 second, out float result)
|
|
{
|
|
Dot(ref first, ref second, out var temp);
|
|
result = (float) MathF.Acos(temp / (first.Length * second.Length));
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region Swizzle
|
|
|
|
/// <summary>
|
|
/// Gets or sets an OpenTK.Vector2 with the X and Y components of this instance.
|
|
/// </summary>
|
|
[XmlIgnore]
|
|
public Vector2 Xy
|
|
{
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
get => new Vector2(X, Y);
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
set
|
|
{
|
|
X = value.X;
|
|
Y = value.Y;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Operators
|
|
|
|
/// <summary>
|
|
/// Adds two instances.
|
|
/// </summary>
|
|
/// <param name="left">The first instance.</param>
|
|
/// <param name="right">The second instance.</param>
|
|
/// <returns>The result of the calculation.</returns>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static Vector3 operator +(Vector3 left, Vector3 right)
|
|
{
|
|
left.X += right.X;
|
|
left.Y += right.Y;
|
|
left.Z += right.Z;
|
|
return left;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Subtracts two instances.
|
|
/// </summary>
|
|
/// <param name="left">The first instance.</param>
|
|
/// <param name="right">The second instance.</param>
|
|
/// <returns>The result of the calculation.</returns>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static Vector3 operator -(Vector3 left, Vector3 right)
|
|
{
|
|
left.X -= right.X;
|
|
left.Y -= right.Y;
|
|
left.Z -= right.Z;
|
|
return left;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Negates an instance.
|
|
/// </summary>
|
|
/// <param name="vec">The instance.</param>
|
|
/// <returns>The result of the calculation.</returns>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static Vector3 operator -(Vector3 vec)
|
|
{
|
|
vec.X = -vec.X;
|
|
vec.Y = -vec.Y;
|
|
vec.Z = -vec.Z;
|
|
return vec;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Multiplies an instance by a scalar.
|
|
/// </summary>
|
|
/// <param name="vec">The instance.</param>
|
|
/// <param name="scale">The scalar.</param>
|
|
/// <returns>The result of the calculation.</returns>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static Vector3 operator *(Vector3 vec, float scale)
|
|
{
|
|
vec.X *= scale;
|
|
vec.Y *= scale;
|
|
vec.Z *= scale;
|
|
return vec;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Multiplies an instance by a scalar.
|
|
/// </summary>
|
|
/// <param name="scale">The scalar.</param>
|
|
/// <param name="vec">The instance.</param>
|
|
/// <returns>The result of the calculation.</returns>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static Vector3 operator *(float scale, Vector3 vec)
|
|
{
|
|
vec.X *= scale;
|
|
vec.Y *= scale;
|
|
vec.Z *= scale;
|
|
return vec;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Component wise multiply two vectors.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static Vector3 operator *(Vector3 a, Vector3 b)
|
|
{
|
|
return new Vector3(a.X * b.X, a.Y * b.Y, a.Z * b.Z);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Divides an instance by a scalar.
|
|
/// </summary>
|
|
/// <param name="vec">The instance.</param>
|
|
/// <param name="scale">The scalar.</param>
|
|
/// <returns>The result of the calculation.</returns>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static Vector3 operator /(Vector3 vec, float scale)
|
|
{
|
|
var mult = 1.0f / scale;
|
|
vec.X *= mult;
|
|
vec.Y *= mult;
|
|
vec.Z *= mult;
|
|
return vec;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Compares two instances for equality.
|
|
/// </summary>
|
|
/// <param name="left">The first instance.</param>
|
|
/// <param name="right">The second instance.</param>
|
|
/// <returns>True, if left equals right; false otherwise.</returns>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static bool operator ==(Vector3 left, Vector3 right)
|
|
{
|
|
return left.Equals(right);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Compares two instances for inequality.
|
|
/// </summary>
|
|
/// <param name="left">The first instance.</param>
|
|
/// <param name="right">The second instance.</param>
|
|
/// <returns>True, if left does not equa lright; false otherwise.</returns>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static bool operator !=(Vector3 left, Vector3 right)
|
|
{
|
|
return !left.Equals(right);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Overrides
|
|
|
|
#region public override string ToString()
|
|
|
|
/// <summary>
|
|
/// Returns a System.String that represents the current Vector3.
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public override string ToString()
|
|
{
|
|
return $"({X}, {Y}, {Z})";
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region public override int GetHashCode()
|
|
|
|
/// <summary>
|
|
/// Returns the hashcode for this instance.
|
|
/// </summary>
|
|
/// <returns>A System.Int32 containing the unique hashcode for this instance.</returns>
|
|
public override int GetHashCode()
|
|
{
|
|
return X.GetHashCode() ^ Y.GetHashCode() ^ Z.GetHashCode();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region public override bool Equals(object obj)
|
|
|
|
/// <summary>
|
|
/// Indicates whether this instance and a specified object are equal.
|
|
/// </summary>
|
|
/// <param name="obj">The object to compare to.</param>
|
|
/// <returns>True if the instances are equal; false otherwise.</returns>
|
|
public override bool Equals(object? obj)
|
|
{
|
|
if (!(obj is Vector3))
|
|
return false;
|
|
|
|
return Equals((Vector3) obj);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region IEquatable<Vector3> Members
|
|
|
|
/// <summary>Indicates whether the current vector is equal to another vector.</summary>
|
|
/// <param name="other">A vector to compare with this vector.</param>
|
|
/// <returns>true if the current vector is equal to the vector parameter; otherwise, false.</returns>
|
|
public bool Equals(Vector3 other)
|
|
{
|
|
return
|
|
X == other.X &&
|
|
Y == other.Y &&
|
|
Z == other.Z;
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|