How to use Lerp in Unity. Like a BOSS.

Hello there!

I heard you want to make videogames. I know you want to make GOOD videogames. Am I right? Then keep reading. =)

Lerp stands for Linear Interpolation. The meaning of it is very simple: you have 2 numbers and you need to find some value in the middle.

This is a LERP example with two points. It is not that bad :)

Let's see how it works. Usually Lerp has 3 parameters. Lets see some example:

// Example values
value1 = 10;
value2 = 20;
result = Mathf.Lerp(value1, value2, 0.5f);
// result == 15

What is so great about Lerp is that it can be used with pretty much anything! Vectors, Rotations (Quaternions), even Colors!

I made an small example where you can see different effects that can be achieved using different kinds of Lerp:

"What time is it?" - Lerp time!

As you can see, the characters move from left to right, at the same time. But they do not do it in the same way. That is because there is at least two ways of effectively use lerp to "animate" elements of the game.

The first kind of lerp is what I call "Smooth". Smooth is fast at the beginning but slows down as it arrive to the destination point. The result is good looking. It is desired that all the element of your game that have a fast change in some of their attributes do this kind of transition. 

void Update(){
    // From actual position to destination with "constant" t
    transform.position = Vector3.Lerp(transform.position,
                                      destination.position,
                                      speed * 3.0f * Time.deltaTime);
}

The line of code above is the heart of the Lerp. The parameters are the actual position and the destination. The function is called every frame and every time moves the game object. Just like in the fable of the hare and the turtle, this is the hare. Every time walks a portion of the remaining path. This also means that it never really arrive to destination.



The second kind of lerp is the "Constant". Constant gives the feeling of constant speed though all the animation. The result also looks nice and is useful when you want to animate characters, vehicles and things that should not happen too fast. Is also very useful to define way points. Imagine a tower defence game.

void Update(){
    // From position1 to position2 with increasing t
    transform.position = Vector3.Lerp(position1.position,
                                      position2.position,
                                      speed * timer);

    // Increase or decrease the constant lerp timer
    if (destination == position1){
        // Go to position1 t = 0.0f
        timer = Mathf.Clamp(timer - Time.deltaTime, 0.0f, 1.0f/speed);
    } else {
        // Go to position2 t = 1.0f
        timer = Mathf.Clamp(timer + Time.deltaTime, 0.0f, 1.0f/speed);
    }
}

This code is a little bit more complicated that the other. The starting position and destination are always the same. What changes is the third parameter that increases or decreases with time depending on the destination. The value is clamped between 0.0f and 1.0f. You can give different values to Lerp but its going to clamp it anyway. This is the turtle of the fable. It will always arrive to destination.


As I said you can also Lerp many other things. In the example the arrow uses a "Smooth" Lerp for the rotation and the color

void Update (){
    // Lerp color
    spriteRenderer.color = Color.Lerp(spriteRenderer.color,
                                      destinationColor,
                                      speed * Time.deltaTime);

    // Lerp rotation
    transform.rotation = Quaternion.Lerp(transform.rotation,
                                         destinationRotation,
                                         speed * 4.0f * Time.deltaTime);
}

As you can see. Both kinds of Lerp can come in handy. It is curious because the original use for Lerp is the constant one, but people mostly use the smooth one for one reason or another. Also because it can be achieved with only one line of code.

In general, is a fairly common mistake in beginner videogame developers that elements in the games  are either in position A or B. For us, programmers, is much easier the world were things are never in a "travelling" or "transition" status. But the truth is that you better start to remove that idea from your mind, as things that happens instantaneously harm the player experience.

"May the Lerp be with you" - A wise man

Here is the link to the complete example posted on github.

Here are the links to the official documentation: numbers, vectors, colors, rotations.