# Interpolation

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.

## Numeric Interpolation

The core formula for linear interpolation is this:

``````func lerp(a, b, t):
return (1 - t) * a + t * b
``````

In this formula, `a` and `b` represent the two values and `t` is the amount of interpolation, typically expressed as a value between `0` (which returns `a`), and `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)
``````

## Vector interpolation

You can also interpolate between vectors. Both `Vector2` and `Vector3` provide `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 `Tween`.