[Mono] Rename LinearInterpolate to Lerp

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

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

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

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

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

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

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

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

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

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