Linear Interpolation, or its commonly-used abbreviation lerp, is a term that comes up often in game development. If you’ve never come across it before it can seem mysterious and highly-technical, but as you’ll see in this tutorial, it’s actually a straightforward concept with a wide variety of applications in game programming.
The core formula for linear interpolation is this:
func lerp(a, b, t): return (1 - t) * a + t * b
In this formula,
b represent the two values and
t is the amount of interpolation, typically expressed as a value between
0 (which returns
1 (which returns
b). The function finds a value the given amount between the two. For example:
x = lerp(0, 1, 0.75) # x is 0.75 x = lerp(0, 100, 0.5) # x is 50 x = lerp(10, 75, 0.3) # x is 29.5 x = lerp(30, 2, 0.75) # x is 9
It’s called linear interpolation because the path between the two points is a straight line.
You can animate a node’s properties with
lerp(). For example, if you divide the elapsed time by the desired duration, you’ll get a value between zero and one you can use to alter a property smoothly over time. This script scales a sprite up to five times its starting size while fading it out (using
modulate.a) over two seconds:
extends Sprite2D var time = 0 var duration = 2 # length of the effect func _process(delta): if time < duration: time += delta modulate.a = lerp(1, 0, time / duration) scale = Vector2.ONE * lerp(1, 5, time / duration)
You can also interpolate between vectors. Both
linear_interpolate() methods for this.
For example, to find a vector that’s halfway between a
Spatial node’s forward and left direction vectors:
var forward = -transform.basis.z var left = transform.basis.x var forward_left = forward.linear_interpolate(left, 0.5)
The following example moves a Sprite node towards the mouse click position. Each frame the node moves 10% of the way to the target. This results in an “approach” effect, where the object’s speed becomes slower the closer it gets to the target.
extends Sprite2D var target func _input(event): if event is InputEventMouseButton and event.pressed: target = event.position func _process(delta): if target: position = position.linear_interpolate(target, 0.1)
For more advanced applications of interpolation, see