Replace generic macros with math equivalents

Repiteo · Repiteo · commit 67e004ee8f30 · 2024-06-24T11:32:04.000-05:00
diff --git a/include/godot_cpp/core/math.hpp b/include/godot_cpp/core/math.hpp
@@ -55,27 +55,31 @@ namespace godot {
 #undef MAX
 #undef CLAMP
 
-// Generic ABS function, for math uses please use Math::abs.
+// DEPRECATED. Use `Math::abs` instead.
 template <typename T>
 constexpr T ABS(T m_v) {
 	return m_v < 0 ? -m_v : m_v;
 }
 
+// DEPRECATED. Use `Math::sign` instead.
 template <typename T>
 constexpr const T SIGN(const T m_v) {
 	return m_v == 0 ? 0.0f : (m_v < 0 ? -1.0f : +1.0f);
 }
 
+// DEPRECATED. Use `Math::min` instead.
 template <typename T, typename T2>
 constexpr auto MIN(const T m_a, const T2 m_b) {
 	return m_a < m_b ? m_a : m_b;
 }
 
+// DEPRECATED. Use `Math::max` instead.
 template <typename T, typename T2>
 constexpr auto MAX(const T m_a, const T2 m_b) {
 	return m_a > m_b ? m_a : m_b;
 }
 
+// DEPRECATED. Use `Math::clamp` instead.
 template <typename T, typename T2, typename T3>
 constexpr auto CLAMP(const T m_a, const T2 m_min, const T3 m_max) {
 	return m_a < m_min ? m_min : (m_a > m_max ? m_max : m_a);
@@ -539,34 +543,28 @@ inline float bezier_interpolate(float p_start, float p_control_1, float p_contro
 }
 
 template <typename T>
-inline T clamp(T x, T minv, T maxv) {
-	if (x < minv) {
-		return minv;
-	}
-	if (x > maxv) {
-		return maxv;
-	}
-	return x;
+constexpr T clamp(T x, T minv, T maxv) {
+	return x < minv ? minv : (x > maxv ? maxv : x);
 }
 
 template <typename T>
-inline T min(T a, T b) {
+constexpr T min(T a, T b) {
 	return a < b ? a : b;
 }
 
 template <typename T>
-inline T max(T a, T b) {
+constexpr T max(T a, T b) {
 	return a > b ? a : b;
 }
 
 template <typename T>
-inline T sign(T x) {
-	return static_cast<T>(SIGN(x));
+constexpr T sign(T x) {
+	return x > T(0) ? T(1) : (x < T(0) ? T(-1) : T(0));
 }
 
 template <typename T>
-inline T abs(T x) {
-	return std::abs(x);
+constexpr T abs(T x) {
+	return x == T(0) ? T(0) : (x < T(0) ? -x : x);
 }
 
 inline double deg_to_rad(double p_y) {
diff --git a/include/godot_cpp/templates/hash_map.hpp b/include/godot_cpp/templates/hash_map.hpp
@@ -160,7 +160,7 @@ class HashMap {
 		uint32_t old_capacity = hash_table_size_primes[capacity_index];
 
 		// Capacity can't be 0.
-		capacity_index = MAX((uint32_t)MIN_CAPACITY_INDEX, p_new_capacity_index);
+		capacity_index = Math::max((uint32_t)MIN_CAPACITY_INDEX, p_new_capacity_index);
 
 		uint32_t capacity = hash_table_size_primes[capacity_index];
 
diff --git a/include/godot_cpp/templates/hash_set.hpp b/include/godot_cpp/templates/hash_set.hpp
@@ -141,7 +141,7 @@ class HashSet {
 
 	void _resize_and_rehash(uint32_t p_new_capacity_index) {
 		// Capacity can't be 0.
-		capacity_index = MAX((uint32_t)MIN_CAPACITY_INDEX, p_new_capacity_index);
+		capacity_index = Math::max((uint32_t)MIN_CAPACITY_INDEX, p_new_capacity_index);
 
 		uint32_t capacity = hash_table_size_primes[capacity_index];
 
diff --git a/include/godot_cpp/templates/vector.hpp b/include/godot_cpp/templates/vector.hpp
@@ -165,11 +165,11 @@ class Vector {
 
 		const Size s = size();
 
-		Size begin = CLAMP(p_begin, -s, s);
+		Size begin = Math::clamp(p_begin, -s, s);
 		if (begin < 0) {
 			begin += s;
 		}
-		Size end = CLAMP(p_end, -s, s);
+		Size end = Math::clamp(p_end, -s, s);
 		if (end < 0) {
 			end += s;
 		}
diff --git a/include/godot_cpp/variant/color.hpp b/include/godot_cpp/variant/color.hpp
@@ -135,13 +135,13 @@ struct _NO_DISCARD_ Color {
 
 		float sharedexp = 65408.000f; // Result of: ((pow2to9 - 1.0f) / pow2to9) * powf(2.0f, 31.0f - 15.0f)
 
-		float cRed = MAX(0.0f, MIN(sharedexp, r));
-		float cGreen = MAX(0.0f, MIN(sharedexp, g));
-		float cBlue = MAX(0.0f, MIN(sharedexp, b));
+		float cRed = Math::max(0.0f, Math::min(sharedexp, r));
+		float cGreen = Math::max(0.0f, Math::min(sharedexp, g));
+		float cBlue = Math::max(0.0f, Math::min(sharedexp, b));
 
-		float cMax = MAX(cRed, MAX(cGreen, cBlue));
+		float cMax = Math::max(cRed, Math::max(cGreen, cBlue));
 
-		float expp = MAX(-B - 1.0f, floor(Math::log(cMax) / (real_t)Math_LN2)) + 1.0f + B;
+		float expp = Math::max<float>(-B - 1.0f, floor(Math::log(cMax) / (real_t)Math_LN2)) + 1.0f + B;
 
 		float sMax = (float)floor((cMax / Math::pow(2.0f, expp - B - N)) + 0.5f);
 
@@ -204,14 +204,14 @@ struct _NO_DISCARD_ Color {
 	operator String() const;
 
 	// For the binder.
-	_FORCE_INLINE_ void set_r8(int32_t r8) { r = (CLAMP(r8, 0, 255) / 255.0f); }
-	_FORCE_INLINE_ int32_t get_r8() const { return int32_t(CLAMP(Math::round(r * 255.0f), 0.0f, 255.0f)); }
-	_FORCE_INLINE_ void set_g8(int32_t g8) { g = (CLAMP(g8, 0, 255) / 255.0f); }
-	_FORCE_INLINE_ int32_t get_g8() const { return int32_t(CLAMP(Math::round(g * 255.0f), 0.0f, 255.0f)); }
-	_FORCE_INLINE_ void set_b8(int32_t b8) { b = (CLAMP(b8, 0, 255) / 255.0f); }
-	_FORCE_INLINE_ int32_t get_b8() const { return int32_t(CLAMP(Math::round(b * 255.0f), 0.0f, 255.0f)); }
-	_FORCE_INLINE_ void set_a8(int32_t a8) { a = (CLAMP(a8, 0, 255) / 255.0f); }
-	_FORCE_INLINE_ int32_t get_a8() const { return int32_t(CLAMP(Math::round(a * 255.0f), 0.0f, 255.0f)); }
+	_FORCE_INLINE_ void set_r8(int32_t r8) { r = (Math::clamp(r8, 0, 255) / 255.0f); }
+	_FORCE_INLINE_ int32_t get_r8() const { return int32_t(Math::clamp(Math::round(r * 255.0f), 0.0f, 255.0f)); }
+	_FORCE_INLINE_ void set_g8(int32_t g8) { g = (Math::clamp(g8, 0, 255) / 255.0f); }
+	_FORCE_INLINE_ int32_t get_g8() const { return int32_t(Math::clamp(Math::round(g * 255.0f), 0.0f, 255.0f)); }
+	_FORCE_INLINE_ void set_b8(int32_t b8) { b = (Math::clamp(b8, 0, 255) / 255.0f); }
+	_FORCE_INLINE_ int32_t get_b8() const { return int32_t(Math::clamp(Math::round(b * 255.0f), 0.0f, 255.0f)); }
+	_FORCE_INLINE_ void set_a8(int32_t a8) { a = (Math::clamp(a8, 0, 255) / 255.0f); }
+	_FORCE_INLINE_ int32_t get_a8() const { return int32_t(Math::clamp(Math::round(a * 255.0f), 0.0f, 255.0f)); }
 
 	_FORCE_INLINE_ void set_h(float p_h) { set_hsv(p_h, get_s(), get_v(), a); }
 	_FORCE_INLINE_ void set_s(float p_s) { set_hsv(get_h(), p_s, get_v(), a); }
diff --git a/include/godot_cpp/variant/vector2.hpp b/include/godot_cpp/variant/vector2.hpp
@@ -88,19 +88,19 @@ struct _NO_DISCARD_ Vector2 {
 	Vector2 limit_length(const real_t p_len = 1.0) const;
 
 	Vector2 min(const Vector2 &p_vector2) const {
-		return Vector2(MIN(x, p_vector2.x), MIN(y, p_vector2.y));
+		return Vector2(Math::min(x, p_vector2.x), Math::min(y, p_vector2.y));
 	}
 
 	Vector2 minf(real_t p_scalar) const {
-		return Vector2(MIN(x, p_scalar), MIN(y, p_scalar));
+		return Vector2(Math::min(x, p_scalar), Math::min(y, p_scalar));
 	}
 
 	Vector2 max(const Vector2 &p_vector2) const {
-		return Vector2(MAX(x, p_vector2.x), MAX(y, p_vector2.y));
+		return Vector2(Math::max(x, p_vector2.x), Math::max(y, p_vector2.y));
 	}
 
 	Vector2 maxf(real_t p_scalar) const {
-		return Vector2(MAX(x, p_scalar), MAX(y, p_scalar));
+		return Vector2(Math::max(x, p_scalar), Math::max(y, p_scalar));
 	}
 
 	real_t distance_to(const Vector2 &p_vector2) const;
diff --git a/include/godot_cpp/variant/vector2i.hpp b/include/godot_cpp/variant/vector2i.hpp
@@ -80,19 +80,19 @@ struct _NO_DISCARD_ Vector2i {
 	}
 
 	Vector2i min(const Vector2i &p_vector2i) const {
-		return Vector2i(MIN(x, p_vector2i.x), MIN(y, p_vector2i.y));
+		return Vector2i(Math::min(x, p_vector2i.x), Math::min(y, p_vector2i.y));
 	}
 
 	Vector2i mini(int32_t p_scalar) const {
-		return Vector2i(MIN(x, p_scalar), MIN(y, p_scalar));
+		return Vector2i(Math::min(x, p_scalar), Math::min(y, p_scalar));
 	}
 
 	Vector2i max(const Vector2i &p_vector2i) const {
-		return Vector2i(MAX(x, p_vector2i.x), MAX(y, p_vector2i.y));
+		return Vector2i(Math::max(x, p_vector2i.x), Math::max(y, p_vector2i.y));
 	}
 
 	Vector2i maxi(int32_t p_scalar) const {
-		return Vector2i(MAX(x, p_scalar), MAX(y, p_scalar));
+		return Vector2i(Math::max(x, p_scalar), Math::max(y, p_scalar));
 	}
 
 	Vector2i operator+(const Vector2i &p_v) const;
@@ -129,7 +129,7 @@ struct _NO_DISCARD_ Vector2i {
 	double distance_to(const Vector2i &p_to) const;
 
 	real_t aspect() const { return width / (real_t)height; }
-	Vector2i sign() const { return Vector2i(SIGN(x), SIGN(y)); }
+	Vector2i sign() const { return Vector2i(Math::sign(x), Math::sign(y)); }
 	Vector2i abs() const { return Vector2i(Math::abs(x), Math::abs(y)); }
 	Vector2i snapped(const Vector2i &p_step) const;
 	Vector2i snappedi(int32_t p_step) const;
diff --git a/include/godot_cpp/variant/vector3.hpp b/include/godot_cpp/variant/vector3.hpp
@@ -79,19 +79,19 @@ struct _NO_DISCARD_ Vector3 {
 	}
 
 	Vector3 min(const Vector3 &p_vector3) const {
-		return Vector3(MIN(x, p_vector3.x), MIN(y, p_vector3.y), MIN(z, p_vector3.z));
+		return Vector3(Math::min(x, p_vector3.x), Math::min(y, p_vector3.y), Math::min(z, p_vector3.z));
 	}
 
 	Vector3 minf(real_t p_scalar) const {
-		return Vector3(MIN(x, p_scalar), MIN(y, p_scalar), MIN(z, p_scalar));
+		return Vector3(Math::min(x, p_scalar), Math::min(y, p_scalar), Math::min(z, p_scalar));
 	}
 
 	Vector3 max(const Vector3 &p_vector3) const {
-		return Vector3(MAX(x, p_vector3.x), MAX(y, p_vector3.y), MAX(z, p_vector3.z));
+		return Vector3(Math::max(x, p_vector3.x), Math::max(y, p_vector3.y), Math::max(z, p_vector3.z));
 	}
 
 	Vector3 maxf(real_t p_scalar) const {
-		return Vector3(MAX(x, p_scalar), MAX(y, p_scalar), MAX(z, p_scalar));
+		return Vector3(Math::max(x, p_scalar), Math::max(y, p_scalar), Math::max(z, p_scalar));
 	}
 
 	_FORCE_INLINE_ real_t length() const;
@@ -213,7 +213,7 @@ Vector3 Vector3::abs() const {
 }
 
 Vector3 Vector3::sign() const {
-	return Vector3(SIGN(x), SIGN(y), SIGN(z));
+	return Vector3(Math::sign(x), Math::sign(y), Math::sign(z));
 }
 
 Vector3 Vector3::floor() const {
diff --git a/include/godot_cpp/variant/vector3i.hpp b/include/godot_cpp/variant/vector3i.hpp
@@ -72,19 +72,19 @@ struct _NO_DISCARD_ Vector3i {
 	Vector3i::Axis max_axis_index() const;
 
 	Vector3i min(const Vector3i &p_vector3i) const {
-		return Vector3i(MIN(x, p_vector3i.x), MIN(y, p_vector3i.y), MIN(z, p_vector3i.z));
+		return Vector3i(Math::min(x, p_vector3i.x), Math::min(y, p_vector3i.y), Math::min(z, p_vector3i.z));
 	}
 
 	Vector3i mini(int32_t p_scalar) const {
-		return Vector3i(MIN(x, p_scalar), MIN(y, p_scalar), MIN(z, p_scalar));
+		return Vector3i(Math::min(x, p_scalar), Math::min(y, p_scalar), Math::min(z, p_scalar));
 	}
 
 	Vector3i max(const Vector3i &p_vector3i) const {
-		return Vector3i(MAX(x, p_vector3i.x), MAX(y, p_vector3i.y), MAX(z, p_vector3i.z));
+		return Vector3i(Math::max(x, p_vector3i.x), Math::max(y, p_vector3i.y), Math::max(z, p_vector3i.z));
 	}
 
 	Vector3i maxi(int32_t p_scalar) const {
-		return Vector3i(MAX(x, p_scalar), MAX(y, p_scalar), MAX(z, p_scalar));
+		return Vector3i(Math::max(x, p_scalar), Math::max(y, p_scalar), Math::max(z, p_scalar));
 	}
 
 	_FORCE_INLINE_ int64_t length_squared() const;
@@ -163,7 +163,7 @@ Vector3i Vector3i::abs() const {
 }
 
 Vector3i Vector3i::sign() const {
-	return Vector3i(SIGN(x), SIGN(y), SIGN(z));
+	return Vector3i(Math::sign(x), Math::sign(y), Math::sign(z));
 }
 
 /* Operators */
diff --git a/include/godot_cpp/variant/vector4.hpp b/include/godot_cpp/variant/vector4.hpp
@@ -71,19 +71,19 @@ struct _NO_DISCARD_ Vector4 {
 	Vector4::Axis max_axis_index() const;
 
 	Vector4 min(const Vector4 &p_vector4) const {
-		return Vector4(MIN(x, p_vector4.x), MIN(y, p_vector4.y), MIN(z, p_vector4.z), MIN(w, p_vector4.w));
+		return Vector4(Math::min(x, p_vector4.x), Math::min(y, p_vector4.y), Math::min(z, p_vector4.z), Math::min(w, p_vector4.w));
 	}
 
 	Vector4 minf(real_t p_scalar) const {
-		return Vector4(MIN(x, p_scalar), MIN(y, p_scalar), MIN(z, p_scalar), MIN(w, p_scalar));
+		return Vector4(Math::min(x, p_scalar), Math::min(y, p_scalar), Math::min(z, p_scalar), Math::min(w, p_scalar));
 	}
 
 	Vector4 max(const Vector4 &p_vector4) const {
-		return Vector4(MAX(x, p_vector4.x), MAX(y, p_vector4.y), MAX(z, p_vector4.z), MAX(w, p_vector4.w));
+		return Vector4(Math::max(x, p_vector4.x), Math::max(y, p_vector4.y), Math::max(z, p_vector4.z), Math::max(w, p_vector4.w));
 	}
 
 	Vector4 maxf(real_t p_scalar) const {
-		return Vector4(MAX(x, p_scalar), MAX(y, p_scalar), MAX(z, p_scalar), MAX(w, p_scalar));
+		return Vector4(Math::max(x, p_scalar), Math::max(y, p_scalar), Math::max(z, p_scalar), Math::max(w, p_scalar));
 	}
 
 	_FORCE_INLINE_ real_t length_squared() const;
diff --git a/include/godot_cpp/variant/vector4i.hpp b/include/godot_cpp/variant/vector4i.hpp
@@ -74,19 +74,19 @@ struct _NO_DISCARD_ Vector4i {
 	Vector4i::Axis max_axis_index() const;
 
 	Vector4i min(const Vector4i &p_vector4i) const {
-		return Vector4i(MIN(x, p_vector4i.x), MIN(y, p_vector4i.y), MIN(z, p_vector4i.z), MIN(w, p_vector4i.w));
+		return Vector4i(Math::min(x, p_vector4i.x), Math::min(y, p_vector4i.y), Math::min(z, p_vector4i.z), Math::min(w, p_vector4i.w));
 	}
 
 	Vector4i mini(int32_t p_scalar) const {
-		return Vector4i(MIN(x, p_scalar), MIN(y, p_scalar), MIN(z, p_scalar), MIN(w, p_scalar));
+		return Vector4i(Math::min(x, p_scalar), Math::min(y, p_scalar), Math::min(z, p_scalar), Math::min(w, p_scalar));
 	}
 
 	Vector4i max(const Vector4i &p_vector4i) const {
-		return Vector4i(MAX(x, p_vector4i.x), MAX(y, p_vector4i.y), MAX(z, p_vector4i.z), MAX(w, p_vector4i.w));
+		return Vector4i(Math::max(x, p_vector4i.x), Math::max(y, p_vector4i.y), Math::max(z, p_vector4i.z), Math::max(w, p_vector4i.w));
 	}
 
 	Vector4i maxi(int32_t p_scalar) const {
-		return Vector4i(MAX(x, p_scalar), MAX(y, p_scalar), MAX(z, p_scalar), MAX(w, p_scalar));
+		return Vector4i(Math::max(x, p_scalar), Math::max(y, p_scalar), Math::max(z, p_scalar), Math::max(w, p_scalar));
 	}
 
 	_FORCE_INLINE_ int64_t length_squared() const;
diff --git a/src/variant/basis.cpp b/src/variant/basis.cpp
@@ -292,7 +292,7 @@ Vector3 Basis::get_scale_abs() const {
 }
 
 Vector3 Basis::get_scale_local() const {
-	real_t det_sign = SIGN(determinant());
+	real_t det_sign = Math::sign(determinant());
 	return det_sign * Vector3(rows[0].length(), rows[1].length(), rows[2].length());
 }
 
@@ -318,7 +318,7 @@ Vector3 Basis::get_scale() const {
 	// matrix elements.
 	//
 	// The rotation part of this decomposition is returned by get_rotation* functions.
-	real_t det_sign = SIGN(determinant());
+	real_t det_sign = Math::sign(determinant());
 	return det_sign * get_scale_abs();
 }
 
@@ -416,7 +416,7 @@ void Basis::rotate_to_align(Vector3 p_start_direction, Vector3 p_end_direction)
 	const Vector3 axis = p_start_direction.cross(p_end_direction).normalized();
 	if (axis.length_squared() != 0) {
 		real_t dot = p_start_direction.dot(p_end_direction);
-		dot = CLAMP(dot, -1.0f, 1.0f);
+		dot = Math::clamp(dot, -1.0f, 1.0f);
 		const real_t angle_rads = Math::acos(dot);
 		set_axis_angle(axis, angle_rads);
 	}
@@ -829,7 +829,7 @@ void Basis::get_axis_angle(Vector3 &r_axis, real_t &r_angle) const {
 
 	r_axis = Vector3(x, y, z);
 	// CLAMP to avoid NaN if the value passed to acos is not in [0,1].
-	r_angle = Math::acos(CLAMP((rows[0][0] + rows[1][1] + rows[2][2] - 1) / 2, (real_t)0.0, (real_t)1.0));
+	r_angle = Math::acos(Math::clamp((rows[0][0] + rows[1][1] + rows[2][2] - 1) / 2, (real_t)0.0, (real_t)1.0));
 }
 
 void Basis::set_quaternion(const Quaternion &p_quaternion) {
diff --git a/src/variant/color.cpp b/src/variant/color.cpp
@@ -109,7 +109,7 @@ uint64_t Color::to_rgba64() const {
 
 String _to_hex(float p_val) {
 	int v = Math::round(p_val * 255.0f);
-	v = CLAMP(v, 0, 255);
+	v = Math::clamp(v, 0, 255);
 	String ret;
 
 	for (int i = 0; i < 2; i++) {
@@ -246,10 +246,10 @@ bool Color::is_equal_approx(const Color &p_color) const {
 
 Color Color::clamp(const Color &p_min, const Color &p_max) const {
 	return Color(
-			CLAMP(r, p_min.r, p_max.r),
-			CLAMP(g, p_min.g, p_max.g),
-			CLAMP(b, p_min.b, p_max.b),
-			CLAMP(a, p_min.a, p_max.a));
+			Math::clamp(r, p_min.r, p_max.r),
+			Math::clamp(g, p_min.g, p_max.g),
+			Math::clamp(b, p_min.b, p_max.b),
+			Math::clamp(a, p_min.a, p_max.a));
 }
 
 void Color::invert() {
diff --git a/src/variant/quaternion.cpp b/src/variant/quaternion.cpp
@@ -37,7 +37,7 @@ namespace godot {
 
 real_t Quaternion::angle_to(const Quaternion &p_to) const {
 	real_t d = dot(p_to);
-	return Math::acos(CLAMP(d * d * 2 - 1, -1, 1));
+	return Math::acos(Math::clamp<real_t>(d * d * 2 - 1, -1, 1));
 }
 
 // get_euler_xyz returns a vector containing the Euler angles in the format
diff --git a/src/variant/transform2d.cpp b/src/variant/transform2d.cpp
diff --git a/src/variant/vector2.cpp b/src/variant/vector2.cpp
diff --git a/src/variant/vector2i.cpp b/src/variant/vector2i.cpp
diff --git a/src/variant/vector3.cpp b/src/variant/vector3.cpp
diff --git a/src/variant/vector3i.cpp b/src/variant/vector3i.cpp
diff --git a/src/variant/vector4.cpp b/src/variant/vector4.cpp
diff --git a/src/variant/vector4i.cpp b/src/variant/vector4i.cpp

Original file line number	Diff line number	Diff line change
`@@ -165,11 +165,11 @@ class Vector {`
`165`	`165`
`166`	`166`	`const Size s = size();`
`167`	`167`
`168`		`- Size begin = CLAMP(p_begin, -s, s);`
	`168`	`+ Size begin = Math::clamp(p_begin, -s, s);`
`169`	`169`	`if (begin < 0) {`
`170`	`170`	`begin += s;`
`171`	`171`	`}`
`172`		`- Size end = CLAMP(p_end, -s, s);`
	`172`	`+ Size end = Math::clamp(p_end, -s, s);`
`173`	`173`	`if (end < 0) {`
`174`	`174`	`end += s;`
`175`	`175`	`}`
Original file line number	Diff line number	Diff line change
`@@ -88,19 +88,19 @@ struct _NO_DISCARD_ Vector2 {`
`88`	`88`	`Vector2 limit_length(const real_t p_len = 1.0) const;`
`89`	`89`
`90`	`90`	`Vector2 min(const Vector2 &p_vector2) const {`
`91`		`- return Vector2(MIN(x, p_vector2.x), MIN(y, p_vector2.y));`
	`91`	`+ return Vector2(Math::min(x, p_vector2.x), Math::min(y, p_vector2.y));`
`92`	`92`	`}`
`93`	`93`
`94`	`94`	`Vector2 minf(real_t p_scalar) const {`
`95`		`- return Vector2(MIN(x, p_scalar), MIN(y, p_scalar));`
	`95`	`+ return Vector2(Math::min(x, p_scalar), Math::min(y, p_scalar));`
`96`	`96`	`}`
`97`	`97`
`98`	`98`	`Vector2 max(const Vector2 &p_vector2) const {`
`99`		`- return Vector2(MAX(x, p_vector2.x), MAX(y, p_vector2.y));`
	`99`	`+ return Vector2(Math::max(x, p_vector2.x), Math::max(y, p_vector2.y));`
`100`	`100`	`}`
`101`	`101`
`102`	`102`	`Vector2 maxf(real_t p_scalar) const {`
`103`		`- return Vector2(MAX(x, p_scalar), MAX(y, p_scalar));`
	`103`	`+ return Vector2(Math::max(x, p_scalar), Math::max(y, p_scalar));`
`104`	`104`	`}`
`105`	`105`
`106`	`106`	`real_t distance_to(const Vector2 &p_vector2) const;`
Original file line number	Diff line number	Diff line change
`@@ -80,19 +80,19 @@ struct _NO_DISCARD_ Vector2i {`
`80`	`80`	`}`
`81`	`81`
`82`	`82`	`Vector2i min(const Vector2i &p_vector2i) const {`
`83`		`- return Vector2i(MIN(x, p_vector2i.x), MIN(y, p_vector2i.y));`
	`83`	`+ return Vector2i(Math::min(x, p_vector2i.x), Math::min(y, p_vector2i.y));`
`84`	`84`	`}`
`85`	`85`
`86`	`86`	`Vector2i mini(int32_t p_scalar) const {`
`87`		`- return Vector2i(MIN(x, p_scalar), MIN(y, p_scalar));`
	`87`	`+ return Vector2i(Math::min(x, p_scalar), Math::min(y, p_scalar));`
`88`	`88`	`}`
`89`	`89`
`90`	`90`	`Vector2i max(const Vector2i &p_vector2i) const {`
`91`		`- return Vector2i(MAX(x, p_vector2i.x), MAX(y, p_vector2i.y));`
	`91`	`+ return Vector2i(Math::max(x, p_vector2i.x), Math::max(y, p_vector2i.y));`
`92`	`92`	`}`
`93`	`93`
`94`	`94`	`Vector2i maxi(int32_t p_scalar) const {`
`95`		`- return Vector2i(MAX(x, p_scalar), MAX(y, p_scalar));`
	`95`	`+ return Vector2i(Math::max(x, p_scalar), Math::max(y, p_scalar));`
`96`	`96`	`}`
`97`	`97`
`98`	`98`	`Vector2i operator+(const Vector2i &p_v) const;`
`@@ -129,7 +129,7 @@ struct _NO_DISCARD_ Vector2i {`
`129`	`129`	`double distance_to(const Vector2i &p_to) const;`
`130`	`130`
`131`	`131`	`real_t aspect() const { return width / (real_t)height; }`
`132`		`- Vector2i sign() const { return Vector2i(SIGN(x), SIGN(y)); }`
	`132`	`+ Vector2i sign() const { return Vector2i(Math::sign(x), Math::sign(y)); }`
`133`	`133`	`Vector2i abs() const { return Vector2i(Math::abs(x), Math::abs(y)); }`
`134`	`134`	`Vector2i snapped(const Vector2i &p_step) const;`
`135`	`135`	`Vector2i snappedi(int32_t p_step) const;`
Original file line number	Diff line number	Diff line change
`@@ -79,19 +79,19 @@ struct _NO_DISCARD_ Vector3 {`
`79`	`79`	`}`
`80`	`80`
`81`	`81`	`Vector3 min(const Vector3 &p_vector3) const {`
`82`		`- return Vector3(MIN(x, p_vector3.x), MIN(y, p_vector3.y), MIN(z, p_vector3.z));`
	`82`	`+ return Vector3(Math::min(x, p_vector3.x), Math::min(y, p_vector3.y), Math::min(z, p_vector3.z));`
`83`	`83`	`}`
`84`	`84`
`85`	`85`	`Vector3 minf(real_t p_scalar) const {`
`86`		`- return Vector3(MIN(x, p_scalar), MIN(y, p_scalar), MIN(z, p_scalar));`
	`86`	`+ return Vector3(Math::min(x, p_scalar), Math::min(y, p_scalar), Math::min(z, p_scalar));`
`87`	`87`	`}`
`88`	`88`
`89`	`89`	`Vector3 max(const Vector3 &p_vector3) const {`
`90`		`- return Vector3(MAX(x, p_vector3.x), MAX(y, p_vector3.y), MAX(z, p_vector3.z));`
	`90`	`+ return Vector3(Math::max(x, p_vector3.x), Math::max(y, p_vector3.y), Math::max(z, p_vector3.z));`
`91`	`91`	`}`
`92`	`92`
`93`	`93`	`Vector3 maxf(real_t p_scalar) const {`
`94`		`- return Vector3(MAX(x, p_scalar), MAX(y, p_scalar), MAX(z, p_scalar));`
	`94`	`+ return Vector3(Math::max(x, p_scalar), Math::max(y, p_scalar), Math::max(z, p_scalar));`
`95`	`95`	`}`
`96`	`96`
`97`	`97`	`_FORCE_INLINE_ real_t length() const;`
`@@ -213,7 +213,7 @@ Vector3 Vector3::abs() const {`
`213`	`213`	`}`
`214`	`214`
`215`	`215`	`Vector3 Vector3::sign() const {`
`216`		`- return Vector3(SIGN(x), SIGN(y), SIGN(z));`
	`216`	`+ return Vector3(Math::sign(x), Math::sign(y), Math::sign(z));`
`217`	`217`	`}`
`218`	`218`
`219`	`219`	`Vector3 Vector3::floor() const {`
Original file line number	Diff line number	Diff line change
`@@ -72,19 +72,19 @@ struct _NO_DISCARD_ Vector3i {`
`72`	`72`	`Vector3i::Axis max_axis_index() const;`
`73`	`73`
`74`	`74`	`Vector3i min(const Vector3i &p_vector3i) const {`
`75`		`- return Vector3i(MIN(x, p_vector3i.x), MIN(y, p_vector3i.y), MIN(z, p_vector3i.z));`
	`75`	`+ return Vector3i(Math::min(x, p_vector3i.x), Math::min(y, p_vector3i.y), Math::min(z, p_vector3i.z));`
`76`	`76`	`}`
`77`	`77`
`78`	`78`	`Vector3i mini(int32_t p_scalar) const {`
`79`		`- return Vector3i(MIN(x, p_scalar), MIN(y, p_scalar), MIN(z, p_scalar));`
	`79`	`+ return Vector3i(Math::min(x, p_scalar), Math::min(y, p_scalar), Math::min(z, p_scalar));`
`80`	`80`	`}`
`81`	`81`
`82`	`82`	`Vector3i max(const Vector3i &p_vector3i) const {`
`83`		`- return Vector3i(MAX(x, p_vector3i.x), MAX(y, p_vector3i.y), MAX(z, p_vector3i.z));`
	`83`	`+ return Vector3i(Math::max(x, p_vector3i.x), Math::max(y, p_vector3i.y), Math::max(z, p_vector3i.z));`
`84`	`84`	`}`
`85`	`85`
`86`	`86`	`Vector3i maxi(int32_t p_scalar) const {`
`87`		`- return Vector3i(MAX(x, p_scalar), MAX(y, p_scalar), MAX(z, p_scalar));`
	`87`	`+ return Vector3i(Math::max(x, p_scalar), Math::max(y, p_scalar), Math::max(z, p_scalar));`
`88`	`88`	`}`
`89`	`89`
`90`	`90`	`_FORCE_INLINE_ int64_t length_squared() const;`
`@@ -163,7 +163,7 @@ Vector3i Vector3i::abs() const {`
`163`	`163`	`}`
`164`	`164`
`165`	`165`	`Vector3i Vector3i::sign() const {`
`166`		`- return Vector3i(SIGN(x), SIGN(y), SIGN(z));`
	`166`	`+ return Vector3i(Math::sign(x), Math::sign(y), Math::sign(z));`
`167`	`167`	`}`
`168`	`168`
`169`	`169`	`/* Operators */`
Original file line number	Diff line number	Diff line change
`@@ -71,19 +71,19 @@ struct _NO_DISCARD_ Vector4 {`
`71`	`71`	`Vector4::Axis max_axis_index() const;`
`72`	`72`
`73`	`73`	`Vector4 min(const Vector4 &p_vector4) const {`
`74`		`- return Vector4(MIN(x, p_vector4.x), MIN(y, p_vector4.y), MIN(z, p_vector4.z), MIN(w, p_vector4.w));`
	`74`	`+ return Vector4(Math::min(x, p_vector4.x), Math::min(y, p_vector4.y), Math::min(z, p_vector4.z), Math::min(w, p_vector4.w));`
`75`	`75`	`}`
`76`	`76`
`77`	`77`	`Vector4 minf(real_t p_scalar) const {`
`78`		`- return Vector4(MIN(x, p_scalar), MIN(y, p_scalar), MIN(z, p_scalar), MIN(w, p_scalar));`
	`78`	`+ return Vector4(Math::min(x, p_scalar), Math::min(y, p_scalar), Math::min(z, p_scalar), Math::min(w, p_scalar));`
`79`	`79`	`}`
`80`	`80`
`81`	`81`	`Vector4 max(const Vector4 &p_vector4) const {`
`82`		`- return Vector4(MAX(x, p_vector4.x), MAX(y, p_vector4.y), MAX(z, p_vector4.z), MAX(w, p_vector4.w));`
	`82`	`+ return Vector4(Math::max(x, p_vector4.x), Math::max(y, p_vector4.y), Math::max(z, p_vector4.z), Math::max(w, p_vector4.w));`
`83`	`83`	`}`
`84`	`84`
`85`	`85`	`Vector4 maxf(real_t p_scalar) const {`
`86`		`- return Vector4(MAX(x, p_scalar), MAX(y, p_scalar), MAX(z, p_scalar), MAX(w, p_scalar));`
	`86`	`+ return Vector4(Math::max(x, p_scalar), Math::max(y, p_scalar), Math::max(z, p_scalar), Math::max(w, p_scalar));`
`87`	`87`	`}`
`88`	`88`
`89`	`89`	`_FORCE_INLINE_ real_t length_squared() const;`