chore: added missing public facing documentation, linted, and minor code cleanup

Author: mrdav30

src/FixedMathSharp/Bounds/BoundingArea.cs

@@ -89,6 +89,9 @@ public Vector3d Max
         get => new(MaxX, MaxY, MaxZ);
     }
 
+    /// <summary>
+    /// The minimum X coordinate of the bounding area.
+    /// </summary>
     [JsonIgnore]
     [MemoryPackIgnore]
     public Fixed64 MinX
@@ -97,6 +100,9 @@ public Fixed64 MinX
         get => Corner1.x < Corner2.x ? Corner1.x : Corner2.x;
     }
 
+    /// <summary>
+    /// Gets the greater X-coordinate value of the two corners that define the bounding area.
+    /// </summary>
     [JsonIgnore]
     [MemoryPackIgnore]
     public Fixed64 MaxX
@@ -105,6 +111,9 @@ public Fixed64 MaxX
         get => Corner1.x > Corner2.x ? Corner1.x : Corner2.x;
     }
 
+    /// <summary>
+    /// Gets the minimum Y-coordinate value of the bounding area defined by Corner1 and Corner2.
+    /// </summary>
     [JsonIgnore]
     [MemoryPackIgnore]
     public Fixed64 MinY
@@ -113,6 +122,9 @@ public Fixed64 MinY
         get => Corner1.y < Corner2.y ? Corner1.y : Corner2.y;
     }
 
+    /// <summary>
+    /// Gets the maximum Y-coordinate value of the bounding area defined by the two corners.
+    /// </summary>
     [JsonIgnore]
     [MemoryPackIgnore]
     public Fixed64 MaxY
@@ -121,6 +133,9 @@ public Fixed64 MaxY
         get => Corner1.y > Corner2.y ? Corner1.y : Corner2.y;
     }
 
+    /// <summary>
+    /// Gets the minimum Z coordinate value of the bounding volume.
+    /// </summary>
     [JsonIgnore]
     [MemoryPackIgnore]
     public Fixed64 MinZ
@@ -129,6 +144,9 @@ public Fixed64 MinZ
         get => Corner1.z < Corner2.z ? Corner1.z : Corner2.z;
     }
 
+    /// <summary>
+    /// Gets the maximum Z coordinate value between the two corners of the bounding box.
+    /// </summary>
     [JsonIgnore]
     [MemoryPackIgnore]
     public Fixed64 MaxZ
@@ -290,22 +308,37 @@ private static bool OverlapsOnAllAxes(Vector3d min, Vector3d max, Vector3d other
 
     #region Operators
 
+    /// <summary>
+    /// Determines whether two BoundingArea instances are equal.
+    /// </summary>
+    /// <param name="left">The first BoundingArea to compare.</param>
+    /// <param name="right">The second BoundingArea to compare.</param>
+    /// <returns>true if the specified BoundingArea instances are equal; otherwise, false.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator ==(BoundingArea left, BoundingArea right) => left.Equals(right);
 
+    /// <summary>
+    /// Determines whether two BoundingArea instances are not equal.
+    /// </summary>
+    /// <param name="left">The first BoundingArea to compare.</param>
+    /// <param name="right">The second BoundingArea to compare.</param>
+    /// <returns>true if the specified BoundingArea instances are not equal; otherwise, false.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(BoundingArea left, BoundingArea right) => !left.Equals(right);
 
     #endregion
 
     #region Equality and HashCode Overrides
 
+    /// <inheritdoc/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public override bool Equals(object? obj) => obj is BoundingArea other && Equals(other);
 
+    /// <inheritdoc/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public bool Equals(BoundingArea other) => Corner1.Equals(other.Corner1) && Corner2.Equals(other.Corner2);
 
+    /// <inheritdoc/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public override int GetHashCode()
     {

src/FixedMathSharp/Bounds/BoundingBox.cs

@@ -23,18 +23,31 @@ public partial struct BoundingBox : IBound, IEquatable<BoundingBox>
 {
     #region Nested Types
 
+    /// <summary>
+    /// Represents the state of a three-dimensional axis-aligned bounding box using its minimum and maximum coordinates.
+    /// </summary>
+    /// <remarks>
+    /// The bounding box is defined by two points: the minimum and maximum corners in 3D space. This
+    /// structure is immutable and can be used to describe spatial boundaries for geometric computations, collision
+    /// detection, or spatial queries.
+    /// </remarks>
     [Serializable]
     [MemoryPackable]
     public readonly partial struct BoundingBoxState
     {
+        /// <inheritdoc cref="BoundingBox.Min"/>
         [JsonInclude]
         [MemoryPackInclude]
         public readonly Vector3d Min;
 
+        /// <inheritdoc cref="BoundingBox.Max"/>
         [JsonInclude]
         [MemoryPackInclude]
         public readonly Vector3d Max;
 
+        /// <summary>
+        /// Initializes a new instance of the BoundingBoxState class with the specified minimum and maximum coordinates.
+        /// </summary>
         [JsonConstructor]
         public BoundingBoxState(Vector3d min, Vector3d max)
         {
@@ -73,6 +86,10 @@ public BoundingBox(Vector3d center, Vector3d size)
         _isDirty = true;
     }
 
+    /// <summary>
+    /// Initializes a new instance of the BoundingBox class with the specified bounding box state.
+    /// </summary>
+    /// <param name="state">The state that defines the position, size, and orientation of the bounding box.</param>
     [JsonConstructor]
     [MemoryPackConstructor]
     public BoundingBox(BoundingBoxState state)
@@ -160,6 +177,9 @@ public Vector3d[] Vertices
         get => GetOrGenerateVertices();
     }
 
+    /// <summary>
+    /// Gets or sets the current bounding box state, including its minimum and maximum coordinates.
+    /// </summary>
     [JsonInclude]
     [MemoryPackInclude]
     public BoundingBoxState State
@@ -457,18 +477,28 @@ public static Vector3d FindClosestPointsBetweenBoxes(BoundingBox a, BoundingBox
 
     #region Equality
 
+    /// <summary>
+    /// Determines whether two BoundingBox instances are equal.
+    /// </summary>
     public static bool operator ==(BoundingBox left, BoundingBox right) => left.Equals(right);
+
+    /// <summary>
+    /// Determines whether two BoundingBox instances are not equal.
+    /// </summary>
     public static bool operator !=(BoundingBox left, BoundingBox right) => !left.Equals(right);
 
     #endregion
 
     #region Equality and HashCode Overrides
 
+    /// <inheritdoc/>
     public override bool Equals(object? obj) => obj is BoundingBox other && Equals(other);
 
+    /// <inheritdoc/>
     public bool Equals(BoundingBox other)
         => Min.Equals(other.Min) && Max.Equals(other.Max);
 
+    /// <inheritdoc/>
     public override int GetHashCode()
     {
         return HashCode.Combine(Min, Max);

src/FixedMathSharp/Bounds/BoundingSphere.cs

@@ -55,6 +55,13 @@ public BoundingSphere(Vector3d center, Fixed64 radius)
 
         #region Properties
 
+        /// <summary>
+        /// Gets the coordinates of the minimum corner of the bounding box that contains the sphere.
+        /// </summary>
+        /// <remarks>
+        /// The minimum corner is calculated by subtracting the radius from each component of the sphere's center. 
+        /// This property is useful for spatial queries and bounding box calculations.
+        /// </remarks>
         [JsonIgnore]
         [MemoryPackIgnore]
         public Vector3d Min
@@ -63,6 +70,13 @@ public Vector3d Min
             get => Center - new Vector3d(Radius, Radius, Radius);
         }
 
+        /// <summary>
+        /// Gets the coordinates of the maximum corner of the bounding box that contains the sphere.
+        /// </summary>
+        /// <remarks>
+        /// The maximum corner is calculated as the center of the sphere plus the radius in each dimension. 
+        /// This property is useful for spatial queries and bounding volume calculations.
+        /// </remarks>
         [JsonIgnore]
         [MemoryPackIgnore]
         public Vector3d Max
@@ -146,22 +160,31 @@ public Fixed64 DistanceToSurface(Vector3d point)
 
         #region Operators
 
+        /// <summary>
+        /// Determines whether two BoundingSphere instances are equal.
+        /// </summary>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static bool operator ==(BoundingSphere left, BoundingSphere right) => left.Equals(right);
 
+        /// <summary>
+        /// Determines whether two BoundingSphere instances are not equal.
+        /// </summary>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static bool operator !=(BoundingSphere left, BoundingSphere right) => !left.Equals(right);
 
         #endregion
 
         #region Equality and HashCode Overrides
 
+        /// <inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public override bool Equals(object? obj) => obj is BoundingSphere other && Equals(other);
 
+        /// <inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public bool Equals(BoundingSphere other) => Center.Equals(other.Center) && Radius.Equals(other.Radius);
 
+        /// <inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public override int GetHashCode()
         {

src/FixedMathSharp/Bounds/IBound.cs

@@ -1,34 +1,43 @@
-namespace FixedMathSharp
+namespace FixedMathSharp;
+
+/// <summary>
+/// Defines an axis-aligned bounding volume in three-dimensional space and provides methods for containment,
+/// intersection, and projection operations.
+/// </summary>
+/// <remarks>
+/// Implementations of this interface represent a 3D region defined by minimum and maximum coordinates.
+/// The interface provides methods to determine whether a point is contained within the bounds, whether two bounds
+/// intersect, and to project a point onto the bounds. Typical use cases include spatial queries, collision detection,
+/// and geometric computations in 3D environments.
+/// </remarks>
+public interface IBound
 {
-    public interface IBound
-    {
-        /// <summary>
-        /// The minimum bounds of the IBound.
-        /// </summary>
-        Vector3d Min { get; }
+    /// <summary>
+    /// The minimum bounds of the IBound.
+    /// </summary>
+    Vector3d Min { get; }
 
-        /// <summary>
-        /// The maximum bounds of the IBound.
-        /// </summary>
-        Vector3d Max { get; }
+    /// <summary>
+    /// The maximum bounds of the IBound.
+    /// </summary>
+    Vector3d Max { get; }
 
-        /// <summary>
-        /// Checks if a point is inside the IBound.
-        /// </summary>
-        /// <param name="point">The point to check.</param>
-        /// <returns>True if the point is inside the IBound, otherwise false.</returns>
-        bool Contains(Vector3d point);
+    /// <summary>
+    /// Checks if a point is inside the IBound.
+    /// </summary>
+    /// <param name="point">The point to check.</param>
+    /// <returns>True if the point is inside the IBound, otherwise false.</returns>
+    bool Contains(Vector3d point);
 
-        /// <summary>
-        /// Checks if the IBound intersects with another IBound.
-        /// </summary>
-        /// <param name="other">The other IBound to check for intersection.</param>
-        /// <returns>True if the IBounds intersect, otherwise false.</returns>
-        bool Intersects(IBound other);
+    /// <summary>
+    /// Checks if the IBound intersects with another IBound.
+    /// </summary>
+    /// <param name="other">The other IBound to check for intersection.</param>
+    /// <returns>True if the IBounds intersect, otherwise false.</returns>
+    bool Intersects(IBound other);
 
-        /// <summary>
-        /// Projects a point onto the IBound. If the point is outside the IBound, it returns the closest point on the surface.
-        /// </summary>
-        Vector3d ProjectPoint(Vector3d point);
-    }
+    /// <summary>
+    /// Projects a point onto the IBound. If the point is outside the IBound, it returns the closest point on the surface.
+    /// </summary>
+    Vector3d ProjectPoint(Vector3d point);
 }

src/FixedMathSharp/Core/FixedMath.cs

@@ -11,19 +11,74 @@ public static partial class FixedMath
     {
         #region Fields and Constants
 
-        public const int NUM_BITS = 64;
+        /// <summary>
+        /// Represents the number of bits to shift for fixed-point representation.
+        /// </summary>
         public const int SHIFT_AMOUNT_I = 32;
+        /// <summary>
+        /// Represents the maximum value that can be produced by left-shifting 1 by SHIFT_AMOUNT_I bits and subtracting 1.
+        /// </summary>
+        /// <remarks>
+        /// This constant is typically used as a bitmask to extract or limit values to the range
+        /// defined by SHIFT_AMOUNT_I. 
+        /// The value is always non-negative and fits within a 32-bit unsigned
+        /// integer.
+        /// </remarks>
         public const uint MAX_SHIFTED_AMOUNT_UI = (uint)((1L << SHIFT_AMOUNT_I) - 1);
+        /// <summary>
+        /// Represents a bitmask with all bits set except for the lowest SHIFT_AMOUNT_I bits.
+        /// </summary>
+        /// <remarks>
+        /// This constant is typically used to isolate or clear the lower SHIFT_AMOUNT_I bits of
+        /// an unsigned 64-bit value. 
+        /// The value of SHIFT_AMOUNT_I determines how many least significant bits are masked out.
+        /// </remarks>
         public const ulong MASK_UL = (ulong)(ulong.MaxValue << SHIFT_AMOUNT_I);
 
-        public const long MAX_VALUE_L = long.MaxValue; // Max possible value for Fixed64
-        public const long MIN_VALUE_L = long.MinValue; // Min possible value for Fixed64
+        /// <summary>
+        /// Represents the largest possible value for a 64-bit fixed-point number.
+        /// </summary>
+        /// <remarks>
+        /// Use this constant to perform comparisons or to initialize variables that require the
+        /// maximum representable value for a 64-bit fixed-point type.
+        /// </remarks>
+        public const long MAX_VALUE_L = long.MaxValue;
+        /// <summary>
+        /// Represents the smallest possible value for a 64-bit fixed-point number.
+        /// </summary>
+        /// <remarks>
+        /// Use this constant to check for underflow conditions or to initialize variables that
+        /// require the minimum representable value for a 64-bit fixed-point type.
+        /// </remarks>
+        public const long MIN_VALUE_L = long.MinValue;
 
+        /// <summary>
+        /// Represents the value 1 shifted left by the number of bits specified by SHIFT_AMOUNT_I.
+        /// </summary>
         public const long ONE_L = 1L << SHIFT_AMOUNT_I;
 
         // Precomputed scale factors only for performance-critical scenarios to avoid division at runtime
+
+        /// <summary>
+        /// Represents the precomputed scale factor used for floating-point calculations.
+        /// </summary>
+        /// <remarks>
+        /// This constant is intended only for converting fixed-point values to floating-point representations in performance-critical scenarios.
+        /// </remarks>
         public const float SCALE_FACTOR_F = 1.0f / ONE_L;
+        /// <summary>
+        /// Represents the precomputed scale factor used for double-precision calculations.
+        /// </summary>
+        /// <remarks>
+        /// This constant is intended only for converting fixed-point values to double-precision representations in performance-critical scenarios.
+        /// </remarks>
         public const double SCALE_FACTOR_D = 1.0 / ONE_L;
+        /// <summary>
+        /// Represents the precomputed scale factor used for decimal calculations.
+        /// </summary>
+        /// <remarks>
+        /// This constant is intended only for converting fixed-point values to decimal representations in performance-critical scenarios.
+        /// </remarks>
         public const decimal SCALE_FACTOR_M = 1.0m / ONE_L;
 
         /// <summary>