vector4 distance_squared_to and update csharp

core/math/vector4.cpp

@@ -91,6 +91,10 @@ real_t Vector4::distance_to(const Vector4 &p_to) const {
 	return (p_to - *this).length();
 }
 
+real_t Vector4::distance_squared_to(const Vector4 &p_to) const {
+	return (p_to - *this).length_squared();
+}
+
 Vector4 Vector4::direction_to(const Vector4 &p_to) const {
 	Vector4 ret(p_to.x - x, p_to.y - y, p_to.z - z, p_to.w - w);
 	ret.normalize();

core/math/vector4.h

@@ -79,6 +79,7 @@ struct _NO_DISCARD_ Vector4 {
 	bool is_normalized() const;
 
 	real_t distance_to(const Vector4 &p_to) const;
+	real_t distance_squared_to(const Vector4 &p_to) const;
 	Vector4 direction_to(const Vector4 &p_to) const;
 
 	Vector4 abs() const;

core/variant/variant_call.cpp

@@ -1746,6 +1746,7 @@ static void _register_variant_builtin_methods() {
 	bind_method(Vector4, is_normalized, sarray(), varray());
 	bind_method(Vector4, direction_to, sarray("to"), varray());
 	bind_method(Vector4, distance_to, sarray("to"), varray());
+	bind_method(Vector4, distance_squared_to, sarray("to"), varray());
 	bind_method(Vector4, dot, sarray("with"), varray());
 	bind_method(Vector4, inverse, sarray(), varray());
 	bind_method(Vector4, is_equal_approx, sarray("with"), varray());

doc/classes/Vector4.xml

@@ -80,6 +80,14 @@
 				Returns the normalized vector pointing from this vector to [code]to[/code]. This is equivalent to using [code](b - a).normalized()[/code].
 			</description>
 		</method>
+		<method name="distance_squared_to" qualifiers="const">
+			<return type="float" />
+			<param index="0" name="to" type="Vector4" />
+			<description>
+				Returns the squared distance between this vector and [code]to[/code].
+				This method runs faster than [method distance_to], so prefer it if you need to compare vectors or need the squared distance for some formula.
+			</description>
+		</method>
 		<method name="distance_to" qualifiers="const">
 			<return type="float" />
 			<param index="0" name="to" type="Vector4" />

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

@@ -140,7 +140,6 @@ namespace Godot
             }
         }
 
-
         /// <summary>
         /// Returns a new vector with all components in absolute values (i.e. positive).
         /// </summary>
@@ -178,16 +177,59 @@ namespace Godot
             );
         }
 
+        /// <summary>
+        /// Performs a cubic interpolation between vectors <paramref name="preA"/>, this vector,
+        /// <paramref name="b"/>, and <paramref name="postB"/>, by the given amount <paramref name="weight"/>.
+        /// </summary>
+        /// <param name="b">The destination vector.</param>
+        /// <param name="preA">A vector before this vector.</param>
+        /// <param name="postB">A vector after <paramref name="b"/>.</param>
+        /// <param name="weight">A value on the range of 0.0 to 1.0, representing the amount of interpolation.</param>
+        /// <returns>The interpolated vector.</returns>
+        public Vector4 CubicInterpolate(Vector4 b, Vector4 preA, Vector4 postB, real_t weight)
+        {
+            return new Vector4
+            (
+                Mathf.CubicInterpolate(x, b.x, preA.x, postB.x, weight),
+                Mathf.CubicInterpolate(y, b.y, preA.y, postB.y, weight),
+                Mathf.CubicInterpolate(y, b.z, preA.z, postB.z, weight),
+                Mathf.CubicInterpolate(w, b.w, preA.w, postB.w, weight)
+            );
+        }
 
         /// <summary>
-        /// Returns a new vector with all components rounded down (towards negative infinity).
+        /// Returns the normalized vector pointing from this vector to <paramref name="to"/>.
         /// </summary>
-        /// <returns>A vector with <see cref="Mathf.Floor"/> called on each component.</returns>
-        public Vector4 Floor()
+        /// <param name="to">The other vector to point towards.</param>
+        /// <returns>The direction from this vector to <paramref name="to"/>.</returns>
+        public Vector4 DirectionTo(Vector4 to)
         {
-            return new Vector4(Mathf.Floor(x), Mathf.Floor(y), Mathf.Floor(z), Mathf.Floor(w));
+            Vector4 ret = new Vector4(to.x - x, to.y - y, to.z - z, to.w - w);
+            ret.Normalize();
+            return ret;
         }
 
+        /// <summary>
+        /// Returns the squared distance between this vector and <paramref name="to"/>.
+        /// This method runs faster than <see cref="DistanceTo"/>, so prefer it if
+        /// you need to compare vectors or need the squared distance for some formula.
+        /// </summary>
+        /// <param name="to">The other vector to use.</param>
+        /// <returns>The squared distance between the two vectors.</returns>
+        public real_t DistanceSquaredTo(Vector4 to)
+        {
+            return (to - this).LengthSquared();
+        }
+
+        /// <summary>
+        /// Returns the distance between this vector and <paramref name="to"/>.
+        /// </summary>
+        /// <param name="to">The other vector to use.</param>
+        /// <returns>The distance between the two vectors.</returns>
+        public real_t DistanceTo(Vector4 to)
+        {
+            return (to - this).Length();
+        }
 
         /// <summary>
         /// Returns the dot product of this vector and <paramref name="with"/>.
@@ -199,6 +241,15 @@ namespace Godot
             return (x * with.x) + (y * with.y) + (z * with.z) + (w + with.w);
         }
 
+        /// <summary>
+        /// Returns a new vector with all components rounded down (towards negative infinity).
+        /// </summary>
+        /// <returns>A vector with <see cref="Mathf.Floor"/> called on each component.</returns>
+        public Vector4 Floor()
+        {
+            return new Vector4(Mathf.Floor(x), Mathf.Floor(y), Mathf.Floor(z), Mathf.Floor(w));
+        }
+
         /// <summary>
         /// Returns the inverse of this vector. This is the same as <c>new Vector4(1 / v.x, 1 / v.y, 1 / v.z, 1 / v.w)</c>.
         /// </summary>
@@ -317,6 +368,42 @@ namespace Godot
             return v;
         }
 
+        /// <summary>
+        /// Returns a vector composed of the <see cref="Mathf.PosMod(real_t, real_t)"/> of this vector's components
+        /// and <paramref name="mod"/>.
+        /// </summary>
+        /// <param name="mod">A value representing the divisor of the operation.</param>
+        /// <returns>
+        /// A vector with each component <see cref="Mathf.PosMod(real_t, real_t)"/> by <paramref name="mod"/>.
+        /// </returns>
+        public Vector4 PosMod(real_t mod)
+        {
+            return new Vector4(
+                Mathf.PosMod(x, mod),
+                Mathf.PosMod(y, mod),
+                Mathf.PosMod(z, mod),
+                Mathf.PosMod(w, mod)
+            );
+        }
+
+        /// <summary>
+        /// Returns a vector composed of the <see cref="Mathf.PosMod(real_t, real_t)"/> of this vector's components
+        /// and <paramref name="modv"/>'s components.
+        /// </summary>
+        /// <param name="modv">A vector representing the divisors of the operation.</param>
+        /// <returns>
+        /// A vector with each component <see cref="Mathf.PosMod(real_t, real_t)"/> by <paramref name="modv"/>'s components.
+        /// </returns>
+        public Vector4 PosMod(Vector4 modv)
+        {
+            return new Vector4(
+                Mathf.PosMod(x, modv.x),
+                Mathf.PosMod(y, modv.y),
+                Mathf.PosMod(z, modv.z),
+                Mathf.PosMod(w, modv.w)
+            );
+        }
+
         /// <summary>
         /// Returns this vector with all components rounded to the nearest integer,
         /// with halfway cases rounded towards the nearest multiple of two.
@@ -343,6 +430,21 @@ namespace Godot
             return v;
         }
 
+        /// <summary>
+        /// Returns this vector with each component snapped to the nearest multiple of <paramref name="step"/>.
+        /// This can also be used to round to an arbitrary number of decimals.
+        /// </summary>
+        /// <param name="step">A vector value representing the step size to snap to.</param>
+        public Vector4 Snapped(Vector4 step)
+        {
+            return new Vector4(
+                Mathf.Snapped(x, step.x),
+                Mathf.Snapped(y, step.y),
+                Mathf.Snapped(z, step.z),
+                Mathf.Snapped(w, step.w)
+            );
+        }
+
         // Constants
         private static readonly Vector4 _zero = new Vector4(0, 0, 0, 0);
         private static readonly Vector4 _one = new Vector4(1, 1, 1, 1);

tests/core/math/test_vector4.h

@@ -98,6 +98,9 @@ TEST_CASE("[Vector4] Length methods") {
 	CHECK_MESSAGE(
 			Math::is_equal_approx(vector1.distance_to(vector2), (real_t)54.772255750517),
 			"Vector4 distance_to should work as expected.");
+	CHECK_MESSAGE(
+			Math::is_equal_approx(vector1.distance_squared_to(vector2), 3000),
+			"Vector4 distance_squared_to should work as expected.");
 }
 
 TEST_CASE("[Vector4] Limiting methods") {