diff --git a/Engine.Core/Primitives/AABB.cs b/Engine.Core/Primitives/AABB.cs
index cbf60a5..7e6e3c8 100644
--- a/Engine.Core/Primitives/AABB.cs
+++ b/Engine.Core/Primitives/AABB.cs
@@ -75,8 +75,8 @@ public readonly struct AABB(Vector2D lowerBoundary, Vector2D upperBoundary)
     /// <param name="left">The first <see cref="AABB"/>.</param>
     /// <param name="right">The second <see cref="AABB"/>.</param>
     /// <returns><see cref="true"/> if the <see cref="AABB"/>s are approximately equal; otherwise, <see cref="false"/>.</returns>
-    public static bool ApproximatelyEquals(AABB left, AABB right)
-        => left.LowerBoundary.ApproximatelyEquals(right.LowerBoundary) && left.UpperBoundary.ApproximatelyEquals(right.UpperBoundary);
+    public static bool ApproximatelyEquals(AABB left, AABB right, float epsilon = float.Epsilon)
+        => left.LowerBoundary.ApproximatelyEquals(right.LowerBoundary, epsilon) && left.UpperBoundary.ApproximatelyEquals(right.UpperBoundary, epsilon);
 }
 
 /// <summary>
@@ -91,11 +91,5 @@ public static class AABBExtensions
     /// <returns>An <see cref="AABB"/> that bounds all the <see cref="Vector2D"/>s.</returns>
     public static AABB ToAABB(this IEnumerable<Vector2D> vectors) => AABB.FromVectors(vectors);
 
-    /// <summary>
-    /// Checks if two <see cref="AABB"/>s are approximately equal.
-    /// </summary>
-    /// <param name="left">The first <see cref="AABB"/>.</param>
-    /// <param name="right">The second <see cref="AABB"/>.</param>
-    /// <returns><see cref="true"/> if the <see cref="AABB"/>s are approximately equal; otherwise, <see cref="false"/>.</returns>
-    public static bool ApproximatelyEquals(this AABB left, AABB right) => AABB.ApproximatelyEquals(left, right);
+    public static bool ApproximatelyEquals(this AABB left, AABB right, float epsilon = float.Epsilon) => AABB.ApproximatelyEquals(left, right, epsilon);
 }
diff --git a/Engine.Core/Primitives/Circle.cs b/Engine.Core/Primitives/Circle.cs
index 1833a65..780fd64 100644
--- a/Engine.Core/Primitives/Circle.cs
+++ b/Engine.Core/Primitives/Circle.cs
@@ -72,8 +72,8 @@ public readonly struct Circle(Vector2D center, float radius)
     /// <summary>
     /// Checks if two <see cref="Circle"/>s are approximately equal.
     /// </summary>
-    public static bool ApproximatelyEquals(Circle left, Circle right)
-        => left.Center.ApproximatelyEquals(right.Center) && left.Radius.ApproximatelyEquals(right.Radius);
+    public static bool ApproximatelyEquals(Circle left, Circle right, float epsilon = float.Epsilon)
+        => left.Center.ApproximatelyEquals(right.Center, epsilon) && left.Radius.ApproximatelyEquals(right.Radius, epsilon);
 }
 
 /// <summary>
@@ -106,8 +106,5 @@ public static class CircleExtensions
     /// </summary>
     public static Circle TransformCircle(this ITransform transform, Circle circle) => Circle.TransformCircle(transform, circle);
 
-    /// <summary>
-    /// Checks if two <see cref="Circle"/>s are approximately equal.
-    /// </summary>
-    public static bool ApproximatelyEquals(this Circle left, Circle right) => Circle.ApproximatelyEquals(left, right);
+    public static bool ApproximatelyEquals(this Circle left, Circle right, float epsilon = float.Epsilon) => Circle.ApproximatelyEquals(left, right, epsilon);
 }
diff --git a/Engine.Core/Primitives/Line2D.cs b/Engine.Core/Primitives/Line2D.cs
index 0a11de2..d2b776c 100644
--- a/Engine.Core/Primitives/Line2D.cs
+++ b/Engine.Core/Primitives/Line2D.cs
@@ -184,8 +184,8 @@ public readonly struct Line2D(Vector2D from, Vector2D to)
     /// <summary>
     /// Checks if two <see cref="Line2D"/> segments are approximately equal.
     /// </summary>
-    public static bool ApproximatelyEquals(Line2D left, Line2D right)
-        => left.From.ApproximatelyEquals(right.From) && left.To.ApproximatelyEquals(right.To);
+    public static bool ApproximatelyEquals(Line2D left, Line2D right, float epsilon = float.Epsilon)
+        => left.From.ApproximatelyEquals(right.From, epsilon) && left.To.ApproximatelyEquals(right.To, epsilon);
 }
 
 /// <summary>
@@ -223,8 +223,5 @@ public static class Line2DExtensions
     /// </summary>
     public static bool Intersects(this Line2D left, Line2D right, [NotNullWhen(returnValue: true)] out Vector2D? point) => Line2D.Intersects(left, right, out point);
 
-    /// <summary>
-    /// Checks if two <see cref="Line2D"/>s are approximately equal.
-    /// </summary>
-    public static bool ApproximatelyEquals(this Line2D left, Line2D right) => Line2D.ApproximatelyEquals(left, right);
+    public static bool ApproximatelyEquals(this Line2D left, Line2D right, float epsilon = float.Epsilon) => Line2D.ApproximatelyEquals(left, right, epsilon);
 }
diff --git a/Engine.Core/Primitives/Line2DEquation.cs b/Engine.Core/Primitives/Line2DEquation.cs
index 20d33ab..24479e3 100644
--- a/Engine.Core/Primitives/Line2DEquation.cs
+++ b/Engine.Core/Primitives/Line2DEquation.cs
@@ -34,9 +34,10 @@ public readonly struct Line2DEquation(float slope, float offsetY)
     /// </summary>
     /// <param name="left">The first line equation to compare.</param>
     /// <param name="right">The second line equation to compare.</param>
+    /// <param name="epsilon">The epsilon range.</param>
     /// <returns>True if the line equations are approximately equal; otherwise, false.</returns>
-    public static bool ApproximatelyEquals(Line2DEquation left, Line2DEquation right)
-        => left.Slope.ApproximatelyEquals(right.Slope) && left.OffsetY.ApproximatelyEquals(right.OffsetY);
+    public static bool ApproximatelyEquals(Line2DEquation left, Line2DEquation right, float epsilon = float.Epsilon)
+        => left.Slope.ApproximatelyEquals(right.Slope, epsilon) && left.OffsetY.ApproximatelyEquals(right.OffsetY, epsilon);
 }
 
 /// <summary>
@@ -52,11 +53,5 @@ public static class Line2DEquationExtensions
     /// <returns>The y-coordinate resolved using the line equation.</returns>
     public static float Resolve(this Line2DEquation lineEquation, float x) => Line2DEquation.Resolve(lineEquation, x);
 
-    /// <summary>
-    /// Checks if two line equations are approximately equal.
-    /// </summary>
-    /// <param name="left">The first line equation to compare.</param>
-    /// <param name="right">The second line equation to compare.</param>
-    /// <returns>True if the line equations are approximately equal; otherwise, false.</returns>
-    public static bool ApproximatelyEquals(this Line2DEquation left, Line2DEquation right) => Line2DEquation.ApproximatelyEquals(left, right);
+    public static bool ApproximatelyEquals(this Line2DEquation left, Line2DEquation right, float epsilon = float.Epsilon) => Line2DEquation.ApproximatelyEquals(left, right, epsilon);
 }
diff --git a/Engine.Core/Primitives/Shape2D.cs b/Engine.Core/Primitives/Shape2D.cs
index 95d94df..a2c5433 100644
--- a/Engine.Core/Primitives/Shape2D.cs
+++ b/Engine.Core/Primitives/Shape2D.cs
@@ -198,13 +198,13 @@ public readonly struct Shape2D(List<Vector2D> vertices) : IEnumerable<Vector2D>
     /// <param name="left">The first shape to compare.</param>
     /// <param name="right">The second shape to compare.</param>
     /// <returns><c>true</c> if the shapes are approximately equal; otherwise, <c>false</c>.</returns>
-    public static bool ApproximatelyEquals(Shape2D left, Shape2D right)
+    public static bool ApproximatelyEquals(Shape2D left, Shape2D right, float epsilon = float.Epsilon)
     {
         if (left.Vertices.Count != right.Vertices.Count)
             return false;
 
         for (int i = 0; i < left.Vertices.Count; i++)
-            if (!left.Vertices[i].ApproximatelyEquals(right.Vertices[i]))
+            if (!left.Vertices[i].ApproximatelyEquals(right.Vertices[i], epsilon))
                 return false;
 
         return true;
@@ -282,11 +282,5 @@ public static class Shape2DExtensions
     /// <param name="to">The transformed shape.</param>
     public static void TransformShape(this ITransform transform, Shape2D from, ref Shape2D to) => Shape2D.TransformShape(from, transform, ref to);
 
-    /// <summary>
-    /// Determines whether two shapes are approximately equal.
-    /// </summary>
-    /// <param name="left">The first shape to compare.</param>
-    /// <param name="right">The second shape to compare.</param>
-    /// <returns><c>true</c> if the shapes are approximately equal; otherwise, <c>false</c>.</returns>
-    public static bool ApproximatelyEquals(this Shape2D left, Shape2D right) => Shape2D.ApproximatelyEquals(left, right);
+    public static bool ApproximatelyEquals(this Shape2D left, Shape2D right, float epsilon = float.Epsilon) => Shape2D.ApproximatelyEquals(left, right, epsilon);
 }
diff --git a/Engine.Core/Primitives/Triangle.cs b/Engine.Core/Primitives/Triangle.cs
index 8e3ce88..1dfbf2f 100644
--- a/Engine.Core/Primitives/Triangle.cs
+++ b/Engine.Core/Primitives/Triangle.cs
@@ -37,11 +37,11 @@ public readonly struct Triangle(Vector2D A, Vector2D B, Vector2D C)
         return new(center, Vector2D.Distance(center, triangle.A));
     }
 
-    public static bool ApproximatelyEquals(Triangle left, Triangle right)
-        => left.A.ApproximatelyEquals(right.A) && left.B.ApproximatelyEquals(right.B) && left.C.ApproximatelyEquals(right.C);
+    public static bool ApproximatelyEquals(Triangle left, Triangle right, float epsilon = float.Epsilon)
+        => left.A.ApproximatelyEquals(right.A, epsilon) && left.B.ApproximatelyEquals(right.B, epsilon) && left.C.ApproximatelyEquals(right.C, epsilon);
 }
 
 public static class TriangleExtensions
 {
-    public static bool ApproximatelyEquals(this Triangle left, Triangle right) => Triangle.ApproximatelyEquals(left, right);
+    public static bool ApproximatelyEquals(this Triangle left, Triangle right, float epsilon = float.Epsilon) => Triangle.ApproximatelyEquals(left, right, epsilon);
 }