Merge pull request #20371 from aaronfranke/vector-lerp

[Core] [Mono] [GDNative] Rename "linear_interpolate" methods to "lerp"

core/color.h

@@ -97,7 +97,7 @@ struct Color {
 	Color inverted() const;
 	Color contrasted() const;
 
-	_FORCE_INLINE_ Color linear_interpolate(const Color &p_b, float p_t) const {
+	_FORCE_INLINE_ Color lerp(const Color &p_b, float p_t) const {
 
 		Color res = *this;
 

core/input/input.cpp

@@ -175,7 +175,7 @@ void Input::SpeedTrack::update(const Vector2 &p_delta_p) {
 		accum = accum - slice;
 		accum_t -= min_ref_frame;
 
-		speed = (slice / min_ref_frame).linear_interpolate(speed, min_ref_frame / max_ref_frame);
+		speed = (slice / min_ref_frame).lerp(speed, min_ref_frame / max_ref_frame);
 	}
 }
 

core/math/audio_frame.h

@@ -104,7 +104,7 @@ struct AudioFrame {
 		r = ::undenormalise(r);
 	}
 
-	_FORCE_INLINE_ AudioFrame linear_interpolate(const AudioFrame &p_b, float p_t) const {
+	_FORCE_INLINE_ AudioFrame lerp(const AudioFrame &p_b, float p_t) const {
 
 		AudioFrame res = *this;
 

core/math/geometry.cpp

@@ -911,7 +911,7 @@ Vector<Plane> Geometry::build_sphere_planes(real_t p_radius, int p_lats, int p_l
 		for (int j = 1; j <= p_lats; j++) {
 
 			// FIXME: This is stupid.
-			Vector3 angle = normal.linear_interpolate(axis, j / (real_t)p_lats).normalized();
+			Vector3 angle = normal.lerp(axis, j / (real_t)p_lats).normalized();
 			Vector3 pos = angle * p_radius;
 			planes.push_back(Plane(pos, angle));
 			planes.push_back(Plane(pos * axis_neg, angle * axis_neg));
@@ -943,7 +943,7 @@ Vector<Plane> Geometry::build_capsule_planes(real_t p_radius, real_t p_height, i
 
 		for (int j = 1; j <= p_lats; j++) {
 
-			Vector3 angle = normal.linear_interpolate(axis, j / (real_t)p_lats).normalized();
+			Vector3 angle = normal.lerp(axis, j / (real_t)p_lats).normalized();
 			Vector3 pos = axis * p_height * 0.5 + angle * p_radius;
 			planes.push_back(Plane(pos, angle));
 			planes.push_back(Plane(pos * axis_neg, angle * axis_neg));

core/math/geometry.h

@@ -117,8 +117,8 @@ public:
 		if (mub < 0) mub = 0;
 		if (mua > 1) mua = 1;
 		if (mub > 1) mub = 1;
-		c1 = p1.linear_interpolate(p2, mua);
-		c2 = q1.linear_interpolate(q2, mub);
+		c1 = p1.lerp(p2, mua);
+		c2 = q1.lerp(q2, mub);
 	}
 
 	static real_t get_closest_distance_between_segments(const Vector3 &p_from_a, const Vector3 &p_to_a, const Vector3 &p_from_b, const Vector3 &p_to_b) {

core/math/transform.cpp

@@ -129,8 +129,8 @@ Transform Transform::interpolate_with(const Transform &p_transform, real_t p_c)
 	Vector3 dst_loc = p_transform.origin;
 
 	Transform interp;
-	interp.basis.set_quat_scale(src_rot.slerp(dst_rot, p_c).normalized(), src_scale.linear_interpolate(dst_scale, p_c));
-	interp.origin = src_loc.linear_interpolate(dst_loc, p_c);
+	interp.basis.set_quat_scale(src_rot.slerp(dst_rot, p_c).normalized(), src_scale.lerp(dst_scale, p_c));
+	interp.origin = src_loc.lerp(dst_loc, p_c);
 
 	return interp;
 }

core/math/transform_2d.cpp

@@ -267,7 +267,7 @@ Transform2D Transform2D::interpolate_with(const Transform2D &p_transform, real_t
 	Vector2 v;
 
 	if (dot > 0.9995) {
-		v = Vector2::linear_interpolate(v1, v2, p_c).normalized(); //linearly interpolate to avoid numerical precision issues
+		v = v1.lerp(v2, p_c).normalized(); //linearly interpolate to avoid numerical precision issues
 	} else {
 		real_t angle = p_c * Math::acos(dot);
 		Vector2 v3 = (v2 - v1 * dot).normalized();
@@ -275,8 +275,8 @@ Transform2D Transform2D::interpolate_with(const Transform2D &p_transform, real_t
 	}
 
 	//construct matrix
-	Transform2D res(Math::atan2(v.y, v.x), Vector2::linear_interpolate(p1, p2, p_c));
-	res.scale_basis(Vector2::linear_interpolate(s1, s2, p_c));
+	Transform2D res(Math::atan2(v.y, v.x), p1.lerp(p2, p_c));
+	res.scale_basis(s1.lerp(s2, p_c));
 	return res;
 }
 

core/math/vector2.h

@@ -82,8 +82,7 @@ struct Vector2 {
 
 	Vector2 clamped(real_t p_len) const;
 
-	_FORCE_INLINE_ static Vector2 linear_interpolate(const Vector2 &p_a, const Vector2 &p_b, real_t p_t);
-	_FORCE_INLINE_ Vector2 linear_interpolate(const Vector2 &p_b, real_t p_t) const;
+	_FORCE_INLINE_ Vector2 lerp(const Vector2 &p_b, real_t p_t) const;
 	_FORCE_INLINE_ Vector2 slerp(const Vector2 &p_b, real_t p_t) const;
 	Vector2 cubic_interpolate(const Vector2 &p_b, const Vector2 &p_pre_a, const Vector2 &p_post_b, real_t p_t) const;
 	Vector2 move_toward(const Vector2 &p_to, const real_t p_delta) const;
@@ -224,7 +223,7 @@ _FORCE_INLINE_ bool Vector2::operator!=(const Vector2 &p_vec2) const {
 	return x != p_vec2.x || y != p_vec2.y;
 }
 
-Vector2 Vector2::linear_interpolate(const Vector2 &p_b, real_t p_t) const {
+Vector2 Vector2::lerp(const Vector2 &p_b, real_t p_t) const {
 
 	Vector2 res = *this;
 
@@ -248,16 +247,6 @@ Vector2 Vector2::direction_to(const Vector2 &p_b) const {
 	return ret;
 }
 
-Vector2 Vector2::linear_interpolate(const Vector2 &p_a, const Vector2 &p_b, real_t p_t) {
-
-	Vector2 res = p_a;
-
-	res.x += (p_t * (p_b.x - p_a.x));
-	res.y += (p_t * (p_b.y - p_a.y));
-
-	return res;
-}
-
 typedef Vector2 Size2;
 typedef Vector2 Point2;
 

core/math/vector3.h

@@ -89,7 +89,7 @@ struct Vector3 {
 
 	/* Static Methods between 2 vector3s */
 
-	_FORCE_INLINE_ Vector3 linear_interpolate(const Vector3 &p_b, real_t p_t) const;
+	_FORCE_INLINE_ Vector3 lerp(const Vector3 &p_b, real_t p_t) const;
 	_FORCE_INLINE_ Vector3 slerp(const Vector3 &p_b, real_t p_t) const;
 	Vector3 cubic_interpolate(const Vector3 &p_b, const Vector3 &p_pre_a, const Vector3 &p_post_b, real_t p_t) const;
 	Vector3 cubic_interpolaten(const Vector3 &p_b, const Vector3 &p_pre_a, const Vector3 &p_post_b, real_t p_t) const;
@@ -206,7 +206,7 @@ Vector3 Vector3::round() const {
 	return Vector3(Math::round(x), Math::round(y), Math::round(z));
 }
 
-Vector3 Vector3::linear_interpolate(const Vector3 &p_b, real_t p_t) const {
+Vector3 Vector3::lerp(const Vector3 &p_b, real_t p_t) const {
 
 	return Vector3(
 			x + (p_t * (p_b.x - x)),

core/variant_call.cpp

@@ -362,7 +362,7 @@ struct _VariantCall {
 	VCALL_LOCALMEM1R(Vector2, angle_to);
 	VCALL_LOCALMEM1R(Vector2, angle_to_point);
 	VCALL_LOCALMEM1R(Vector2, direction_to);
-	VCALL_LOCALMEM2R(Vector2, linear_interpolate);
+	VCALL_LOCALMEM2R(Vector2, lerp);
 	VCALL_LOCALMEM2R(Vector2, slerp);
 	VCALL_LOCALMEM4R(Vector2, cubic_interpolate);
 	VCALL_LOCALMEM2R(Vector2, move_toward);
@@ -426,7 +426,7 @@ struct _VariantCall {
 	VCALL_LOCALMEM0R(Vector3, inverse);
 	VCALL_LOCALMEM1R(Vector3, snapped);
 	VCALL_LOCALMEM2R(Vector3, rotated);
-	VCALL_LOCALMEM2R(Vector3, linear_interpolate);
+	VCALL_LOCALMEM2R(Vector3, lerp);
 	VCALL_LOCALMEM2R(Vector3, slerp);
 	VCALL_LOCALMEM4R(Vector3, cubic_interpolate);
 	VCALL_LOCALMEM2R(Vector3, move_toward);
@@ -509,7 +509,7 @@ struct _VariantCall {
 	VCALL_LOCALMEM0R(Color, to_rgba64);
 	VCALL_LOCALMEM0R(Color, inverted);
 	VCALL_LOCALMEM0R(Color, contrasted);
-	VCALL_LOCALMEM2R(Color, linear_interpolate);
+	VCALL_LOCALMEM2R(Color, lerp);
 	VCALL_LOCALMEM1R(Color, blend);
 	VCALL_LOCALMEM1R(Color, lightened);
 	VCALL_LOCALMEM1R(Color, darkened);
@@ -1801,7 +1801,7 @@ void register_variant_methods() {
 	ADDFUNC1R(VECTOR2, VECTOR2, Vector2, posmod, FLOAT, "mod", varray());
 	ADDFUNC1R(VECTOR2, VECTOR2, Vector2, posmodv, VECTOR2, "modv", varray());
 	ADDFUNC1R(VECTOR2, VECTOR2, Vector2, project, VECTOR2, "b", varray());
-	ADDFUNC2R(VECTOR2, VECTOR2, Vector2, linear_interpolate, VECTOR2, "b", FLOAT, "t", varray());
+	ADDFUNC2R(VECTOR2, VECTOR2, Vector2, lerp, VECTOR2, "b", FLOAT, "t", varray());
 	ADDFUNC2R(VECTOR2, VECTOR2, Vector2, slerp, VECTOR2, "b", FLOAT, "t", varray());
 	ADDFUNC4R(VECTOR2, VECTOR2, Vector2, cubic_interpolate, VECTOR2, "b", VECTOR2, "pre_a", VECTOR2, "post_b", FLOAT, "t", varray());
 	ADDFUNC2R(VECTOR2, VECTOR2, Vector2, move_toward, VECTOR2, "to", FLOAT, "delta", varray());
@@ -1866,7 +1866,7 @@ void register_variant_methods() {
 	ADDFUNC0R(VECTOR3, VECTOR3, Vector3, inverse, varray());
 	ADDFUNC1R(VECTOR3, VECTOR3, Vector3, snapped, VECTOR3, "by", varray());
 	ADDFUNC2R(VECTOR3, VECTOR3, Vector3, rotated, VECTOR3, "axis", FLOAT, "phi", varray());
-	ADDFUNC2R(VECTOR3, VECTOR3, Vector3, linear_interpolate, VECTOR3, "b", FLOAT, "t", varray());
+	ADDFUNC2R(VECTOR3, VECTOR3, Vector3, lerp, VECTOR3, "b", FLOAT, "t", varray());
 	ADDFUNC2R(VECTOR3, VECTOR3, Vector3, slerp, VECTOR3, "b", FLOAT, "t", varray());
 	ADDFUNC4R(VECTOR3, VECTOR3, Vector3, cubic_interpolate, VECTOR3, "b", VECTOR3, "pre_a", VECTOR3, "post_b", FLOAT, "t", varray());
 	ADDFUNC2R(VECTOR3, VECTOR3, Vector3, move_toward, VECTOR3, "to", FLOAT, "delta", varray());
@@ -1925,7 +1925,7 @@ void register_variant_methods() {
 	ADDFUNC0R(COLOR, INT, Color, to_rgba64, varray());
 	ADDFUNC0R(COLOR, COLOR, Color, inverted, varray());
 	ADDFUNC0R(COLOR, COLOR, Color, contrasted, varray());
-	ADDFUNC2R(COLOR, COLOR, Color, linear_interpolate, COLOR, "b", FLOAT, "t", varray());
+	ADDFUNC2R(COLOR, COLOR, Color, lerp, COLOR, "b", FLOAT, "t", varray());
 	ADDFUNC1R(COLOR, COLOR, Color, blend, COLOR, "over", varray());
 	ADDFUNC1R(COLOR, COLOR, Color, lightened, FLOAT, "amount", varray());
 	ADDFUNC1R(COLOR, COLOR, Color, darkened, FLOAT, "amount", varray());

core/variant_op.cpp

@@ -4220,7 +4220,7 @@ void Variant::interpolate(const Variant &a, const Variant &b, float c, Variant &
 		}
 			return;
 		case VECTOR2: {
-			r_dst = reinterpret_cast<const Vector2 *>(a._data._mem)->linear_interpolate(*reinterpret_cast<const Vector2 *>(b._data._mem), c);
+			r_dst = reinterpret_cast<const Vector2 *>(a._data._mem)->lerp(*reinterpret_cast<const Vector2 *>(b._data._mem), c);
 		}
 			return;
 		case VECTOR2I: {
@@ -4233,7 +4233,7 @@ void Variant::interpolate(const Variant &a, const Variant &b, float c, Variant &
 			return;
 
 		case RECT2: {
-			r_dst = Rect2(reinterpret_cast<const Rect2 *>(a._data._mem)->position.linear_interpolate(reinterpret_cast<const Rect2 *>(b._data._mem)->position, c), reinterpret_cast<const Rect2 *>(a._data._mem)->size.linear_interpolate(reinterpret_cast<const Rect2 *>(b._data._mem)->size, c));
+			r_dst = Rect2(reinterpret_cast<const Rect2 *>(a._data._mem)->position.lerp(reinterpret_cast<const Rect2 *>(b._data._mem)->position, c), reinterpret_cast<const Rect2 *>(a._data._mem)->size.lerp(reinterpret_cast<const Rect2 *>(b._data._mem)->size, c));
 		}
 			return;
 		case RECT2I: {
@@ -4254,7 +4254,7 @@ void Variant::interpolate(const Variant &a, const Variant &b, float c, Variant &
 			return;
 
 		case VECTOR3: {
-			r_dst = reinterpret_cast<const Vector3 *>(a._data._mem)->linear_interpolate(*reinterpret_cast<const Vector3 *>(b._data._mem), c);
+			r_dst = reinterpret_cast<const Vector3 *>(a._data._mem)->lerp(*reinterpret_cast<const Vector3 *>(b._data._mem), c);
 		}
 			return;
 		case VECTOR3I: {
@@ -4281,7 +4281,7 @@ void Variant::interpolate(const Variant &a, const Variant &b, float c, Variant &
 		}
 			return;
 		case AABB: {
-			r_dst = ::AABB(a._data._aabb->position.linear_interpolate(b._data._aabb->position, c), a._data._aabb->size.linear_interpolate(b._data._aabb->size, c));
+			r_dst = ::AABB(a._data._aabb->position.lerp(b._data._aabb->position, c), a._data._aabb->size.lerp(b._data._aabb->size, c));
 		}
 			return;
 		case BASIS: {
@@ -4293,7 +4293,7 @@ void Variant::interpolate(const Variant &a, const Variant &b, float c, Variant &
 		}
 			return;
 		case COLOR: {
-			r_dst = reinterpret_cast<const Color *>(a._data._mem)->linear_interpolate(*reinterpret_cast<const Color *>(b._data._mem), c);
+			r_dst = reinterpret_cast<const Color *>(a._data._mem)->lerp(*reinterpret_cast<const Color *>(b._data._mem), c);
 		}
 			return;
 		case STRING_NAME: {
@@ -4448,7 +4448,7 @@ void Variant::interpolate(const Variant &a, const Variant &b, float c, Variant &
 					const Vector2 *br = arr_b->ptr();
 
 					for (int i = 0; i < sz; i++) {
-						vw[i] = ar[i].linear_interpolate(br[i], c);
+						vw[i] = ar[i].lerp(br[i], c);
 					}
 				}
 				r_dst = v;
@@ -4473,7 +4473,7 @@ void Variant::interpolate(const Variant &a, const Variant &b, float c, Variant &
 					const Vector3 *br = arr_b->ptr();
 
 					for (int i = 0; i < sz; i++) {
-						vw[i] = ar[i].linear_interpolate(br[i], c);
+						vw[i] = ar[i].lerp(br[i], c);
 					}
 				}
 				r_dst = v;
@@ -4497,7 +4497,7 @@ void Variant::interpolate(const Variant &a, const Variant &b, float c, Variant &
 					const Color *br = arr_b->ptr();
 
 					for (int i = 0; i < sz; i++) {
-						vw[i] = ar[i].linear_interpolate(br[i], c);
+						vw[i] = ar[i].lerp(br[i], c);
 					}
 				}
 				r_dst = v;

doc/classes/Color.xml

@@ -149,32 +149,32 @@
 				Returns [code]true[/code] if this color and [code]color[/code] are approximately equal, by running [method @GDScript.is_equal_approx] on each component.
 			</description>
 		</method>
-		<method name="lightened">
+		<method name="lerp">
 			<return type="Color">
 			</return>
-			<argument index="0" name="amount" type="float">
+			<argument index="0" name="b" type="Color">
+			</argument>
+			<argument index="1" name="t" type="float">
 			</argument>
 			<description>
-				Returns a new color resulting from making this color lighter by the specified percentage (ratio from 0 to 1).
+				Returns the linear interpolation with another color. The interpolation factor [code]t[/code] is between 0 and 1.
 				[codeblock]
-				var green = Color(0.0, 1.0, 0.0)
-				var lightgreen = green.lightened(0.2) # 20% lighter than regular green
+				var c1 = Color(1.0, 0.0, 0.0)
+				var c2 = Color(0.0, 1.0, 0.0)
+				var li_c = c1.lerp(c2, 0.5) # A color of an RGBA(128, 128, 0, 255)
 				[/codeblock]
 			</description>
 		</method>
-		<method name="linear_interpolate">
+		<method name="lightened">
 			<return type="Color">
 			</return>
-			<argument index="0" name="b" type="Color">
-			</argument>
-			<argument index="1" name="t" type="float">
+			<argument index="0" name="amount" type="float">
 			</argument>
 			<description>
-				Returns the linear interpolation with another color. The interpolation factor [code]t[/code] is between 0 and 1.
+				Returns a new color resulting from making this color lighter by the specified percentage (ratio from 0 to 1).
 				[codeblock]
-				var c1 = Color(1.0, 0.0, 0.0)
-				var c2 = Color(0.0, 1.0, 0.0)
-				var li_c = c1.linear_interpolate(c2, 0.5) # A color of an RGBA(128, 128, 0, 255)
+				var green = Color(0.0, 1.0, 0.0)
+				var lightgreen = green.lightened(0.2) # 20% lighter than regular green
 				[/codeblock]
 			</description>
 		</method>

doc/classes/Vector2.xml

@@ -193,7 +193,7 @@
 				Returns the vector's length squared. Prefer this method over [method length] if you need to sort vectors or need the squared length for some formula.
 			</description>
 		</method>
-		<method name="linear_interpolate">
+		<method name="lerp">
 			<return type="Vector2">
 			</return>
 			<argument index="0" name="b" type="Vector2">

doc/classes/Vector3.xml

@@ -169,7 +169,7 @@
 				Returns the vector's length squared. Prefer this function over [method length] if you need to sort vectors or need the squared length for some formula.
 			</description>
 		</method>
-		<method name="linear_interpolate">
+		<method name="lerp">
 			<return type="Vector3">
 			</return>
 			<argument index="0" name="b" type="Vector3">

doc/translations/classes.pot

@@ -480,7 +480,7 @@ msgid ""
 "[float], the return value is a [float].\n"
 "If both are of the same vector type ([Vector2], [Vector3] or [Color]), the "
 "return value will be of the same type ([code]lerp[/code] then calls the "
-"vector type's [code]linear_interpolate[/code] method).\n"
+"vector type's [code]lerp[/code] method).\n"
 "[codeblock]\n"
 "lerp(0, 4, 0.75) # Returns 3.0\n"
 "lerp(Vector2(1, 5), Vector2(3, 2), 0.5) # Returns Vector2(2, 3.5)\n"
@@ -12703,7 +12703,7 @@ msgid ""
 "[codeblock]\n"
 "var c1 = Color(1.0, 0.0, 0.0)\n"
 "var c2 = Color(0.0, 1.0, 0.0)\n"
-"var li_c = c1.linear_interpolate(c2, 0.5) # A color of an RGBA(128, 128, 0, "
+"var li_c = c1.lerp(c2, 0.5) # A color of an RGBA(128, 128, 0, "
 "255)\n"
 "[/codeblock]"
 msgstr ""

doc/translations/fr.po

@@ -490,7 +490,7 @@ msgid ""
 "[float], the return value is a [float].\n"
 "If both are of the same vector type ([Vector2], [Vector3] or [Color]), the "
 "return value will be of the same type ([code]lerp[/code] then calls the "
-"vector type's [code]linear_interpolate[/code] method).\n"
+"vector type's [code]lerp[/code] method).\n"
 "[codeblock]\n"
 "lerp(0, 4, 0.75) # Returns 3.0\n"
 "lerp(Vector2(1, 5), Vector2(3, 2), 0.5) # Returns Vector2(2, 3.5)\n"
@@ -12713,7 +12713,7 @@ msgid ""
 "[codeblock]\n"
 "var c1 = Color(1.0, 0.0, 0.0)\n"
 "var c2 = Color(0.0, 1.0, 0.0)\n"
-"var li_c = c1.linear_interpolate(c2, 0.5) # A color of an RGBA(128, 128, 0, "
+"var li_c = c1.lerp(c2, 0.5) # A color of an RGBA(128, 128, 0, "
 "255)\n"
 "[/codeblock]"
 msgstr ""

editor/animation_bezier_editor.cpp

@@ -162,7 +162,7 @@ void AnimationBezierTrackEdit::_draw_track(int p_track, const Color &p_color) {
 
 				float c = (t - low_pos.x) / (high_pos.x - low_pos.x);
 
-				h = low_pos.linear_interpolate(high_pos, c).y;
+				h = low_pos.lerp(high_pos, c).y;
 			}
 
 			h = _bezier_h_to_pixel(h);
@@ -201,12 +201,12 @@ void AnimationBezierTrackEdit::_draw_line_clipped(const Vector2 &p_from, const V
 
 	if (to.x > p_clip_right) {
 		float c = (p_clip_right - from.x) / (to.x - from.x);
-		to = from.linear_interpolate(to, c);
+		to = from.lerp(to, c);
 	}
 
 	if (from.x < p_clip_left) {
 		float c = (p_clip_left - from.x) / (to.x - from.x);
-		from = from.linear_interpolate(to, c);
+		from = from.lerp(to, c);
 	}
 
 	draw_line(from, to, p_color);

editor/animation_track_editor_plugins.cpp

@@ -112,13 +112,13 @@ void AnimationTrackEditColor::draw_key_link(int p_index, float p_pixels_sec, int
 
 	if (x_from < p_clip_left) {
 		float c = float(p_clip_left - x_from) / (x_to - x_from);
-		color = color.linear_interpolate(color_next, c);
+		color = color.lerp(color_next, c);
 		x_from = p_clip_left;
 	}
 
 	if (x_to > p_clip_right) {
 		float c = float(p_clip_right - x_from) / (x_to - x_from);
-		color_next = color.linear_interpolate(color_next, c);
+		color_next = color.lerp(color_next, c);
 		x_to = p_clip_right;
 	}
 

editor/debugger/editor_profiler.cpp

@@ -136,7 +136,7 @@ Color EditorProfiler::_get_color_from_signature(const StringName &p_signature) c
 	double rot = ABS(double(p_signature.hash()) / double(0x7FFFFFFF));
 	Color c;
 	c.set_hsv(rot, bc.get_s(), bc.get_v());
-	return c.linear_interpolate(get_theme_color("base_color", "Editor"), 0.07);
+	return c.lerp(get_theme_color("base_color", "Editor"), 0.07);
 }
 
 void EditorProfiler::_item_edited() {

editor/debugger/editor_visual_profiler.cpp

@@ -132,7 +132,7 @@ Color EditorVisualProfiler::_get_color_from_signature(const StringName &p_signat
 	double rot = ABS(double(p_signature.hash()) / double(0x7FFFFFFF));
 	Color c;
 	c.set_hsv(rot, bc.get_s(), bc.get_v());
-	return c.linear_interpolate(get_theme_color("base_color", "Editor"), 0.07);
+	return c.lerp(get_theme_color("base_color", "Editor"), 0.07);
 }
 
 void EditorVisualProfiler::_item_selected() {

editor/editor_help.cpp

@@ -47,12 +47,12 @@ void EditorHelp::_init_colors() {
 	title_color = get_theme_color("accent_color", "Editor");
 	text_color = get_theme_color("default_color", "RichTextLabel");
 	headline_color = get_theme_color("headline_color", "EditorHelp");
-	base_type_color = title_color.linear_interpolate(text_color, 0.5);
+	base_type_color = title_color.lerp(text_color, 0.5);
 	comment_color = text_color * Color(1, 1, 1, 0.6);
 	symbol_color = comment_color;
 	value_color = text_color * Color(1, 1, 1, 0.6);
 	qualifier_color = text_color * Color(1, 1, 1, 0.8);
-	type_color = get_theme_color("accent_color", "Editor").linear_interpolate(text_color, 0.5);
+	type_color = get_theme_color("accent_color", "Editor").lerp(text_color, 0.5);
 	class_desc->add_theme_color_override("selection_color", get_theme_color("accent_color", "Editor") * Color(1, 1, 1, 0.4));
 	class_desc->add_theme_constant_override("line_separation", Math::round(5 * EDSCALE));
 }
@@ -196,7 +196,7 @@ void EditorHelp::_add_type(const String &p_type, const String &p_enum) {
 		}
 	}
 	const Color text_color = get_theme_color("default_color", "RichTextLabel");
-	const Color type_color = get_theme_color("accent_color", "Editor").linear_interpolate(text_color, 0.5);
+	const Color type_color = get_theme_color("accent_color", "Editor").lerp(text_color, 0.5);
 	class_desc->push_color(type_color);
 	bool add_array = false;
 	if (can_ref) {
@@ -1227,9 +1227,9 @@ static void _add_text_to_rt(const String &p_bbcode, RichTextLabel *p_rt) {
 	Color font_color_hl = p_rt->get_theme_color("headline_color", "EditorHelp");
 	Color accent_color = p_rt->get_theme_color("accent_color", "Editor");
 	Color property_color = p_rt->get_theme_color("property_color", "Editor");
-	Color link_color = accent_color.linear_interpolate(font_color_hl, 0.8);
-	Color code_color = accent_color.linear_interpolate(font_color_hl, 0.6);
-	Color kbd_color = accent_color.linear_interpolate(property_color, 0.6);
+	Color link_color = accent_color.lerp(font_color_hl, 0.8);
+	Color code_color = accent_color.lerp(font_color_hl, 0.6);
+	Color kbd_color = accent_color.lerp(property_color, 0.6);
 
 	String bbcode = p_bbcode.dedent().replace("\t", "").replace("\r", "").strip_edges();
 

editor/editor_themes.cpp

@@ -337,24 +337,24 @@ Ref<Theme> create_editor_theme(const Ref<Theme> p_theme) {
 	//Colors
 	bool dark_theme = EditorSettings::get_singleton()->is_dark_theme();
 
-	const Color dark_color_1 = base_color.linear_interpolate(Color(0, 0, 0, 1), contrast);
-	const Color dark_color_2 = base_color.linear_interpolate(Color(0, 0, 0, 1), contrast * 1.5);
-	const Color dark_color_3 = base_color.linear_interpolate(Color(0, 0, 0, 1), contrast * 2);
+	const Color dark_color_1 = base_color.lerp(Color(0, 0, 0, 1), contrast);
+	const Color dark_color_2 = base_color.lerp(Color(0, 0, 0, 1), contrast * 1.5);
+	const Color dark_color_3 = base_color.lerp(Color(0, 0, 0, 1), contrast * 2);
 
 	const Color background_color = dark_color_2;
 
 	// white (dark theme) or black (light theme), will be used to generate the rest of the colors
 	const Color mono_color = dark_theme ? Color(1, 1, 1) : Color(0, 0, 0);
 
-	const Color contrast_color_1 = base_color.linear_interpolate(mono_color, MAX(contrast, default_contrast));
-	const Color contrast_color_2 = base_color.linear_interpolate(mono_color, MAX(contrast * 1.5, default_contrast * 1.5));
+	const Color contrast_color_1 = base_color.lerp(mono_color, MAX(contrast, default_contrast));
+	const Color contrast_color_2 = base_color.lerp(mono_color, MAX(contrast * 1.5, default_contrast * 1.5));
 
-	const Color font_color = mono_color.linear_interpolate(base_color, 0.25);
-	const Color font_color_hl = mono_color.linear_interpolate(base_color, 0.15);
+	const Color font_color = mono_color.lerp(base_color, 0.25);
+	const Color font_color_hl = mono_color.lerp(base_color, 0.15);
 	const Color font_color_disabled = Color(mono_color.r, mono_color.g, mono_color.b, 0.3);
 	const Color font_color_selection = accent_color * Color(1, 1, 1, 0.4);
-	const Color color_disabled = mono_color.inverted().linear_interpolate(base_color, 0.7);
-	const Color color_disabled_bg = mono_color.inverted().linear_interpolate(base_color, 0.9);
+	const Color color_disabled = mono_color.inverted().lerp(base_color, 0.7);
+	const Color color_disabled_bg = mono_color.inverted().lerp(base_color, 0.9);
 
 	Color icon_color_hover = Color(1, 1, 1) * (dark_theme ? 1.15 : 1.45);
 	icon_color_hover.a = 1.0;
@@ -391,13 +391,13 @@ Ref<Theme> create_editor_theme(const Ref<Theme> p_theme) {
 	Color success_color = Color(0.45, 0.95, 0.5);
 	Color warning_color = Color(1, 0.87, 0.4);
 	Color error_color = Color(1, 0.47, 0.42);
-	Color property_color = font_color.linear_interpolate(Color(0.5, 0.5, 0.5), 0.5);
+	Color property_color = font_color.lerp(Color(0.5, 0.5, 0.5), 0.5);
 
 	if (!dark_theme) {
 		// Darken some colors to be readable on a light background
-		success_color = success_color.linear_interpolate(mono_color, 0.35);
-		warning_color = warning_color.linear_interpolate(mono_color, 0.35);
-		error_color = error_color.linear_interpolate(mono_color, 0.25);
+		success_color = success_color.lerp(mono_color, 0.35);
+		warning_color = warning_color.lerp(mono_color, 0.35);
+		error_color = error_color.lerp(mono_color, 0.25);
 	}
 
 	theme->set_color("success_color", "Editor", success_color);
@@ -434,7 +434,7 @@ Ref<Theme> create_editor_theme(const Ref<Theme> p_theme) {
 	editor_register_fonts(theme);
 
 	// Highlighted tabs and border width
-	Color tab_color = highlight_tabs ? base_color.linear_interpolate(font_color, contrast) : base_color;
+	Color tab_color = highlight_tabs ? base_color.lerp(font_color, contrast) : base_color;
 	const int border_width = CLAMP(border_size, 0, 3) * EDSCALE;
 
 	const int default_margin_size = 4;
@@ -686,7 +686,7 @@ Ref<Theme> create_editor_theme(const Ref<Theme> p_theme) {
 	theme->set_icon("visibility_xray", "PopupMenu", theme->get_icon("GuiVisibilityXray", "EditorIcons"));
 	theme->set_constant("vseparation", "PopupMenu", (extra_spacing + default_margin_size + 1) * EDSCALE);
 
-	Ref<StyleBoxFlat> sub_inspector_bg = make_flat_stylebox(dark_color_1.linear_interpolate(accent_color, 0.08), 2, 0, 2, 2);
+	Ref<StyleBoxFlat> sub_inspector_bg = make_flat_stylebox(dark_color_1.lerp(accent_color, 0.08), 2, 0, 2, 2);
 	sub_inspector_bg->set_border_width(MARGIN_LEFT, 2);
 	sub_inspector_bg->set_border_width(MARGIN_RIGHT, 2);
 	sub_inspector_bg->set_border_width(MARGIN_BOTTOM, 2);
@@ -763,9 +763,9 @@ Ref<Theme> create_editor_theme(const Ref<Theme> p_theme) {
 	theme->set_stylebox("title_button_hover", "Tree", style_tree_title);
 	theme->set_stylebox("title_button_pressed", "Tree", style_tree_title);
 
-	Color prop_category_color = dark_color_1.linear_interpolate(mono_color, 0.12);
-	Color prop_section_color = dark_color_1.linear_interpolate(mono_color, 0.09);
-	Color prop_subsection_color = dark_color_1.linear_interpolate(mono_color, 0.06);
+	Color prop_category_color = dark_color_1.lerp(mono_color, 0.12);
+	Color prop_section_color = dark_color_1.lerp(mono_color, 0.09);
+	Color prop_subsection_color = dark_color_1.lerp(mono_color, 0.06);
 	theme->set_color("prop_category", "Editor", prop_category_color);
 	theme->set_color("prop_section", "Editor", prop_section_color);
 	theme->set_color("prop_subsection", "Editor", prop_subsection_color);
@@ -1124,7 +1124,7 @@ Ref<Theme> create_editor_theme(const Ref<Theme> p_theme) {
 	theme->set_icon("toggle_hidden", "FileDialog", theme->get_icon("GuiVisibilityVisible", "EditorIcons"));
 	// Use a different color for folder icons to make them easier to distinguish from files.
 	// On a light theme, the icon will be dark, so we need to lighten it before blending it with the accent color.
-	theme->set_color("folder_icon_modulate", "FileDialog", (dark_theme ? Color(1, 1, 1) : Color(4.25, 4.25, 4.25)).linear_interpolate(accent_color, 0.7));
+	theme->set_color("folder_icon_modulate", "FileDialog", (dark_theme ? Color(1, 1, 1) : Color(4.25, 4.25, 4.25)).lerp(accent_color, 0.7));
 	theme->set_color("files_disabled", "FileDialog", font_color_disabled);
 
 	// color picker
@@ -1158,13 +1158,13 @@ Ref<Theme> create_editor_theme(const Ref<Theme> p_theme) {
 	// editor main color
 	const Color main_color = dark_theme ? Color(0.34, 0.7, 1.0) : Color(0.02, 0.5, 1.0);
 
-	const Color symbol_color = Color(0.34, 0.57, 1.0).linear_interpolate(mono_color, dark_theme ? 0.5 : 0.3);
+	const Color symbol_color = Color(0.34, 0.57, 1.0).lerp(mono_color, dark_theme ? 0.5 : 0.3);
 	const Color keyword_color = Color(1.0, 0.44, 0.52);
 	const Color basetype_color = dark_theme ? Color(0.26, 1.0, 0.76) : Color(0.0, 0.76, 0.38);
-	const Color type_color = basetype_color.linear_interpolate(mono_color, dark_theme ? 0.4 : 0.3);
-	const Color usertype_color = basetype_color.linear_interpolate(mono_color, dark_theme ? 0.7 : 0.5);
+	const Color type_color = basetype_color.lerp(mono_color, dark_theme ? 0.4 : 0.3);
+	const Color usertype_color = basetype_color.lerp(mono_color, dark_theme ? 0.7 : 0.5);
 	const Color comment_color = dim_color;
-	const Color string_color = (dark_theme ? Color(1.0, 0.85, 0.26) : Color(1.0, 0.82, 0.09)).linear_interpolate(mono_color, dark_theme ? 0.5 : 0.3);
+	const Color string_color = (dark_theme ? Color(1.0, 0.85, 0.26) : Color(1.0, 0.82, 0.09)).lerp(mono_color, dark_theme ? 0.5 : 0.3);
 
 	const Color te_background_color = dark_theme ? background_color : base_color;
 	const Color completion_background_color = dark_theme ? base_color : background_color;
@@ -1183,9 +1183,9 @@ Ref<Theme> create_editor_theme(const Ref<Theme> p_theme) {
 	const Color current_line_color = alpha1;
 	const Color line_length_guideline_color = dark_theme ? base_color : background_color;
 	const Color word_highlighted_color = alpha1;
-	const Color number_color = basetype_color.linear_interpolate(mono_color, dark_theme ? 0.5 : 0.3);
+	const Color number_color = basetype_color.lerp(mono_color, dark_theme ? 0.5 : 0.3);
 	const Color function_color = main_color;
-	const Color member_variable_color = main_color.linear_interpolate(mono_color, 0.6);
+	const Color member_variable_color = main_color.lerp(mono_color, 0.6);
 	const Color mark_color = Color(error_color.r, error_color.g, error_color.b, 0.3);
 	const Color bookmark_color = Color(0.08, 0.49, 0.98);
 	const Color breakpoint_color = error_color;

editor/node_3d_editor_gizmos.cpp

@@ -2827,10 +2827,10 @@ void DecalGizmoPlugin::redraw(EditorNode3DGizmo *p_gizmo) {
 			lines.push_back(a);
 			lines.push_back(b);
 		} else {
-			Vector3 ah = a.linear_interpolate(b, 0.2);
+			Vector3 ah = a.lerp(b, 0.2);
 			lines.push_back(a);
 			lines.push_back(ah);
-			Vector3 bh = b.linear_interpolate(a, 0.2);
+			Vector3 bh = b.lerp(a, 0.2);
 			lines.push_back(b);
 			lines.push_back(bh);
 		}

editor/plugins/animation_state_machine_editor.cpp

@@ -885,7 +885,7 @@ void AnimationNodeStateMachineEditor::_state_machine_pos_draw() {
 
 	state_machine_play_pos->draw_line(from, to, bg, 2);
 
-	to = from.linear_interpolate(to, c);
+	to = from.lerp(to, c);
 
 	state_machine_play_pos->draw_line(from, to, fg, 2);
 }

editor/plugins/canvas_item_editor_plugin.cpp

@@ -1437,13 +1437,13 @@ void CanvasItemEditor::_solve_IK(Node2D *leaf_node, Point2 target_position) {
 					Vector2 direction = (joints_pos[node_id + 1] - joints_pos[node_id]).normalized();
 					int len = E->get();
 					if (E == se->pre_drag_bones_length.front()) {
-						joints_pos[1] = joints_pos[1].linear_interpolate(joints_pos[0] + len * direction, solver_k);
+						joints_pos[1] = joints_pos[1].lerp(joints_pos[0] + len * direction, solver_k);
 					} else if (E == se->pre_drag_bones_length.back()) {
-						joints_pos[node_id] = joints_pos[node_id].linear_interpolate(joints_pos[node_id + 1] - len * direction, solver_k);
+						joints_pos[node_id] = joints_pos[node_id].lerp(joints_pos[node_id + 1] - len * direction, solver_k);
 					} else {
 						Vector2 center = (joints_pos[node_id + 1] + joints_pos[node_id]) / 2.0;
-						joints_pos[node_id] = joints_pos[node_id].linear_interpolate(center - (direction * len) / 2.0, solver_k);
-						joints_pos[node_id + 1] = joints_pos[node_id + 1].linear_interpolate(center + (direction * len) / 2.0, solver_k);
+						joints_pos[node_id] = joints_pos[node_id].lerp(center - (direction * len) / 2.0, solver_k);
+						joints_pos[node_id + 1] = joints_pos[node_id + 1].lerp(center + (direction * len) / 2.0, solver_k);
 					}
 					node_id++;
 				}
@@ -2698,7 +2698,7 @@ void CanvasItemEditor::_draw_smart_snapping() {
 
 void CanvasItemEditor::_draw_rulers() {
 	Color bg_color = get_theme_color("dark_color_2", "Editor");
-	Color graduation_color = get_theme_color("font_color", "Editor").linear_interpolate(bg_color, 0.5);
+	Color graduation_color = get_theme_color("font_color", "Editor").lerp(bg_color, 0.5);
 	Color font_color = get_theme_color("font_color", "Editor");
 	font_color.a = 0.8;
 	Ref<Font> font = get_theme_font("rulers", "EditorFonts");
@@ -3072,8 +3072,8 @@ void CanvasItemEditor::_draw_control_helpers(Control *control) {
 			Vector2 line_ends[4];
 			for (int i = 0; i < 4; i++) {
 				float anchor_val = (i >= 2) ? ANCHOR_END - anchors_values[i] : anchors_values[i];
-				line_starts[i] = Vector2::linear_interpolate(corners_pos[i], corners_pos[(i + 1) % 4], anchor_val);
-				line_ends[i] = Vector2::linear_interpolate(corners_pos[(i + 3) % 4], corners_pos[(i + 2) % 4], anchor_val);
+				line_starts[i] = corners_pos[i].lerp(corners_pos[(i + 1) % 4], anchor_val);
+				line_ends[i] = corners_pos[(i + 3) % 4].lerp(corners_pos[(i + 2) % 4], anchor_val);
 				anchor_snapped = anchors_values[i] == 0.0 || anchors_values[i] == 0.5 || anchors_values[i] == 1.0;
 				viewport->draw_line(line_starts[i], line_ends[i], anchor_snapped ? color_snapped : color_base, (i == dragged_anchor || (i + 3) % 4 == dragged_anchor) ? 2 : 1);
 			}

editor/plugins/node_3d_editor_plugin.cpp

@@ -268,7 +268,7 @@ void Node3DEditorViewport::_update_camera(float p_interp_delta) {
 			real_t factor = (1.0 / inertia) * p_interp_delta;
 
 			// We interpolate a different point here, because in freelook mode the focus point (cursor.pos) orbits around eye_pos
-			camera_cursor.eye_pos = old_camera_cursor.eye_pos.linear_interpolate(cursor.eye_pos, CLAMP(factor, 0, 1));
+			camera_cursor.eye_pos = old_camera_cursor.eye_pos.lerp(cursor.eye_pos, CLAMP(factor, 0, 1));
 
 			float orbit_inertia = EDITOR_GET("editors/3d/navigation_feel/orbit_inertia");
 			orbit_inertia = MAX(0.0001, orbit_inertia);
@@ -318,7 +318,7 @@ void Node3DEditorViewport::_update_camera(float p_interp_delta) {
 				camera_cursor.y_rot = cursor.y_rot;
 			}
 
-			camera_cursor.pos = old_camera_cursor.pos.linear_interpolate(cursor.pos, MIN(1.f, p_interp_delta * (1 / translation_inertia)));
+			camera_cursor.pos = old_camera_cursor.pos.lerp(cursor.pos, MIN(1.f, p_interp_delta * (1 / translation_inertia)));
 			camera_cursor.distance = Math::lerp(old_camera_cursor.distance, cursor.distance, MIN(1.f, p_interp_delta * (1 / zoom_inertia)));
 		}
 	}
@@ -4570,10 +4570,10 @@ void Node3DEditor::_generate_selection_box() {
 		st->add_color(Color(1.0, 1.0, 0.8, 0.8));
 		st->add_vertex(a);
 		st->add_color(Color(1.0, 1.0, 0.8, 0.4));
-		st->add_vertex(a.linear_interpolate(b, 0.2));
+		st->add_vertex(a.lerp(b, 0.2));
 
 		st->add_color(Color(1.0, 1.0, 0.8, 0.4));
-		st->add_vertex(a.linear_interpolate(b, 0.8));
+		st->add_vertex(a.lerp(b, 0.8));
 		st->add_color(Color(1.0, 1.0, 0.8, 0.8));
 		st->add_vertex(b);
 	}

editor/plugins/script_editor_plugin.cpp

@@ -1742,7 +1742,7 @@ void ScriptEditor::_update_script_colors() {
 			int non_zero_hist_size = (hist_size == 0) ? 1 : hist_size;
 			float v = Math::ease((edit_pass - pass) / float(non_zero_hist_size), 0.4);
 
-			script_list->set_item_custom_fg_color(i, hot_color.linear_interpolate(cold_color, v));
+			script_list->set_item_custom_fg_color(i, hot_color.lerp(cold_color, v));
 		}
 	}
 }

editor/rename_dialog.cpp

@@ -403,7 +403,7 @@ void RenameDialog::_update_preview(String new_text) {
 			// New name is identical to the old one. Don't color it as much to avoid distracting the user.
 			const Color accent_color = EditorNode::get_singleton()->get_gui_base()->get_theme_color("accent_color", "Editor");
 			const Color text_color = EditorNode::get_singleton()->get_gui_base()->get_theme_color("default_color", "RichTextLabel");
-			lbl_preview->add_theme_color_override("font_color", accent_color.linear_interpolate(text_color, 0.5));
+			lbl_preview->add_theme_color_override("font_color", accent_color.lerp(text_color, 0.5));
 		} else {
 			lbl_preview->add_theme_color_override("font_color", EditorNode::get_singleton()->get_gui_base()->get_theme_color("success_color", "Editor"));
 		}

modules/csg/csg.cpp

@@ -50,7 +50,7 @@ inline static Vector2 interpolate_segment_uv(const Vector2 p_segement_points[2],
 	float distance = (p_interpolation_point - p_segement_points[0]).length();
 	float fraction = distance / segment_length;
 
-	return p_uvs[0].linear_interpolate(p_uvs[1], fraction);
+	return p_uvs[0].lerp(p_uvs[1], fraction);
 }
 
 inline static Vector2 interpolate_triangle_uv(const Vector2 p_vertices[3], const Vector2 p_uvs[3], const Vector2 &p_interpolation_point) {

modules/gdnative/gdnative/color.cpp

@@ -155,11 +155,11 @@ godot_color GDAPI godot_color_contrasted(const godot_color *p_self) {
 	return dest;
 }
 
-godot_color GDAPI godot_color_linear_interpolate(const godot_color *p_self, const godot_color *p_b, const godot_real p_t) {
+godot_color GDAPI godot_color_lerp(const godot_color *p_self, const godot_color *p_b, const godot_real p_t) {
 	godot_color dest;
 	const Color *self = (const Color *)p_self;
 	const Color *b = (const Color *)p_b;
-	*((Color *)&dest) = self->linear_interpolate(*b, p_t);
+	*((Color *)&dest) = self->lerp(*b, p_t);
 	return dest;
 }
 

modules/gdnative/gdnative/vector2.cpp

@@ -109,11 +109,11 @@ godot_real GDAPI godot_vector2_angle_to_point(const godot_vector2 *p_self, const
 	return self->angle_to_point(*to);
 }
 
-godot_vector2 GDAPI godot_vector2_linear_interpolate(const godot_vector2 *p_self, const godot_vector2 *p_b, const godot_real p_t) {
+godot_vector2 GDAPI godot_vector2_lerp(const godot_vector2 *p_self, const godot_vector2 *p_b, const godot_real p_t) {
 	godot_vector2 dest;
 	const Vector2 *self = (const Vector2 *)p_self;
 	const Vector2 *b = (const Vector2 *)p_b;
-	*((Vector2 *)&dest) = self->linear_interpolate(*b, p_t);
+	*((Vector2 *)&dest) = self->lerp(*b, p_t);
 	return dest;
 }
 

modules/gdnative/gdnative/vector3.cpp

@@ -106,11 +106,11 @@ godot_vector3 GDAPI godot_vector3_rotated(const godot_vector3 *p_self, const god
 	return dest;
 }
 
-godot_vector3 GDAPI godot_vector3_linear_interpolate(const godot_vector3 *p_self, const godot_vector3 *p_b, const godot_real p_t) {
+godot_vector3 GDAPI godot_vector3_lerp(const godot_vector3 *p_self, const godot_vector3 *p_b, const godot_real p_t) {
 	godot_vector3 dest;
 	const Vector3 *self = (const Vector3 *)p_self;
 	const Vector3 *b = (const Vector3 *)p_b;
-	*((Vector3 *)&dest) = self->linear_interpolate(*b, p_t);
+	*((Vector3 *)&dest) = self->lerp(*b, p_t);
 	return dest;
 }
 

modules/gdnative/gdnative_api.json

@@ -586,7 +586,7 @@
         ]
       },
       {
-        "name": "godot_color_linear_interpolate",
+        "name": "godot_color_lerp",
         "return_type": "godot_color",
         "arguments": [
           ["const godot_color *", "p_self"],
@@ -710,7 +710,7 @@
         ]
       },
       {
-        "name": "godot_vector2_linear_interpolate",
+        "name": "godot_vector2_lerp",
         "return_type": "godot_vector2",
         "arguments": [
           ["const godot_vector2 *", "p_self"],
@@ -1449,7 +1449,7 @@
         ]
       },
       {
-        "name": "godot_vector3_linear_interpolate",
+        "name": "godot_vector3_lerp",
         "return_type": "godot_vector3",
         "arguments": [
           ["const godot_vector3 *", "p_self"],

modules/gdnative/include/gdnative/color.h

@@ -95,7 +95,7 @@ godot_color GDAPI godot_color_inverted(const godot_color *p_self);
 
 godot_color GDAPI godot_color_contrasted(const godot_color *p_self);
 
-godot_color GDAPI godot_color_linear_interpolate(const godot_color *p_self, const godot_color *p_b, const godot_real p_t);
+godot_color GDAPI godot_color_lerp(const godot_color *p_self, const godot_color *p_b, const godot_real p_t);
 
 godot_color GDAPI godot_color_blend(const godot_color *p_self, const godot_color *p_over);
 

modules/gdnative/include/gdnative/vector2.h

@@ -81,7 +81,7 @@ godot_real GDAPI godot_vector2_angle_to(const godot_vector2 *p_self, const godot
 
 godot_real GDAPI godot_vector2_angle_to_point(const godot_vector2 *p_self, const godot_vector2 *p_to);
 
-godot_vector2 GDAPI godot_vector2_linear_interpolate(const godot_vector2 *p_self, const godot_vector2 *p_b, const godot_real p_t);
+godot_vector2 GDAPI godot_vector2_lerp(const godot_vector2 *p_self, const godot_vector2 *p_b, const godot_real p_t);
 
 godot_vector2 GDAPI godot_vector2_cubic_interpolate(const godot_vector2 *p_self, const godot_vector2 *p_b, const godot_vector2 *p_pre_a, const godot_vector2 *p_post_b, const godot_real p_t);
 

modules/gdnative/include/gdnative/vector3.h

@@ -86,7 +86,7 @@ godot_vector3 GDAPI godot_vector3_snapped(const godot_vector3 *p_self, const god
 
 godot_vector3 GDAPI godot_vector3_rotated(const godot_vector3 *p_self, const godot_vector3 *p_axis, const godot_real p_phi);
 
-godot_vector3 GDAPI godot_vector3_linear_interpolate(const godot_vector3 *p_self, const godot_vector3 *p_b, const godot_real p_t);
+godot_vector3 GDAPI godot_vector3_lerp(const godot_vector3 *p_self, const godot_vector3 *p_b, const godot_real p_t);
 
 godot_vector3 GDAPI godot_vector3_cubic_interpolate(const godot_vector3 *p_self, const godot_vector3 *p_b, const godot_vector3 *p_pre_a, const godot_vector3 *p_post_b, const godot_real p_t);
 

modules/gdscript/doc_classes/@GDScript.xml

@@ -568,7 +568,7 @@
 			<description>
 				Linearly interpolates between two values by a normalized value. This is the opposite of [method inverse_lerp].
 				If the [code]from[/code] and [code]to[/code] arguments are of type [int] or [float], the return value is a [float].
-				If both are of the same vector type ([Vector2], [Vector3] or [Color]), the return value will be of the same type ([code]lerp[/code] then calls the vector type's [code]linear_interpolate[/code] method).
+				If both are of the same vector type ([Vector2], [Vector3] or [Color]), the return value will be of the same type ([code]lerp[/code] then calls the vector type's [code]lerp[/code] method).
 				[codeblock]
 				lerp(0, 4, 0.75) # Returns 3.0
 				lerp(Vector2(1, 5), Vector2(3, 2), 0.5) # Returns Vector2(2, 3.5)

modules/gdscript/gdscript_functions.cpp

@@ -362,13 +362,13 @@ void GDScriptFunctions::call(Function p_func, const Variant **p_args, int p_arg_
 			const double t = (double)*p_args[2];
 			switch (p_args[0]->get_type() == p_args[1]->get_type() ? p_args[0]->get_type() : Variant::FLOAT) {
 				case Variant::VECTOR2: {
-					r_ret = ((Vector2)*p_args[0]).linear_interpolate((Vector2)*p_args[1], t);
+					r_ret = ((Vector2)*p_args[0]).lerp((Vector2)*p_args[1], t);
 				} break;
 				case Variant::VECTOR3: {
-					r_ret = (p_args[0]->operator Vector3()).linear_interpolate(p_args[1]->operator Vector3(), t);
+					r_ret = (p_args[0]->operator Vector3()).lerp(p_args[1]->operator Vector3(), t);
 				} break;
 				case Variant::COLOR: {
-					r_ret = ((Color)*p_args[0]).linear_interpolate((Color)*p_args[1], t);
+					r_ret = ((Color)*p_args[0]).lerp((Color)*p_args[1], t);
 				} break;
 				default: {
 					VALIDATE_ARG_NUM(0);

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

@@ -306,16 +306,26 @@ namespace Godot
             return res;
         }
 
-        public Color LinearInterpolate(Color c, float t)
-        {
-            var res = this;
-
-            res.r += t * (c.r - r);
-            res.g += t * (c.g - g);
-            res.b += t * (c.b - b);
-            res.a += t * (c.a - a);
+        public Color Lerp(Color to, float weight)
+        {
+            return new Color
+            (
+                Mathf.Lerp(r, to.r, weight),
+                Mathf.Lerp(g, to.g, weight),
+                Mathf.Lerp(b, to.b, weight),
+                Mathf.Lerp(a, to.a, weight)
+            );
+        }
 
-            return res;
+        public Color Lerp(Color to, Color weight)
+        {
+            return new Color
+            (
+                Mathf.Lerp(r, to.r, weight.r),
+                Mathf.Lerp(g, to.g, weight.g),
+                Mathf.Lerp(b, to.b, weight.b),
+                Mathf.Lerp(a, to.a, weight.a)
+            );
         }
 
         public uint ToAbgr32()

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

@@ -104,8 +104,8 @@ namespace Godot
             Vector3 destinationLocation = transform.origin;
 
             var interpolated = new Transform();
-            interpolated.basis.SetQuatScale(sourceRotation.Slerp(destinationRotation, c).Normalized(), sourceScale.LinearInterpolate(destinationScale, c));
-            interpolated.origin = sourceLocation.LinearInterpolate(destinationLocation, c);
+            interpolated.basis.SetQuatScale(sourceRotation.Slerp(destinationRotation, c).Normalized(), sourceScale.Lerp(destinationScale, c));
+            interpolated.origin = sourceLocation.Lerp(destinationLocation, c);
 
             return interpolated;
         }

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

@@ -172,7 +172,7 @@ namespace Godot
             if (dot > 0.9995f)
             {
                 // Linearly interpolate to avoid numerical precision issues
-                v = v1.LinearInterpolate(v2, c).Normalized();
+                v = v1.Lerp(v2, c).Normalized();
             }
             else
             {
@@ -186,8 +186,8 @@ namespace Godot
             Vector2 p2 = m.origin;
 
             // Construct matrix
-            var res = new Transform2D(Mathf.Atan2(v.y, v.x), p1.LinearInterpolate(p2, c));
-            Vector2 scale = s1.LinearInterpolate(s2, c);
+            var res = new Transform2D(Mathf.Atan2(v.y, v.x), p1.Lerp(p2, c));
+            Vector2 scale = s1.Lerp(s2, c);
             res.x *= scale;
             res.y *= scale;
 

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

@@ -186,14 +186,22 @@ namespace Godot
             return x * x + y * y;
         }
 
-        public Vector2 LinearInterpolate(Vector2 b, real_t t)
+        public Vector2 Lerp(Vector2 to, real_t weight)
         {
-            var res = this;
-
-            res.x += t * (b.x - x);
-            res.y += t * (b.y - y);
+            return new Vector2
+            (
+                Mathf.Lerp(x, to.x, weight),
+                Mathf.Lerp(y, to.y, weight)
+            );
+        }
 
-            return res;
+        public Vector2 Lerp(Vector2 to, Vector2 weight)
+        {
+            return new Vector2
+            (
+                Mathf.Lerp(x, to.x, weight.x),
+                Mathf.Lerp(y, to.y, weight.y)
+            );
         }
 
         public Vector2 MoveToward(Vector2 to, real_t delta)

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

@@ -184,13 +184,23 @@ namespace Godot
             return x2 + y2 + z2;
         }
 
-        public Vector3 LinearInterpolate(Vector3 b, real_t t)
+        public Vector3 Lerp(Vector3 to, real_t weight)
         {
             return new Vector3
             (
-                x + t * (b.x - x),
-                y + t * (b.y - y),
-                z + t * (b.z - z)
+                Mathf.Lerp(x, to.x, weight),
+                Mathf.Lerp(y, to.y, weight),
+                Mathf.Lerp(z, to.z, weight)
+            );
+        }
+
+        public Vector3 Lerp(Vector3 to, Vector3 weight)
+        {
+            return new Vector3
+            (
+                Mathf.Lerp(x, to.x, weight.x),
+                Mathf.Lerp(y, to.y, weight.y),
+                Mathf.Lerp(z, to.z, weight.z)
             );
         }
 

scene/3d/audio_stream_player_3d.cpp

@@ -556,7 +556,7 @@ void AudioStreamPlayer3D::_notification(int p_what) {
 
 								for (int i = 0; i < vol_index_max; i++) {
 
-									output.reverb_vol[i] = output.reverb_vol[i].linear_interpolate(center_frame, attenuation);
+									output.reverb_vol[i] = output.reverb_vol[i].lerp(center_frame, attenuation);
 								}
 							} else {
 								for (int i = 0; i < vol_index_max; i++) {
@@ -567,7 +567,7 @@ void AudioStreamPlayer3D::_notification(int p_what) {
 
 							for (int i = 0; i < vol_index_max; i++) {
 
-								output.reverb_vol[i] = output.vol[i].linear_interpolate(output.reverb_vol[i] * attenuation, uniformity);
+								output.reverb_vol[i] = output.vol[i].lerp(output.reverb_vol[i] * attenuation, uniformity);
 								output.reverb_vol[i] *= area_send;
 							}
 

scene/3d/skeleton_ik_3d.cpp

@@ -294,7 +294,7 @@ void FabrikInverseKinematic::solve(Task *p_task, real_t blending_delta, bool ove
 	update_chain(p_task->skeleton, &p_task->chain.chain_root);
 
 	if (p_use_magnet && p_task->chain.middle_chain_item) {
-		p_task->chain.magnet_position = p_task->chain.middle_chain_item->initial_transform.origin.linear_interpolate(p_magnet_position, blending_delta);
+		p_task->chain.magnet_position = p_task->chain.middle_chain_item->initial_transform.origin.lerp(p_magnet_position, blending_delta);
 		solve_simple(p_task, true);
 	}
 	solve_simple(p_task, false);

scene/animation/animation_player.cpp

@@ -395,9 +395,9 @@ void AnimationPlayer::_animation_process_animation(AnimationData *p_anim, float
 
 				} else {
 
-					nc->loc_accum = nc->loc_accum.linear_interpolate(loc, p_interp);
+					nc->loc_accum = nc->loc_accum.lerp(loc, p_interp);
 					nc->rot_accum = nc->rot_accum.slerp(rot, p_interp);
-					nc->scale_accum = nc->scale_accum.linear_interpolate(scale, p_interp);
+					nc->scale_accum = nc->scale_accum.lerp(scale, p_interp);
 				}
 
 			} break;

scene/animation/animation_tree.cpp

@@ -958,7 +958,7 @@ void AnimationTree::_process_graph(float p_delta) {
 							if (err != OK)
 								continue;
 
-							t->loc = t->loc.linear_interpolate(loc, blend);
+							t->loc = t->loc.lerp(loc, blend);
 							if (t->rot_blend_accum == 0) {
 								t->rot = rot;
 								t->rot_blend_accum = blend;
@@ -967,7 +967,7 @@ void AnimationTree::_process_graph(float p_delta) {
 								t->rot = rot.slerp(t->rot, t->rot_blend_accum / rot_total).normalized();
 								t->rot_blend_accum = rot_total;
 							}
-							t->scale = t->scale.linear_interpolate(scale, blend);
+							t->scale = t->scale.lerp(scale, blend);
 						}
 
 					} break;

scene/gui/gradient_edit.cpp

@@ -207,7 +207,7 @@ void GradientEdit::_gui_input(const Ref<InputEvent> &p_event) {
 			prev = points[pos];
 		}
 
-		newPoint.color = prev.color.linear_interpolate(next.color, (newPoint.offset - prev.offset) / (next.offset - prev.offset));
+		newPoint.color = prev.color.lerp(next.color, (newPoint.offset - prev.offset) / (next.offset - prev.offset));
 
 		points.push_back(newPoint);
 		points.sort();

scene/gui/graph_edit.cpp

@@ -653,7 +653,7 @@ void GraphEdit::_bake_segment2d(Vector<Vector2> &points, Vector<Color> &colors,
 	if (p_depth >= p_min_depth && (dp < p_tol || p_depth >= p_max_depth)) {
 
 		points.push_back((beg + end) * 0.5);
-		colors.push_back(p_color.linear_interpolate(p_to_color, mp));
+		colors.push_back(p_color.lerp(p_to_color, mp));
 		lines++;
 	} else {
 		_bake_segment2d(points, colors, p_begin, mp, p_a, p_out, p_b, p_in, p_depth + 1, p_min_depth, p_max_depth, p_tol, p_color, p_to_color, lines);
@@ -737,8 +737,8 @@ void GraphEdit::_connections_layer_draw() {
 		Color tocolor = gto->get_connection_input_color(E->get().to_port);
 
 		if (E->get().activity > 0) {
-			color = color.linear_interpolate(activity_color, E->get().activity);
-			tocolor = tocolor.linear_interpolate(activity_color, E->get().activity);
+			color = color.lerp(activity_color, E->get().activity);
+			tocolor = tocolor.lerp(activity_color, E->get().activity);
 		}
 		_draw_cos_line(connections_layer, frompos, topos, color, tocolor);
 	}

scene/resources/animation.cpp

@@ -1570,7 +1570,7 @@ Animation::TransformKey Animation::_interpolate(const Animation::TransformKey &p
 
 Vector3 Animation::_interpolate(const Vector3 &p_a, const Vector3 &p_b, float p_c) const {
 
-	return p_a.linear_interpolate(p_b, p_c);
+	return p_a.lerp(p_b, p_c);
 }
 Quat Animation::_interpolate(const Quat &p_a, const Quat &p_b, float p_c) const {
 
@@ -2432,7 +2432,7 @@ float Animation::bezier_track_interpolate(int p_track, float p_time) const {
 	Vector2 high_pos = _bezier_interp(high, start, start_out, end_in, end);
 	float c = (t - low_pos.x) / (high_pos.x - low_pos.x);
 
-	return low_pos.linear_interpolate(high_pos, c).y;
+	return low_pos.lerp(high_pos, c).y;
 }
 
 int Animation::audio_track_insert_key(int p_track, float p_time, const RES &p_stream, float p_start_offset, float p_end_offset) {

scene/resources/curve.cpp

@@ -796,7 +796,7 @@ Vector2 Curve2D::interpolate_baked(float p_offset, bool p_cubic) const {
 		Vector2 post = (idx < (bpc - 2)) ? r[idx + 2] : r[idx + 1];
 		return r[idx].cubic_interpolate(r[idx + 1], pre, post, frac);
 	} else {
-		return r[idx].linear_interpolate(r[idx + 1], frac);
+		return r[idx].lerp(r[idx + 1], frac);
 	}
 }
 
@@ -1354,7 +1354,7 @@ Vector3 Curve3D::interpolate_baked(float p_offset, bool p_cubic) const {
 		Vector3 post = (idx < (bpc - 2)) ? r[idx + 2] : r[idx + 1];
 		return r[idx].cubic_interpolate(r[idx + 1], pre, post, frac);
 	} else {
-		return r[idx].linear_interpolate(r[idx + 1], frac);
+		return r[idx].lerp(r[idx + 1], frac);
 	}
 }
 

scene/resources/gradient.h

@@ -120,7 +120,7 @@ public:
 			return points[0].color;
 		const Point &pointFirst = points[first];
 		const Point &pointSecond = points[second];
-		return pointFirst.color.linear_interpolate(pointSecond.color, (p_offset - pointFirst.offset) / (pointSecond.offset - pointFirst.offset));
+		return pointFirst.color.lerp(pointSecond.color, (p_offset - pointFirst.offset) / (pointSecond.offset - pointFirst.offset));
 	}
 
 	int get_points_count() const;

servers/rendering/rendering_server_scene.cpp

@@ -1348,15 +1348,15 @@ _FORCE_INLINE_ static void _light_capture_sample_octree(const RasterizerStorage:
 
 	for (int i = 0; i < 2; i++) {
 
-		Vector3 color_x00 = color[i][0].linear_interpolate(color[i][1], pos_fract[i].x);
-		Vector3 color_xy0 = color[i][2].linear_interpolate(color[i][3], pos_fract[i].x);
-		Vector3 blend_z0 = color_x00.linear_interpolate(color_xy0, pos_fract[i].y);
+		Vector3 color_x00 = color[i][0].lerp(color[i][1], pos_fract[i].x);
+		Vector3 color_xy0 = color[i][2].lerp(color[i][3], pos_fract[i].x);
+		Vector3 blend_z0 = color_x00.lerp(color_xy0, pos_fract[i].y);
 
-		Vector3 color_x0z = color[i][4].linear_interpolate(color[i][5], pos_fract[i].x);
-		Vector3 color_xyz = color[i][6].linear_interpolate(color[i][7], pos_fract[i].x);
-		Vector3 blend_z1 = color_x0z.linear_interpolate(color_xyz, pos_fract[i].y);
+		Vector3 color_x0z = color[i][4].lerp(color[i][5], pos_fract[i].x);
+		Vector3 color_xyz = color[i][6].lerp(color[i][7], pos_fract[i].x);
+		Vector3 blend_z1 = color_x0z.lerp(color_xyz, pos_fract[i].y);
 
-		color_interp[i] = blend_z0.linear_interpolate(blend_z1, pos_fract[i].z);
+		color_interp[i] = blend_z0.lerp(blend_z1, pos_fract[i].z);
 
 		float alpha_x00 = Math::lerp(alpha[i][0], alpha[i][1], pos_fract[i].x);
 		float alpha_xy0 = Math::lerp(alpha[i][2], alpha[i][3], pos_fract[i].x);
@@ -1369,7 +1369,7 @@ _FORCE_INLINE_ static void _light_capture_sample_octree(const RasterizerStorage:
 		alpha_interp[i] = Math::lerp(alpha_z0, alpha_z1, pos_fract[i].z);
 	}
 
-	r_color = color_interp[0].linear_interpolate(color_interp[1], level_filter);
+	r_color = color_interp[0].lerp(color_interp[1], level_filter);
 	r_alpha = Math::lerp(alpha_interp[0], alpha_interp[1], level_filter);
 
 	//print_line("pos: " + p_posf + " level " + rtos(p_level) + " down to " + itos(target_level) + "." + rtos(level_filter) + " color " + r_color + " alpha " + rtos(r_alpha));