task: new features and refactoring (#28)

* feat: cleanup and refactor Fixed3x3 and Fixed4x4
- added world space translation methods to both
- refactored Fixed4x4 TRS method
- added SRT method to Fixed4x4

* feat: added new FixedCurve class

* feat: added FixedMath SmoothStep and CubicInterpolate methods

* chore: linting and restructuring

Author: mrdav30

src/FixedMathSharp/FixedMath.cs src/FixedMathSharp/Core/FixedMath.cssrc/FixedMathSharp/FixedMath.cs renamed to src/FixedMathSharp/Core/FixedMath.cs

@@ -248,6 +248,45 @@ public static Fixed64 FastMod(Fixed64 x, Fixed64 y)
             return Fixed64.FromRaw(x.m_rawValue % y.m_rawValue);
         }
 
+        /// <summary>
+        /// Performs a smooth step interpolation between two values.
+        /// </summary>
+        /// <remarks>
+        /// The interpolation follows a cubic Hermite curve where the function starts at `a`,
+        /// accelerates, and then decelerates towards `b`, ensuring smooth transitions.
+        /// </remarks>
+        /// <param name="a">The starting value.</param>
+        /// <param name="b">The ending value.</param>
+        /// <param name="t">A value between 0 and 1 that represents the interpolation factor.</param>
+        /// <returns>The interpolated value between `a` and `b`.</returns>
+        public static Fixed64 SmoothStep(Fixed64 a, Fixed64 b, Fixed64 t)
+        {
+            t = t * t * (Fixed64.Three - Fixed64.Two * t);
+            return LinearInterpolate(a, b, t);
+        }
+
+        /// <summary>
+        /// Performs a cubic Hermite interpolation between two points, using specified tangents.
+        /// </summary>
+        /// <remarks>
+        /// This method interpolates smoothly between `p0` and `p1` while considering the tangents `m0` and `m1`.
+        /// It is useful for animation curves and smooth motion transitions.
+        /// </remarks>
+        /// <param name="p0">The first point.</param>
+        /// <param name="p1">The second point.</param>
+        /// <param name="m0">The tangent (slope) at `p0`.</param>
+        /// <param name="m1">The tangent (slope) at `p1`.</param>
+        /// <param name="t">A value between 0 and 1 that represents the interpolation factor.</param>
+        /// <returns>The interpolated value between `p0` and `p1`.</returns>
+        public static Fixed64 CubicInterpolate(Fixed64 p0, Fixed64 p1, Fixed64 m0, Fixed64 m1, Fixed64 t)
+        {
+            Fixed64 t2 = t * t;
+            Fixed64 t3 = t2 * t;
+            return (Fixed64.Two * p0 - Fixed64.Two * p1 + m0 + m1) * t3
+                 + (-Fixed64.Three * p0 + Fixed64.Three * p1 - Fixed64.Two * m0 - m1) * t2
+                 + m0 * t + p0;
+        }
+
         /// <summary>
         /// Performs linear interpolation between two fixed-point values based on the interpolant t (0 greater or equal to `t` and less than or equal to 1).
         /// </summary>

src/FixedMathSharp/FixedTrigonometry.cs …FixedMathSharp/Core/FixedTrigonometry.cssrc/FixedMathSharp/FixedTrigonometry.cs renamed to src/FixedMathSharp/Core/FixedTrigonometry.cs src/FixedMathSharp/FixedTrigonometry.cs renamed to src/FixedMathSharp/Core/FixedTrigonometry.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Runtime.CompilerServices;
-using System.Threading;
 
 namespace FixedMathSharp
 {

src/FixedMathSharp/Fixed3x3.Extensions.cs …hSharp/Extensions/Fixed3x3.Extensions.cssrc/FixedMathSharp/Fixed3x3.Extensions.cs renamed to src/FixedMathSharp/Extensions/Fixed3x3.Extensions.cs src/FixedMathSharp/Fixed3x3.Extensions.cs renamed to src/FixedMathSharp/Extensions/Fixed3x3.Extensions.cs

@@ -192,6 +192,32 @@ public static Fixed3x3 CreateShear(Fixed64 shX, Fixed64 shY, Fixed64 shZ)
             );
         }
 
+        /// <summary>
+        /// Creates a scaling matrix that applies a uniform or non-uniform scale transformation.
+        /// </summary>
+        /// <param name="scale">The scale factors along the X, Y, and Z axes.</param>
+        /// <returns>A 3x3 scaling matrix.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Fixed3x3 CreateScale(Vector3d scale)
+        {
+            return new Fixed3x3(
+                scale.x, Fixed64.Zero, Fixed64.Zero,
+                Fixed64.Zero, scale.y, Fixed64.Zero,
+                Fixed64.Zero, Fixed64.Zero, scale.z
+            );
+        }
+
+        /// <summary>
+        /// Creates a uniform scaling matrix with the same scale factor on all axes.
+        /// </summary>
+        /// <param name="scaleFactor">The uniform scale factor.</param>
+        /// <returns>A 3x3 scaling matrix with uniform scaling.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Fixed3x3 CreateScale(Fixed64 scaleFactor)
+        {
+            return CreateScale(new Vector3d(scaleFactor, scaleFactor, scaleFactor));
+        }
+
         /// <summary>
         /// Normalizes the basis vectors of a 3x3 matrix to ensure they are orthogonal and unit length.
         /// </summary>
@@ -317,7 +343,7 @@ public static Vector3d ExtractLossyScale(Fixed3x3 matrix)
 
         #endregion
 
-        #region Matrix Operations
+        #region Static Matrix Operations
 
         /// <summary>
         /// Linearly interpolates between two matrices.
@@ -380,11 +406,46 @@ public static bool Invert(Fixed3x3 matrix, out Fixed3x3? result)
             return true;
         }
 
+        /// <summary>
+        /// Transforms a direction vector from local space to world space using this transformation matrix.
+        /// Ignores translation.
+        /// </summary>
+        /// <param name="matrix">The transformation matrix.</param>
+        /// <param name="direction">The local-space direction vector.</param>
+        /// <returns>The transformed direction in world space.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Vector3d TransformDirection(Fixed3x3 matrix, Vector3d direction)
+        {
+            return new Vector3d(
+                matrix.m00 * direction.x + matrix.m01 * direction.y + matrix.m02 * direction.z,
+                matrix.m10 * direction.x + matrix.m11 * direction.y + matrix.m12 * direction.z,
+                matrix.m20 * direction.x + matrix.m21 * direction.y + matrix.m22 * direction.z
+            );
+        }
+
+        /// <summary>
+        /// Transforms a direction from world space into the local space of the matrix.
+        /// Ignores translation.
+        /// </summary>
+        /// <param name="matrix">The transformation matrix.</param>
+        /// <param name="direction">The world-space direction.</param>
+        /// <returns>The transformed local-space direction.</returns>
+        public static Vector3d InverseTransformDirection(Fixed3x3 matrix, Vector3d direction)
+        {
+            if (!Invert(matrix, out Fixed3x3? inverseMatrix) || !inverseMatrix.HasValue)
+                throw new InvalidOperationException("Matrix is not invertible.");
+
+            return new Vector3d(
+                inverseMatrix.Value.m00 * direction.x + inverseMatrix.Value.m01 * direction.y + inverseMatrix.Value.m02 * direction.z,
+                inverseMatrix.Value.m10 * direction.x + inverseMatrix.Value.m11 * direction.y + inverseMatrix.Value.m12 * direction.z,
+                inverseMatrix.Value.m20 * direction.x + inverseMatrix.Value.m21 * direction.y + inverseMatrix.Value.m22 * direction.z
+            );
+        }
+
         #endregion
 
         #region Operators
 
-
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Fixed3x3 operator -(Fixed3x3 a, Fixed3x3 b)
         {