[Core] Rename linear_interpolate to lerp

48 files changed, 144 insertions, 155 deletions

diff --git a/core/color.h b/core/color.h
index 16dc721072..d95e80f5da 100644
--- a/core/color.h
+++ b/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;
 
diff --git a/core/input/input.cpp b/core/input/input.cpp
index 5301f5f4ee..357e4c06c1 100644
--- a/core/input/input.cpp
+++ b/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);
 	}
 }
 
diff --git a/core/math/audio_frame.h b/core/math/audio_frame.h
index e1dbb385e4..4665311059 100644
--- a/core/math/audio_frame.h
+++ b/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;
 
diff --git a/core/math/geometry.cpp b/core/math/geometry.cpp
index 3e07e9253e..4733c27cbc 100644
--- a/core/math/geometry.cpp
+++ b/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));
diff --git a/core/math/geometry.h b/core/math/geometry.h
index e47d18b056..a86db6e395 100644
--- a/core/math/geometry.h
+++ b/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) {
diff --git a/core/math/transform.cpp b/core/math/transform.cpp
index 9dad3262d2..82e4005d3e 100644
--- a/core/math/transform.cpp
+++ 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;
 }
diff --git a/core/math/transform_2d.cpp b/core/math/transform_2d.cpp
index f28b664e46..97a9216a5a 100644
--- a/core/math/transform_2d.cpp
+++ b/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;
 }
 
diff --git a/core/math/vector2.h b/core/math/vector2.h
index 95d2474838..c0057f2543 100644
--- a/core/math/vector2.h
+++ b/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;
 
diff --git a/core/math/vector3.h b/core/math/vector3.h
index 3bf8644af9..a5e9d09208 100644
--- a/core/math/vector3.h
+++ b/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)),
diff --git a/core/variant_call.cpp b/core/variant_call.cpp
index 483565648a..39bfd04a0b 100644
--- a/core/variant_call.cpp
+++ b/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());
diff --git a/core/variant_op.cpp b/core/variant_op.cpp
index f173c88054..27624b81ee 100644
--- a/core/variant_op.cpp
+++ b/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;
diff --git a/doc/classes/Color.xml b/doc/classes/Color.xml
index d495be2ffd..1af5c87532 100644
--- a/doc/classes/Color.xml
+++ b/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>
diff --git a/doc/classes/Vector2.xml b/doc/classes/Vector2.xml
index 7b02a1a4c9..64ebc1fa09 100644
--- a/doc/classes/Vector2.xml
+++ b/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">
diff --git a/doc/classes/Vector3.xml b/doc/classes/Vector3.xml
index 600c03ba7d..8c18ca8cc9 100644
--- a/doc/classes/Vector3.xml
+++ b/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">
diff --git a/doc/translations/classes.pot b/doc/translations/classes.pot
index 641d80c5ca..d5351403dd 100644
--- a/doc/translations/classes.pot
+++ b/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 ""
diff --git a/doc/translations/fr.po b/doc/translations/fr.po
index 6926376c05..51313f873b 100644
--- a/doc/translations/fr.po
+++ b/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 ""
diff --git a/editor/animation_bezier_editor.cpp b/editor/animation_bezier_editor.cpp
index e6a020bf41..57c63dd40d 100644
--- a/editor/animation_bezier_editor.cpp
+++ b/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);
diff --git a/editor/animation_track_editor_plugins.cpp b/editor/animation_track_editor_plugins.cpp
index 695c294ad2..0ce3ab292e 100644
--- a/editor/animation_track_editor_plugins.cpp
+++ b/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;
 	}
 
diff --git a/editor/debugger/editor_profiler.cpp b/editor/debugger/editor_profiler.cpp
index 1577e24ac0..c7d4e9128a 100644
--- a/editor/debugger/editor_profiler.cpp
+++ b/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() {
diff --git a/editor/debugger/editor_visual_profiler.cpp b/editor/debugger/editor_visual_profiler.cpp
index d2edba5970..7d2822b1c9 100644
--- a/editor/debugger/editor_visual_profiler.cpp
+++ b/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() {
diff --git a/editor/editor_help.cpp b/editor/editor_help.cpp
index 75d1b2595a..8089d463bd 100644
--- a/editor/editor_help.cpp
+++ b/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();
 
diff --git a/editor/editor_themes.cpp b/editor/editor_themes.cpp
index 576ee436de..0ef173f074 100644
--- a/editor/editor_themes.cpp
+++ b/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;
diff --git a/editor/node_3d_editor_gizmos.cpp b/editor/node_3d_editor_gizmos.cpp
index 31a8320209..9a5df3e58f 100644
--- a/editor/node_3d_editor_gizmos.cpp
+++ b/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);
 		}
diff --git a/editor/plugins/animation_state_machine_editor.cpp b/editor/plugins/animation_state_machine_editor.cpp
index c28f533958..ed51a2d2cf 100644
--- a/editor/plugins/animation_state_machine_editor.cpp
+++ b/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);
 }
diff --git a/editor/plugins/canvas_item_editor_plugin.cpp b/editor/plugins/canvas_item_editor_plugin.cpp
index 79111762b2..e882b3a8d7 100644
--- a/editor/plugins/canvas_item_editor_plugin.cpp
+++ b/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);
 			}
diff --git a/editor/plugins/node_3d_editor_plugin.cpp b/editor/plugins/node_3d_editor_plugin.cpp
index af34dd5cab..c8f0671390 100644
--- a/editor/plugins/node_3d_editor_plugin.cpp
+++ b/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);
 	}
diff --git a/editor/plugins/script_editor_plugin.cpp b/editor/plugins/script_editor_plugin.cpp
index 80d97e7fa9..35a08f2d1c 100644
--- a/editor/plugins/script_editor_plugin.cpp
+++ 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));
 		}
 	}
 }
diff --git a/editor/rename_dialog.cpp b/editor/rename_dialog.cpp
index 0266ef6a2b..8ae8d0991d 100644
--- a/editor/rename_dialog.cpp
+++ b/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"));
 		}
diff --git a/modules/csg/csg.cpp b/modules/csg/csg.cpp
index 3f61e2852f..6714db76bb 100644
--- a/modules/csg/csg.cpp
+++ b/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) {
diff --git a/modules/gdnative/gdnative/color.cpp b/modules/gdnative/gdnative/color.cpp
index 914d5b03f4..68c83e05a6 100644
--- a/modules/gdnative/gdnative/color.cpp
+++ b/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;
 }
 
diff --git a/modules/gdnative/gdnative/vector2.cpp b/modules/gdnative/gdnative/vector2.cpp
index e9e2a8edf8..dc273e7951 100644
--- a/modules/gdnative/gdnative/vector2.cpp
+++ b/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;
 }
 
diff --git a/modules/gdnative/gdnative/vector3.cpp b/modules/gdnative/gdnative/vector3.cpp
index e34a9370a5..bb27ad5a00 100644
--- a/modules/gdnative/gdnative/vector3.cpp
+++ b/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;
 }
 
diff --git a/modules/gdnative/gdnative_api.json b/modules/gdnative/gdnative_api.json
index 9473a3d419..d5ab62dc61 100644
--- a/modules/gdnative/gdnative_api.json
+++ b/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"],
diff --git a/modules/gdnative/include/gdnative/color.h b/modules/gdnative/include/gdnative/color.h
index 47c01dbb20..e7737bf8e1 100644
--- a/modules/gdnative/include/gdnative/color.h
+++ b/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);
 
diff --git a/modules/gdnative/include/gdnative/vector2.h b/modules/gdnative/include/gdnative/vector2.h
index 15a1a6063b..c11e23a586 100644
--- a/modules/gdnative/include/gdnative/vector2.h
+++ b/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);
 
diff --git a/modules/gdnative/include/gdnative/vector3.h b/modules/gdnative/include/gdnative/vector3.h
index 1b344590ea..8ebf15b724 100644
--- a/modules/gdnative/include/gdnative/vector3.h
+++ b/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);
 
diff --git a/modules/gdscript/doc_classes/@GDScript.xml b/modules/gdscript/doc_classes/@GDScript.xml
index 9324691df5..be159b6407 100644
--- a/modules/gdscript/doc_classes/@GDScript.xml
+++ b/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)
diff --git a/modules/gdscript/gdscript_functions.cpp b/modules/gdscript/gdscript_functions.cpp
index 9154d6eb89..58161d6f53 100644
--- a/modules/gdscript/gdscript_functions.cpp
+++ b/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);
diff --git a/scene/3d/audio_stream_player_3d.cpp b/scene/3d/audio_stream_player_3d.cpp
index 097368853e..28a8b01437 100644
--- a/scene/3d/audio_stream_player_3d.cpp
+++ b/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;
 							}
 
diff --git a/scene/3d/skeleton_ik_3d.cpp b/scene/3d/skeleton_ik_3d.cpp
index 7366290ed3..e8a9d5bf57 100644
--- a/scene/3d/skeleton_ik_3d.cpp
+++ b/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);
diff --git a/scene/animation/animation_player.cpp b/scene/animation/animation_player.cpp
index 946f759610..9ef6b9864a 100644
--- a/scene/animation/animation_player.cpp
+++ b/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;
diff --git a/scene/animation/animation_tree.cpp b/scene/animation/animation_tree.cpp
index f8b3ca291b..56e224819f 100644
--- a/scene/animation/animation_tree.cpp
+++ b/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;
diff --git a/scene/gui/gradient_edit.cpp b/scene/gui/gradient_edit.cpp
index 88107f754c..a6ed3d8de9 100644
--- a/scene/gui/gradient_edit.cpp
+++ b/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();
diff --git a/scene/gui/graph_edit.cpp b/scene/gui/graph_edit.cpp
index 3af730de23..0bf67df9b4 100644
--- a/scene/gui/graph_edit.cpp
+++ b/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);
 	}
diff --git a/scene/resources/animation.cpp b/scene/resources/animation.cpp
index aa4c9bf225..ea4338519e 100644
--- a/scene/resources/animation.cpp
+++ b/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) {
diff --git a/scene/resources/curve.cpp b/scene/resources/curve.cpp
index d19eae0d4f..ae705a47e8 100644
--- a/scene/resources/curve.cpp
+++ b/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);
 	}
 }
 
diff --git a/scene/resources/gradient.h b/scene/resources/gradient.h
index 2d98f799e2..573749ea7e 100644
--- a/scene/resources/gradient.h
+++ b/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;
diff --git a/servers/rendering/rendering_server_scene.cpp b/servers/rendering/rendering_server_scene.cpp
index 9d141ea570..337eb5995f 100644
--- a/servers/rendering/rendering_server_scene.cpp
+++ b/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));