Smoothly move camera to follow player

Question

I'm trying to move my camera with the player but I'm trying to move/lerp over time, so that the camera allows the player to get a small radius from the center as it gets up to speed, and the camera will "catch up" when the player slows or stops.

I've written code that increases the movement speed of the camera the further the player gets - ideally you should only be able to go a set radius before the camera just "follows" you.

This works, except it's too jittery when the player is moving. The larger the distance, the more noticeable the jitter. I've tried different speeds but nothing seems to satisfactorily solve the issue.

Player.cs Update():

var moveHorizontal = player.GetAxis("Move Horizontal") * rigidBody.mass;
var moveVertical = player.GetAxis("Move Vertical") * rigidBody.mass;

var forceDirection = new Vector3(moveHorizontal, 0, moveVertical);

rigidBody.AddForce(forceDirection);

Camera's Follow.cs:

void Awake() {
    offset = transform.position - player.transform.position;
}

void LateUpdate() {
    var dist = Vector3.Distance(transform.position - offset, player.transform.position);

    if (dist != 0) {
        transform.position = Vector3.Lerp(
            transform.position,
            player.transform.position + offset,
            Time.deltaTime * dist * speed);
    }
}

Per the first answer, I've also tried setting my player's rigibody to "Interpolation" mode, and I update my follow script with the suggested smoothing code:

// Compute our exponential smoothing factor.
float blend = 1f - Mathf.Pow(1f - followSharpness, Time.deltaTime * 30f);

transform.position = Vector3.Lerp(
    transform.position,
    player.transform.position + offset,
    blend);

This works initially, but I get awful jitter once my player collides with an object. Plus, interpolation mode appears more susceptible to framerate drops but that's an aspect of my game I haven't worked on yet.

Answer 1

This style of using Lerp:

current = lerp(current, target, sharpness)

is an exponential moving average. So if we want to correct it for deltaTime, a linear adjustment won't do. We need an exponential adjustment.

public float followSharpness = 0.1f;

void LateUpdate() {
     // No need for the "if" - we'll practically never reach exactly 0 distance anyway.

     // Compute our exponential smoothing factor.
     float blend = 1f - Mathf.Pow(1f - followSharpness, Time.deltaTime * 30f);

     transform.position = Vector3.Lerp(
            transform.position,
            player.transform.position + offset,
            blend);
}

You can verify that as deltaTime approaches zero, so does our blend factor. When deltaTime is exactly 1/30, the blend factor is exactly equal to sharpness. When deltaTime is 2/30 (eg. we missed a VBlank when trying to hit 30 FPS), the blending result is the same as if we'd performed a blend with sharpness on two consecutive frames.

You might not find you need to scale the follow sharpness by distance, since an exponential moving average already adjusts its speed according to its distance from the new target - moving slowly when close, and faster when further away.

Answer 2

This is done very easily and the Youtube Channel "Brackeys" has a nice tutorial on how to achieve such an effect. You can find a link to that video here.

To sum up what was in the video:

• Create a script and put it on the camera you want to follow your player.
• Setup a couple public variable which will allow the camera to know which GameObject to follow as well as float variable for desired smooth speed, and a Vector3 for the offset.

Should like something like this:

public Transform target;

public float smoothSpeed = 15f;

public Vector3 offset;

We then set use Unity's built in LateUpdate() function, this allows for all of the other object's to update first, then calls this function. (We want to move the camera after everything else already has.)

• Then in our LateUpdate() function we write a line of code to contain the Vector3 of the desired position we have, as well as smoothing that position. Finally we set the camera position equal to the smoothed position variable.

The way we smooth our position is using a function Unity provides us with called Lerp. It allows us to interpolate linearly between values based on a time value from 0 to 1.

void LateUpdate()
{
    Vector3 desiredPosition = transform.position + offset;
    Vector3 smoothedPosition = Vector3.Lerp(transform.position, desiredPosition, smoothSpeed * Time.deltatime);
    transform.position = smoothedPosition;
}

There you go, that's all there is to it.

Final notes:

• Make sure to set the target gameobject in the editor, this should be your player or object you want to follow.
• To achieve the radius effect you want, play around with the smoothspeed.
• If you are still getting jittey movement or updates, change LateUpdate() to FixedUpdate(). Although this is not the best practice, it usually will achieve a very smooth effect and will not have jitter in the movements because we are moving the time of updating the camera to what other people call the 'Physics Loop'.