godotengine/godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[Core] Rename linear_interpolate to lerp

Browse Source
This commit is contained in:
Aaron Franke 2020-03-16 05:07:33 -04:00
parent ad3c3e1bbb
commit 540156b387
No known key found for this signature in database
GPG Key ID: 40A1750B977E56BF
48 changed files with 146 additions and 157 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
core/color.h
View File

@ -97,7 +97,7 @@ struct Color {
Color inverted() const; Color inverted() const;
Color contrasted() 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; Color res = *this;

2
core/input/input.cpp
View File

@ -175,7 +175,7 @@ void Input::SpeedTrack::update(const Vector2 &p_delta_p) {
accum = accum - slice; accum = accum - slice;
accum_t -= min_ref_frame; 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);
} }
} }

2
core/math/audio_frame.h
View File

@ -104,7 +104,7 @@ struct AudioFrame {
r = ::undenormalise(r); 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; AudioFrame res = *this;

4
core/math/geometry.cpp
View File

@ -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++) { for (int j = 1; j <= p_lats; j++) {
// FIXME: This is stupid. // 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; Vector3 pos = angle * p_radius;
planes.push_back(Plane(pos, angle)); planes.push_back(Plane(pos, angle));
planes.push_back(Plane(pos * axis_neg, angle * axis_neg)); 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++) { 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; Vector3 pos = axis * p_height * 0.5 + angle * p_radius;
planes.push_back(Plane(pos, angle)); planes.push_back(Plane(pos, angle));
planes.push_back(Plane(pos * axis_neg, angle * axis_neg)); planes.push_back(Plane(pos * axis_neg, angle * axis_neg));

4
core/math/geometry.h
View File

@ -117,8 +117,8 @@ public:
if (mub < 0) mub = 0; if (mub < 0) mub = 0;
if (mua > 1) mua = 1; if (mua > 1) mua = 1;
if (mub > 1) mub = 1; if (mub > 1) mub = 1;
c1 = p1.linear_interpolate(p2, mua); c1 = p1.lerp(p2, mua);
c2 = q1.linear_interpolate(q2, mub); 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) { 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) {

4
core/math/transform.cpp
View File

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

6
core/math/transform_2d.cpp
View File

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

15
core/math/vector2.h
View File

@ -82,8 +82,7 @@ struct Vector2 {
Vector2 clamped(real_t p_len) const; 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 lerp(const Vector2 &p_b, real_t p_t) const;
_FORCE_INLINE_ Vector2 linear_interpolate(const Vector2 &p_b, real_t p_t) const;
_FORCE_INLINE_ Vector2 slerp(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 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; 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; 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; Vector2 res = *this;
@ -248,16 +247,6 @@ Vector2 Vector2::direction_to(const Vector2 &p_b) const {
return ret; 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 Size2;
typedef Vector2 Point2; typedef Vector2 Point2;

4
core/math/vector3.h
View File

@ -89,7 +89,7 @@ struct Vector3 {
/* Static Methods between 2 vector3s */ /* 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; _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_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; 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)); 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( return Vector3(
x + (p_t * (p_b.x - x)), x + (p_t * (p_b.x - x)),

12
core/variant_call.cpp
View File

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

16
core/variant_op.cpp
View File

@ -4220,7 +4220,7 @@ void Variant::interpolate(const Variant &a, const Variant &b, float c, Variant &
} }
return; return;
case VECTOR2: { 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; return;
case VECTOR2I: { case VECTOR2I: {
@ -4233,7 +4233,7 @@ void Variant::interpolate(const Variant &a, const Variant &b, float c, Variant &
return; return;
case RECT2: { 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; return;
case RECT2I: { case RECT2I: {
@ -4254,7 +4254,7 @@ void Variant::interpolate(const Variant &a, const Variant &b, float c, Variant &
return; return;
case VECTOR3: { 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; return;
case VECTOR3I: { case VECTOR3I: {
@ -4281,7 +4281,7 @@ void Variant::interpolate(const Variant &a, const Variant &b, float c, Variant &
} }
return; return;
case AABB: { 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; return;
case BASIS: { case BASIS: {
@ -4293,7 +4293,7 @@ void Variant::interpolate(const Variant &a, const Variant &b, float c, Variant &
} }
return; return;
case COLOR: { 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; return;
case STRING_NAME: { 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(); const Vector2 *br = arr_b->ptr();
for (int i = 0; i < sz; i++) { 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; 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(); const Vector3 *br = arr_b->ptr();
for (int i = 0; i < sz; i++) { 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; 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(); const Color *br = arr_b->ptr();
for (int i = 0; i < sz; i++) { 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; r_dst = v;

30
doc/classes/Color.xml
View File

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

2
doc/classes/Vector2.xml
View File

@ -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. 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> </description>
</method> </method>
<method name="linear_interpolate"> <method name="lerp">
<return type="Vector2"> <return type="Vector2">
</return> </return>
<argument index="0" name="b" type="Vector2"> <argument index="0" name="b" type="Vector2">

2
doc/classes/Vector3.xml
View File

@ -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. 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> </description>
</method> </method>
<method name="linear_interpolate"> <method name="lerp">
<return type="Vector3"> <return type="Vector3">
</return> </return>
<argument index="0" name="b" type="Vector3"> <argument index="0" name="b" type="Vector3">

4
doc/translations/classes.pot
View File

@ -480,7 +480,7 @@ msgid ""
"[float], the return value is a [float].\n" "[float], the return value is a [float].\n"
"If both are of the same vector type ([Vector2], [Vector3] or [Color]), the " "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 " "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" "[codeblock]\n"
"lerp(0, 4, 0.75) # Returns 3.0\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" "lerp(Vector2(1, 5), Vector2(3, 2), 0.5) # Returns Vector2(2, 3.5)\n"
@ -12703,7 +12703,7 @@ msgid ""
"[codeblock]\n" "[codeblock]\n"
"var c1 = Color(1.0, 0.0, 0.0)\n" "var c1 = Color(1.0, 0.0, 0.0)\n"
"var c2 = Color(0.0, 1.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" "255)\n"
"[/codeblock]" "[/codeblock]"
msgstr "" msgstr ""

4
doc/translations/fr.po
View File

@ -490,7 +490,7 @@ msgid ""
"[float], the return value is a [float].\n" "[float], the return value is a [float].\n"
"If both are of the same vector type ([Vector2], [Vector3] or [Color]), the " "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 " "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" "[codeblock]\n"
"lerp(0, 4, 0.75) # Returns 3.0\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" "lerp(Vector2(1, 5), Vector2(3, 2), 0.5) # Returns Vector2(2, 3.5)\n"
@ -12713,7 +12713,7 @@ msgid ""
"[codeblock]\n" "[codeblock]\n"
"var c1 = Color(1.0, 0.0, 0.0)\n" "var c1 = Color(1.0, 0.0, 0.0)\n"
"var c2 = Color(0.0, 1.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" "255)\n"
"[/codeblock]" "[/codeblock]"
msgstr "" msgstr ""

6
editor/animation_bezier_editor.cpp
View File

@ -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); 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); 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) { if (to.x > p_clip_right) {
float c = (p_clip_right - from.x) / (to.x - from.x); 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) { if (from.x < p_clip_left) {
float c = (p_clip_left - from.x) / (to.x - from.x); 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); draw_line(from, to, p_color);

4
editor/animation_track_editor_plugins.cpp
View File

@ -112,13 +112,13 @@ void AnimationTrackEditColor::draw_key_link(int p_index, float p_pixels_sec, int
if (x_from < p_clip_left) { if (x_from < p_clip_left) {
float c = float(p_clip_left - x_from) / (x_to - x_from); 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; x_from = p_clip_left;
} }
if (x_to > p_clip_right) { if (x_to > p_clip_right) {
float c = float(p_clip_right - x_from) / (x_to - x_from); 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; x_to = p_clip_right;
} }

2
editor/debugger/editor_profiler.cpp
View File

@ -136,7 +136,7 @@ Color EditorProfiler::_get_color_from_signature(const StringName &p_signature) c
double rot = ABS(double(p_signature.hash()) / double(0x7FFFFFFF)); double rot = ABS(double(p_signature.hash()) / double(0x7FFFFFFF));
Color c; Color c;
c.set_hsv(rot, bc.get_s(), bc.get_v()); 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() { void EditorProfiler::_item_edited() {

2
editor/debugger/editor_visual_profiler.cpp
View File

@ -132,7 +132,7 @@ Color EditorVisualProfiler::_get_color_from_signature(const StringName &p_signat
double rot = ABS(double(p_signature.hash()) / double(0x7FFFFFFF)); double rot = ABS(double(p_signature.hash()) / double(0x7FFFFFFF));
Color c; Color c;
c.set_hsv(rot, bc.get_s(), bc.get_v()); 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() { void EditorVisualProfiler::_item_selected() {

12
editor/editor_help.cpp
View File

@ -47,12 +47,12 @@ void EditorHelp::_init_colors() {
title_color = get_theme_color("accent_color", "Editor"); title_color = get_theme_color("accent_color", "Editor");
text_color = get_theme_color("default_color", "RichTextLabel"); text_color = get_theme_color("default_color", "RichTextLabel");
headline_color = get_theme_color("headline_color", "EditorHelp"); 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); comment_color = text_color * Color(1, 1, 1, 0.6);
symbol_color = comment_color; symbol_color = comment_color;
value_color = text_color * Color(1, 1, 1, 0.6); value_color = text_color * Color(1, 1, 1, 0.6);
qualifier_color = text_color * Color(1, 1, 1, 0.8); 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_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)); 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 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); class_desc->push_color(type_color);
bool add_array = false; bool add_array = false;
if (can_ref) { 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 font_color_hl = p_rt->get_theme_color("headline_color", "EditorHelp");
Color accent_color = p_rt->get_theme_color("accent_color", "Editor"); Color accent_color = p_rt->get_theme_color("accent_color", "Editor");
Color property_color = p_rt->get_theme_color("property_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 link_color = accent_color.lerp(font_color_hl, 0.8);
Color code_color = accent_color.linear_interpolate(font_color_hl, 0.6); Color code_color = accent_color.lerp(font_color_hl, 0.6);
Color kbd_color = accent_color.linear_interpolate(property_color, 0.6); Color kbd_color = accent_color.lerp(property_color, 0.6);
String bbcode = p_bbcode.dedent().replace("\t", "").replace("\r", "").strip_edges(); String bbcode = p_bbcode.dedent().replace("\t", "").replace("\r", "").strip_edges();

50
editor/editor_themes.cpp
View File

@ -337,24 +337,24 @@ Ref<Theme> create_editor_theme(const Ref<Theme> p_theme) {
//Colors //Colors
bool dark_theme = EditorSettings::get_singleton()->is_dark_theme(); 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_1 = base_color.lerp(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_2 = base_color.lerp(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_3 = base_color.lerp(Color(0, 0, 0, 1), contrast * 2);
const Color background_color = dark_color_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 // 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 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_1 = base_color.lerp(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_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 = mono_color.lerp(base_color, 0.25);
const Color font_color_hl = mono_color.linear_interpolate(base_color, 0.15); 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_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 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 = mono_color.inverted().lerp(base_color, 0.7);
const Color color_disabled_bg = mono_color.inverted().linear_interpolate(base_color, 0.9); 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); Color icon_color_hover = Color(1, 1, 1) * (dark_theme ? 1.15 : 1.45);
icon_color_hover.a = 1.0; 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 success_color = Color(0.45, 0.95, 0.5);
Color warning_color = Color(1, 0.87, 0.4); Color warning_color = Color(1, 0.87, 0.4);
Color error_color = Color(1, 0.47, 0.42); 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) { if (!dark_theme) {
// Darken some colors to be readable on a light background // Darken some colors to be readable on a light background
success_color = success_color.linear_interpolate(mono_color, 0.35); success_color = success_color.lerp(mono_color, 0.35);
warning_color = warning_color.linear_interpolate(mono_color, 0.35); warning_color = warning_color.lerp(mono_color, 0.35);
error_color = error_color.linear_interpolate(mono_color, 0.25); error_color = error_color.lerp(mono_color, 0.25);
} }
theme->set_color("success_color", "Editor", success_color); 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); editor_register_fonts(theme);
// Highlighted tabs and border width // 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 border_width = CLAMP(border_size, 0, 3) * EDSCALE;
const int default_margin_size = 4; 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_icon("visibility_xray", "PopupMenu", theme->get_icon("GuiVisibilityXray", "EditorIcons"));
theme->set_constant("vseparation", "PopupMenu", (extra_spacing + default_margin_size + 1) * EDSCALE); 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_LEFT, 2);
sub_inspector_bg->set_border_width(MARGIN_RIGHT, 2); sub_inspector_bg->set_border_width(MARGIN_RIGHT, 2);
sub_inspector_bg->set_border_width(MARGIN_BOTTOM, 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_hover", "Tree", style_tree_title);
theme->set_stylebox("title_button_pressed", "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_category_color = dark_color_1.lerp(mono_color, 0.12);
Color prop_section_color = dark_color_1.linear_interpolate(mono_color, 0.09); Color prop_section_color = dark_color_1.lerp(mono_color, 0.09);
Color prop_subsection_color = dark_color_1.linear_interpolate(mono_color, 0.06); 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_category", "Editor", prop_category_color);
theme->set_color("prop_section", "Editor", prop_section_color); theme->set_color("prop_section", "Editor", prop_section_color);
theme->set_color("prop_subsection", "Editor", prop_subsection_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")); 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. // 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. // 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); theme->set_color("files_disabled", "FileDialog", font_color_disabled);
// color picker // color picker
@ -1158,13 +1158,13 @@ Ref<Theme> create_editor_theme(const Ref<Theme> p_theme) {
// editor main color // 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 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 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 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 type_color = basetype_color.lerp(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 usertype_color = basetype_color.lerp(mono_color, dark_theme ? 0.7 : 0.5);
const Color comment_color = dim_color; 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 te_background_color = dark_theme ? background_color : base_color;
const Color completion_background_color = dark_theme ? base_color : background_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 current_line_color = alpha1;
const Color line_length_guideline_color = dark_theme ? base_color : background_color; const Color line_length_guideline_color = dark_theme ? base_color : background_color;
const Color word_highlighted_color = alpha1; 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 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 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 bookmark_color = Color(0.08, 0.49, 0.98);
const Color breakpoint_color = error_color; const Color breakpoint_color = error_color;

4
editor/node_3d_editor_gizmos.cpp
View File

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

2
editor/plugins/animation_state_machine_editor.cpp
View File

@ -885,7 +885,7 @@ void AnimationNodeStateMachineEditor::_state_machine_pos_draw() {
state_machine_play_pos->draw_line(from, to, bg, 2); 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); state_machine_play_pos->draw_line(from, to, fg, 2);
} }

14
editor/plugins/canvas_item_editor_plugin.cpp
View File

@ -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(); Vector2 direction = (joints_pos[node_id + 1] - joints_pos[node_id]).normalized();
int len = E->get(); int len = E->get();
if (E == se->pre_drag_bones_length.front()) { 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()) { } 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 { } else {
Vector2 center = (joints_pos[node_id + 1] + joints_pos[node_id]) / 2.0; 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] = joints_pos[node_id].lerp(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 + 1] = joints_pos[node_id + 1].lerp(center + (direction * len) / 2.0, solver_k);
} }
node_id++; node_id++;
} }
@ -2698,7 +2698,7 @@ void CanvasItemEditor::_draw_smart_snapping() {
void CanvasItemEditor::_draw_rulers() { void CanvasItemEditor::_draw_rulers() {
Color bg_color = get_theme_color("dark_color_2", "Editor"); 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"); Color font_color = get_theme_color("font_color", "Editor");
font_color.a = 0.8; font_color.a = 0.8;
Ref<Font> font = get_theme_font("rulers", "EditorFonts"); Ref<Font> font = get_theme_font("rulers", "EditorFonts");
@ -3072,8 +3072,8 @@ void CanvasItemEditor::_draw_control_helpers(Control *control) {
Vector2 line_ends[4]; Vector2 line_ends[4];
for (int i = 0; i < 4; i++) { for (int i = 0; i < 4; i++) {
float anchor_val = (i >= 2) ? ANCHOR_END - anchors_values[i] : anchors_values[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_starts[i] = corners_pos[i].lerp(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_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; 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); 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);
} }

8
editor/plugins/node_3d_editor_plugin.cpp
View File

@ -268,7 +268,7 @@ void Node3DEditorViewport::_update_camera(float p_interp_delta) {
real_t factor = (1.0 / inertia) * 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 // 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"); float orbit_inertia = EDITOR_GET("editors/3d/navigation_feel/orbit_inertia");
orbit_inertia = MAX(0.0001, 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.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))); 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_color(Color(1.0, 1.0, 0.8, 0.8));
st->add_vertex(a); st->add_vertex(a);
st->add_color(Color(1.0, 1.0, 0.8, 0.4)); 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_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_color(Color(1.0, 1.0, 0.8, 0.8));
st->add_vertex(b); st->add_vertex(b);
} }

2
editor/plugins/script_editor_plugin.cpp
View File

@ -1742,7 +1742,7 @@ void ScriptEditor::_update_script_colors() {
int non_zero_hist_size = (hist_size == 0) ? 1 : hist_size; 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); 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));
} }
} }
} }

2
editor/rename_dialog.cpp
View File

@ -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. // 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 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"); 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 { } else {
lbl_preview->add_theme_color_override("font_color", EditorNode::get_singleton()->get_gui_base()->get_theme_color("success_color", "Editor")); lbl_preview->add_theme_color_override("font_color", EditorNode::get_singleton()->get_gui_base()->get_theme_color("success_color", "Editor"));
} }

2
modules/csg/csg.cpp
View File

@ -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 distance = (p_interpolation_point - p_segement_points[0]).length();
float fraction = distance / segment_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) { inline static Vector2 interpolate_triangle_uv(const Vector2 p_vertices[3], const Vector2 p_uvs[3], const Vector2 &p_interpolation_point) {

4
modules/gdnative/gdnative/color.cpp
View File

@ -155,11 +155,11 @@ godot_color GDAPI godot_color_contrasted(const godot_color *p_self) {
return dest; 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; godot_color dest;
const Color *self = (const Color *)p_self; const Color *self = (const Color *)p_self;
const Color *b = (const Color *)p_b; const Color *b = (const Color *)p_b;
*((Color *)&dest) = self->linear_interpolate(*b, p_t); *((Color *)&dest) = self->lerp(*b, p_t);
return dest; return dest;
} }

4
modules/gdnative/gdnative/vector2.cpp
View File

@ -109,11 +109,11 @@ godot_real GDAPI godot_vector2_angle_to_point(const godot_vector2 *p_self, const
return self->angle_to_point(*to); 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; godot_vector2 dest;
const Vector2 *self = (const Vector2 *)p_self; const Vector2 *self = (const Vector2 *)p_self;
const Vector2 *b = (const Vector2 *)p_b; const Vector2 *b = (const Vector2 *)p_b;
*((Vector2 *)&dest) = self->linear_interpolate(*b, p_t); *((Vector2 *)&dest) = self->lerp(*b, p_t);
return dest; return dest;
} }

4
modules/gdnative/gdnative/vector3.cpp
View File

@ -106,11 +106,11 @@ godot_vector3 GDAPI godot_vector3_rotated(const godot_vector3 *p_self, const god
return dest; 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; godot_vector3 dest;
const Vector3 *self = (const Vector3 *)p_self; const Vector3 *self = (const Vector3 *)p_self;
const Vector3 *b = (const Vector3 *)p_b; const Vector3 *b = (const Vector3 *)p_b;
*((Vector3 *)&dest) = self->linear_interpolate(*b, p_t); *((Vector3 *)&dest) = self->lerp(*b, p_t);
return dest; return dest;
} }

6
modules/gdnative/gdnative_api.json
View File

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

2
modules/gdnative/include/gdnative/color.h
View File

@ -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_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); godot_color GDAPI godot_color_blend(const godot_color *p_self, const godot_color *p_over);

2
modules/gdnative/include/gdnative/vector2.h
View File

@ -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_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); 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);

2
modules/gdnative/include/gdnative/vector3.h
View File

@ -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_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); 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);

2
modules/gdscript/doc_classes/@GDScript.xml
View File

@ -568,7 +568,7 @@
<description> <description>
Linearly interpolates between two values by a normalized value. This is the opposite of [method inverse_lerp]. 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 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] [codeblock]
lerp(0, 4, 0.75) # Returns 3.0 lerp(0, 4, 0.75) # Returns 3.0
lerp(Vector2(1, 5), Vector2(3, 2), 0.5) # Returns Vector2(2, 3.5) lerp(Vector2(1, 5), Vector2(3, 2), 0.5) # Returns Vector2(2, 3.5)

6
modules/gdscript/gdscript_functions.cpp
View File

@ -362,13 +362,13 @@ void GDScriptFunctions::call(Function p_func, const Variant **p_args, int p_arg_
const double t = (double)*p_args[2]; 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) { switch (p_args[0]->get_type() == p_args[1]->get_type() ? p_args[0]->get_type() : Variant::FLOAT) {
case Variant::VECTOR2: { 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; } break;
case Variant::VECTOR3: { 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; } break;
case Variant::COLOR: { 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; } break;
default: { default: {
VALIDATE_ARG_NUM(0); VALIDATE_ARG_NUM(0);

4
scene/3d/audio_stream_player_3d.cpp
View File

@ -556,7 +556,7 @@ void AudioStreamPlayer3D::_notification(int p_what) {
for (int i = 0; i < vol_index_max; i++) { 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 { } else {
for (int i = 0; i < vol_index_max; i++) { 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++) { 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; output.reverb_vol[i] *= area_send;
} }

2
scene/3d/skeleton_ik_3d.cpp
View File

@ -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); update_chain(p_task->skeleton, &p_task->chain.chain_root);
if (p_use_magnet && p_task->chain.middle_chain_item) { 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, true);
} }
solve_simple(p_task, false); solve_simple(p_task, false);

4
scene/animation/animation_player.cpp
View File

@ -395,9 +395,9 @@ void AnimationPlayer::_animation_process_animation(AnimationData *p_anim, float
} else { } 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->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; } break;

4
scene/animation/animation_tree.cpp
View File

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

2
scene/gui/gradient_edit.cpp
View File

@ -207,7 +207,7 @@ void GradientEdit::_gui_input(const Ref<InputEvent> &p_event) {
prev = points[pos]; 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.push_back(newPoint);
points.sort(); points.sort();

6
scene/gui/graph_edit.cpp
View File

@ -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)) { if (p_depth >= p_min_depth && (dp < p_tol || p_depth >= p_max_depth)) {
points.push_back((beg + end) * 0.5); 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++; lines++;
} else { } 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); _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); Color tocolor = gto->get_connection_input_color(E->get().to_port);
if (E->get().activity > 0) { if (E->get().activity > 0) {
color = color.linear_interpolate(activity_color, E->get().activity); color = color.lerp(activity_color, E->get().activity);
tocolor = tocolor.linear_interpolate(activity_color, E->get().activity); tocolor = tocolor.lerp(activity_color, E->get().activity);
} }
_draw_cos_line(connections_layer, frompos, topos, color, tocolor); _draw_cos_line(connections_layer, frompos, topos, color, tocolor);
} }

4
scene/resources/animation.cpp
View File

@ -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 { 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 { 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); Vector2 high_pos = _bezier_interp(high, start, start_out, end_in, end);
float c = (t - low_pos.x) / (high_pos.x - low_pos.x); 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) { int Animation::audio_track_insert_key(int p_track, float p_time, const RES &p_stream, float p_start_offset, float p_end_offset) {

4
scene/resources/curve.cpp
View File

@ -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]; Vector2 post = (idx < (bpc - 2)) ? r[idx + 2] : r[idx + 1];
return r[idx].cubic_interpolate(r[idx + 1], pre, post, frac); return r[idx].cubic_interpolate(r[idx + 1], pre, post, frac);
} else { } 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]; Vector3 post = (idx < (bpc - 2)) ? r[idx + 2] : r[idx + 1];
return r[idx].cubic_interpolate(r[idx + 1], pre, post, frac); return r[idx].cubic_interpolate(r[idx + 1], pre, post, frac);
} else { } else {
return r[idx].linear_interpolate(r[idx + 1], frac); return r[idx].lerp(r[idx + 1], frac);
} }
} }

2
scene/resources/gradient.h
View File

@ -120,7 +120,7 @@ public:
return points[0].color; return points[0].color;
const Point &pointFirst = points[first]; const Point &pointFirst = points[first];
const Point &pointSecond = points[second]; 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; int get_points_count() const;

16
servers/rendering/rendering_server_scene.cpp
View File

@ -1348,15 +1348,15 @@ _FORCE_INLINE_ static void _light_capture_sample_octree(const RasterizerStorage:
for (int i = 0; i < 2; i++) { for (int i = 0; i < 2; i++) {
Vector3 color_x00 = color[i][0].linear_interpolate(color[i][1], pos_fract[i].x); Vector3 color_x00 = color[i][0].lerp(color[i][1], pos_fract[i].x);
Vector3 color_xy0 = color[i][2].linear_interpolate(color[i][3], pos_fract[i].x); Vector3 color_xy0 = color[i][2].lerp(color[i][3], pos_fract[i].x);
Vector3 blend_z0 = color_x00.linear_interpolate(color_xy0, pos_fract[i].y); 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_x0z = color[i][4].lerp(color[i][5], pos_fract[i].x);
Vector3 color_xyz = color[i][6].linear_interpolate(color[i][7], pos_fract[i].x); Vector3 color_xyz = color[i][6].lerp(color[i][7], pos_fract[i].x);
Vector3 blend_z1 = color_x0z.linear_interpolate(color_xyz, pos_fract[i].y); 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_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); 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); 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); 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)); //print_line("pos: " + p_posf + " level " + rtos(p_level) + " down to " + itos(target_level) + "." + rtos(level_filter) + " color " + r_color + " alpha " + rtos(r_alpha));