Change inequality comparison operators to use exact equality

(cherry picked from commit d0a1399a1b7ef6b76f6e6094fb6dd6bd9b43d2c8)

core/math/vector2.h

@@ -116,10 +116,10 @@ struct Vector2 {
 	bool operator==(const Vector2 &p_vec2) const;
 	bool operator!=(const Vector2 &p_vec2) const;
 
-	bool operator<(const Vector2 &p_vec2) const { return Math::is_equal_approx(x, p_vec2.x) ? (y < p_vec2.y) : (x < p_vec2.x); }
-	bool operator>(const Vector2 &p_vec2) const { return Math::is_equal_approx(x, p_vec2.x) ? (y > p_vec2.y) : (x > p_vec2.x); }
-	bool operator<=(const Vector2 &p_vec2) const { return Math::is_equal_approx(x, p_vec2.x) ? (y <= p_vec2.y) : (x < p_vec2.x); }
-	bool operator>=(const Vector2 &p_vec2) const { return Math::is_equal_approx(x, p_vec2.x) ? (y >= p_vec2.y) : (x > p_vec2.x); }
+	bool operator<(const Vector2 &p_vec2) const { return x == p_vec2.x ? (y < p_vec2.y) : (x < p_vec2.x); }
+	bool operator>(const Vector2 &p_vec2) const { return x == p_vec2.x ? (y > p_vec2.y) : (x > p_vec2.x); }
+	bool operator<=(const Vector2 &p_vec2) const { return x == p_vec2.x ? (y <= p_vec2.y) : (x < p_vec2.x); }
+	bool operator>=(const Vector2 &p_vec2) const { return x == p_vec2.x ? (y >= p_vec2.y) : (x > p_vec2.x); }
 
 	real_t angle() const;
 

core/math/vector3.h

@@ -342,8 +342,8 @@ bool Vector3::operator!=(const Vector3 &p_v) const {
 
 bool Vector3::operator<(const Vector3 &p_v) const {
 
-	if (Math::is_equal_approx(x, p_v.x)) {
-		if (Math::is_equal_approx(y, p_v.y))
+	if (x == p_v.x) {
+		if (y == p_v.y)
 			return z < p_v.z;
 		else
 			return y < p_v.y;
@@ -354,8 +354,8 @@ bool Vector3::operator<(const Vector3 &p_v) const {
 
 bool Vector3::operator>(const Vector3 &p_v) const {
 
-	if (Math::is_equal_approx(x, p_v.x)) {
-		if (Math::is_equal_approx(y, p_v.y))
+	if (x == p_v.x) {
+		if (y == p_v.y)
 			return z > p_v.z;
 		else
 			return y > p_v.y;
@@ -366,8 +366,8 @@ bool Vector3::operator>(const Vector3 &p_v) const {
 
 bool Vector3::operator<=(const Vector3 &p_v) const {
 
-	if (Math::is_equal_approx(x, p_v.x)) {
-		if (Math::is_equal_approx(y, p_v.y))
+	if (x == p_v.x) {
+		if (y == p_v.y)
 			return z <= p_v.z;
 		else
 			return y < p_v.y;
@@ -378,8 +378,8 @@ bool Vector3::operator<=(const Vector3 &p_v) const {
 
 bool Vector3::operator>=(const Vector3 &p_v) const {
 
-	if (Math::is_equal_approx(x, p_v.x)) {
-		if (Math::is_equal_approx(y, p_v.y))
+	if (x == p_v.x) {
+		if (y == p_v.y)
 			return z >= p_v.z;
 		else
 			return y > p_v.y;

modules/mono/glue/GodotSharp/GodotSharp/Core/Vector2.cs

@@ -700,41 +700,37 @@ namespace Godot
 
         public static bool operator <(Vector2 left, Vector2 right)
         {
-            if (Mathf.IsEqualApprox(left.x, right.x))
+            if (left.x == right.x)
             {
                 return left.y < right.y;
             }
-
             return left.x < right.x;
         }
 
         public static bool operator >(Vector2 left, Vector2 right)
         {
-            if (Mathf.IsEqualApprox(left.x, right.x))
+            if (left.x == right.x)
             {
                 return left.y > right.y;
             }
-
             return left.x > right.x;
         }
 
         public static bool operator <=(Vector2 left, Vector2 right)
         {
-            if (Mathf.IsEqualApprox(left.x, right.x))
+            if (left.x == right.x)
             {
                 return left.y <= right.y;
             }
-
             return left.x <= right.x;
         }
 
         public static bool operator >=(Vector2 left, Vector2 right)
         {
-            if (Mathf.IsEqualApprox(left.x, right.x))
+            if (left.x == right.x)
             {
                 return left.y >= right.y;
             }
-
             return left.x >= right.x;
         }
 
@@ -744,7 +740,6 @@ namespace Godot
             {
                 return Equals((Vector2)obj);
             }
-
             return false;
         }
 

modules/mono/glue/GodotSharp/GodotSharp/Core/Vector3.cs

@@ -734,49 +734,53 @@ namespace Godot
 
         public static bool operator <(Vector3 left, Vector3 right)
         {
-            if (Mathf.IsEqualApprox(left.x, right.x))
+            if (left.x == right.x)
             {
-                if (Mathf.IsEqualApprox(left.y, right.y))
+                if (left.y == right.y)
+                {
                     return left.z < right.z;
+                }
                 return left.y < right.y;
             }
-
             return left.x < right.x;
         }
 
         public static bool operator >(Vector3 left, Vector3 right)
         {
-            if (Mathf.IsEqualApprox(left.x, right.x))
+            if (left.x == right.x)
             {
-                if (Mathf.IsEqualApprox(left.y, right.y))
+                if (left.y == right.y)
+                {
                     return left.z > right.z;
+                }
                 return left.y > right.y;
             }
-
             return left.x > right.x;
         }
 
         public static bool operator <=(Vector3 left, Vector3 right)
         {
-            if (Mathf.IsEqualApprox(left.x, right.x))
+            if (left.x == right.x)
             {
-                if (Mathf.IsEqualApprox(left.y, right.y))
+                if (left.y == right.y)
+                {
                     return left.z <= right.z;
+                }
                 return left.y < right.y;
             }
-
             return left.x < right.x;
         }
 
         public static bool operator >=(Vector3 left, Vector3 right)
         {
-            if (Mathf.IsEqualApprox(left.x, right.x))
+            if (left.x == right.x)
             {
-                if (Mathf.IsEqualApprox(left.y, right.y))
+                if (left.y == right.y)
+                {
                     return left.z >= right.z;
+                }
                 return left.y > right.y;
             }
-
             return left.x > right.x;
         }