Merge pull request #24 from mrdav30/develop

Develop to Main

Author: mrdav30

src/FixedMathSharp/Fixed64.cs

@@ -243,14 +243,23 @@ public static explicit operator decimal(Fixed64 value)
         }
 
         /// <summary>
-        /// Adds an int to a 
+        /// Adds an int to x 
         /// </summary>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Fixed64 operator +(Fixed64 x, int y)
         {
             return new Fixed64((x.m_rawValue * FixedMath.SCALE_FACTOR_D) + y);
         }
 
+        /// <summary>
+        /// Adds an int to y 
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Fixed64 operator +(int x, Fixed64 y)
+        {
+            return y + x;
+        }
+
         /// <summary>
         /// Subtracts one Fixed64 number from another, with saturating behavior in case of overflow.
         /// </summary>
@@ -266,14 +275,23 @@ public static explicit operator decimal(Fixed64 value)
         }
 
         /// <summary>
-        /// Subtracts an int from a 
+        /// Subtracts an int from x 
         /// </summary>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Fixed64 operator -(Fixed64 x, int y)
         {
             return new Fixed64((x.m_rawValue * FixedMath.SCALE_FACTOR_D) - y);
         }
 
+        /// <summary>
+        /// Subtracts an int from y 
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Fixed64 operator -(int x, Fixed64 y)
+        {
+            return y - x;
+        }
+
         /// <summary>
         /// Multiplies two Fixed64 numbers, handling overflow and rounding.
         /// </summary>

src/FixedMathSharp/Vector2d.Extensions.cs

@@ -46,6 +46,13 @@ public static Vector2d Abs(this Vector2d value)
             return Vector2d.Abs(value);
         }
 
+        /// <inheritdoc cref="Vector2d.Sign(Vector2d)" />
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Vector2d Sign(this Vector2d value)
+        {
+            return Vector2d.Sign(value);
+        }
+
         #endregion
 
         #region Conversion

src/FixedMathSharp/Vector2d.cs

@@ -24,8 +24,14 @@ public partial struct Vector2d : IEquatable<Vector2d>, IComparable<Vector2d>, IE
     {
         #region Fields and Constants
 
+        /// <summary>
+        /// The X component of the vector.
+        /// </summary>
         public Fixed64 x;
-        
+
+        /// <summary>
+        /// The Y component of the vector.
+        /// </summary>
         public Fixed64 y;
 
         /// <summary>
@@ -128,12 +134,16 @@ public Vector2d LeftHandNormal
             get => new Vector2d(y, -x);
         }
 
+        /// <inheritdoc cref="GetNormalized(Vector2d)"/>
         public Vector2d Normal
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             get => GetNormalized(this);
         }
 
+        /// <summary>
+        /// Returns the actual length of this vector (RO).
+        /// </summary>
         public Fixed64 Magnitude
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -234,6 +244,7 @@ public Vector2d AddInPlace(Fixed64 xAmount, Fixed64 yAmount)
             return this;
         }
 
+        /// <inheritdoc cref="AddInPlace(Fixed64, Fixed64)"/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public Vector2d AddInPlace(Vector2d other)
         {
@@ -515,12 +526,19 @@ public Fixed64 Dot(Vector2d other)
             return Dot(other.x, other.y);
         }
 
+        /// <summary>
+        /// Computes the cross product magnitude of this vector with another vector.
+        /// </summary>
+        /// <param name="otherX">The X component of the other vector.</param>
+        /// <param name="otherY">The Y component of the other vector.</param>
+        /// <returns>The cross product magnitude.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public Fixed64 CrossProduct(Fixed64 otherX, Fixed64 otherY)
         {
             return x * otherY - y * otherX;
         }
 
+        /// <inheritdoc cref="CrossProduct(Fixed64, Fixed64)"/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public Fixed64 CrossProduct(Vector2d other)
         {
@@ -607,12 +625,28 @@ public static Fixed64 GetMagnitude(Vector2d vector)
             return temp1.Abs() > Fixed64.Zero ? FixedMath.Sqrt(temp1) : Fixed64.Zero;
         }
 
+        /// <summary>
+        /// Returns a new <see cref="Vector2d"/> where each component is the absolute value of the corresponding input component.
+        /// </summary>
+        /// <param name="value">The input vector.</param>
+        /// <returns>A vector with absolute values for each component.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Vector2d Abs(Vector2d value)
         {
             return new Vector2d(value.x.Abs(), value.y.Abs());
         }
 
+        /// <summary>
+        /// Returns a new <see cref="Vector2d"/> where each component is the sign of the corresponding input component.
+        /// </summary>
+        /// <param name="value">The input vector.</param>
+        /// <returns>A vector where each component is -1, 0, or 1 based on the sign of the input.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Vector2d Sign(Vector2d value)
+        {
+            return new Vector2d(value.x.Sign(), value.y.Sign());
+        }
+
         /// <summary>
         /// Creates a vector from a given angle in radians.
         /// </summary>
@@ -633,6 +667,10 @@ public static Fixed64 Distance(Vector2d start, Vector2d end)
             return start.Distance(end);
         }
 
+        /// <summary>
+        /// Calculates the squared distance between two vectors, avoiding the need for a square root operation.
+        /// </summary>
+        /// <returns>The squared distance between the two vectors.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Fixed64 SqrDistance(Vector2d start, Vector2d end)
         {
@@ -712,6 +750,15 @@ public override string ToString()
             return $"({Math.Round((double)x, 2)}, {Math.Round((double)y, 2)})";
         }
 
+        /// <summary>
+        /// Converts this <see cref="Vector2d"/> to a <see cref="Vector3d"/>, 
+        /// mapping the Y component of this vector to the Z axis in the resulting vector.
+        /// </summary>
+        /// <param name="z">The value to assign to the Y axis of the resulting <see cref="Vector3d"/>.</param>
+        /// <returns>
+        /// A new <see cref="Vector3d"/> where (X, Y) from this <see cref="Vector2d"/> 
+        /// become (X, Z) in the resulting vector, with the provided Z parameter assigned to Y.
+        /// </returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public Vector3d ToVector3d(Fixed64 z)
         {

src/FixedMathSharp/Vector3d.Extensions.cs

@@ -71,6 +71,13 @@ public static Vector3d Abs(this Vector3d value)
             return Vector3d.Abs(value);
         }
 
+        /// <inheritdoc cref="Vector3d.Sign(Vector3d)" />
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Vector3d Sign(Vector3d value)
+        {
+            return Vector3d.Sign(value);
+        }
+
         #endregion
 
         #region Equality