Unity method to get a vector, which is x seconds behind another moving vector (A bit like TrailRenderer)

Question

I want a function, which lets me follow a vector with a bit offset or delay, like it's done in the TrailRenderer. I tried to achieve this with the Lerp function, but that didn't work for me like I want, since I had to wait for a specific time until the lerp was done and then updated my targetVector of the Lerp again, which led to a bad result.

Now a possible solution to my problem would be a List, which holds all Positions of my Vector from the past 50 frames or so and I assign the same values to my other Vector with a specific offset. But I was wondering if there is some built in method in Unity, which could achieve this for me.

Edit: This is about moving a Canvas

Answer 1

What you describe, in terms of following a position's exact path with a time delay, might be both more complicated and less satisfying than what you want.

Here's a mock-up of two possibilities:

The object labeled "Path" follows the exact path of the leader object, a constant amount of time behind it. This means:

• When the leader starts moving, there is a delay before the follower moves. Likewise for stopping.

• Any kinks or jitter in the leader's movement is repeated exactly by the follower.

The object labeled "Blend" mixes-together its current position with the leader's each frame, so that it attracts toward it asymptotically.

• The follower always moves directly toward the leader, cutting corners tighter and smoothing out jitter to a degree.

• The follower moves slower when it's close to the leader, and faster when far away, making its follow distance/delay non-constant (but for some applications this gives a pleasant ease-in and ease-out to its motion effectively "for free")

The great thing about the blend approach is how simple the code is:

public class BlendFollower : MonoBehaviour {

    public Transform leader;
    public float followSharpness = 0.05f;

    void LateUpdate () {
        transform.position += (leader.position - transform.position) * followSharpness;
    }
}

I use this about 80% of the time when I want some quantity to track toward another in games - it works for floats, positions, colours, rotations, etc. It's a super useful little trick.

---

Edit: for rotation, you'd use something like this:

transform.rotation = Quaternion.Lerp(
                          transform.rotation, 
                          leader.rotation, 
                          followSharpness);

Just ensure the Quaternions you start with are valid (not all zeroes or NaNs) or this will blow up. I often write a Quaternion.IsValid() extension method to check this if I'm working with a lot of computed rotations.

---

Note that since this is blending a constant amount per frame, so at higher framerates it will be sharper and at lower framerates, spongier. For purely visual effects this is often tolerable, but if gameplay outcomes depend on the follow rate then you'll either want to correct for this or move it to FixedUpdate so it's consistent.

Compare this to the path follow:

(Variable framerates account for some of this complexity - if you want to follow a constant number of frames behind, rather than seconds, then the code is a bit simpler. Also, I threw in my path-drawing debug gizmo code too.)

public class PathFollower : MonoBehaviour {

    const int MAX_FPS = 60;

    public Transform leader;
    public float lagSeconds =  0.5f;

    Vector3[] _positionBuffer;
    float[] _timeBuffer;
    int _oldestIndex;
    int _newestIndex;

    // Use this for initialization
    void Start () {
        int bufferLength = Mathf.CeilToInt(lagSeconds * MAX_FPS);
        _positionBuffer = new Vector3[bufferLength];
        _timeBuffer = new float[bufferLength];

        _positionBuffer[0] = _positionBuffer[1] = leader.position;
        _timeBuffer[0] = _timeBuffer[1] = Time.time;

        _oldestIndex = 0;
        _newestIndex = 1;
    }


    void LateUpdate () {
        // Insert newest position into our cache.
        // If the cache is full, overwrite the latest sample.
        int newIndex = (_newestIndex + 1) % _positionBuffer.Length;
        if (newIndex != _oldestIndex)
            _newestIndex = newIndex;

        _positionBuffer[_newestIndex] = leader.position;
        _timeBuffer[_newestIndex] = Time.time;

        // Skip ahead in the buffer to the segment containing our target time.
        float targetTime = Time.time - lagSeconds;
        int nextIndex;
        while (_timeBuffer[nextIndex = (_oldestIndex + 1) % _timeBuffer.Length] < targetTime)
            _oldestIndex = nextIndex;

        // Interpolate between the two samples on either side of our target time.
        float span = _timeBuffer[nextIndex] - _timeBuffer[_oldestIndex];
        float progress = 0f;
        if(span > 0f)
        {
            progress = (targetTime - _timeBuffer[_oldestIndex]) / span;
        }

        transform.position = Vector3.Lerp(_positionBuffer[_oldestIndex], _positionBuffer[nextIndex], progress);
    }

    void OnDrawGizmos()
    {
        if (_positionBuffer == null || _positionBuffer.Length == 0)
            return;

        Gizmos.color = Color.grey;

        Vector3 oldPosition = _positionBuffer[_oldestIndex];
        int next;
        for(int i = _oldestIndex; i != _newestIndex; i = next)
        {
            next = (i + 1) % _positionBuffer.Length;
            Vector3 newPosition = _positionBuffer[next];
            Gizmos.DrawLine(oldPosition, newPosition);
            oldPosition = newPosition;
        }
    }
}

Answer 2

Unity does not store this information, so there is no property or field that holds the old position of objects. Once a frame passes, the old positions of objects are gone.

You can get around this by storing the last few positions yourself and interpolating between them. Here's some code:

using UnityEngine;

public class Tracker : MonoBehaviour
{
    public int trailIntervalsCount = 5;
    public float trailIntervalDuration = .5f;
    Vector3[] pastPositions = new Vector3[0];
    int writeIndex = 0;
    float timer;

    public Vector3 GetPastPosition(float secondsAgo)
    {
        secondsAgo = Mathf.Min((trailIntervalsCount-1) * trailIntervalDuration, secondsAgo);
        float intervalsAgo = ((secondsAgo - timer) / trailIntervalDuration) + 1;
        Vector3 posAtFloor = getPositionByInterval(Mathf.FloorToInt(intervalsAgo));
        Vector3 posAtCeil = getPositionByInterval(Mathf.CeilToInt(intervalsAgo));
        float t = intervalsAgo - Mathf.Floor(intervalsAgo);
        return Vector3.Lerp(posAtFloor, posAtCeil, t);
    }

    void Start()
    {
        // Initialize the past positions buffer to our current position.
        FillPastPositions();
    }

    void FixedUpdate()
    {
        if (trailIntervalsCount != pastPositions.Length)
        {
            FillPastPositions();
        }
        timer += Time.fixedDeltaTime;
        if (timer > trailIntervalDuration && trailIntervalDuration > 0 && trailIntervalsCount > 0)
        {
            timer -= trailIntervalDuration;
            pastPositions[writeIndex++] = transform.position;
            writeIndex %= trailIntervalsCount;
        }
    }

    /// <summary>
    /// Fills the pastPositions buffer with the current position.
    /// </summary>
    private void FillPastPositions()
    {
        pastPositions = new Vector3[trailIntervalsCount];
        for (int i = 0; i < trailIntervalsCount; ++i)
        {
            pastPositions[i] = transform.position;
        }
        writeIndex = 0;
    }

    private Vector3 getPositionByInterval(int intervalsAgo)
    {
        // Interval 0 is our current position. BUT we have to offset it to where we "will be" at the end of the interval.
        if (intervalsAgo <= 0)
        {
            Vector3 currentPos = transform.position;
            Vector3 lastPos = getPositionByInterval(1);
            float percentOfInterval = (timer / trailIntervalDuration);
            if (percentOfInterval == 0)
                return currentPos;
            else
                return Vector3.LerpUnclamped(lastPos, currentPos, (1f / percentOfInterval));
        }
        // Interval 1 is our last written position, 2 is the one before that, etc.
        else if(intervalsAgo <= trailIntervalsCount)
        {
            int index = writeIndex - intervalsAgo;
            // Wrap around once
            if (index < 0)
            {
                index += trailIntervalsCount;
            }
            // If we would wrap around twice, clamp it to the end of the trail.
            if (index < 0)
            {
                index = writeIndex;
            }

            if (index < 0 || index >= pastPositions.Length)
            {
                Debug.LogFormat("{0}, {1}, {2}", index, writeIndex, intervalsAgo);
            }
            return pastPositions[index];
        }
        else
        {
            return getPositionByInterval(trailIntervalsCount);
        }
    }
}

Answer 3

Assuming you don't care about changes in direction you can multiply the velocity vector of the object by a negative amount, then add that negative vector to the position of the object you're trailing. I think it would be something like this:

var positionBehind = rigidbody.velocity * -1.0f;
var trailPosition = rigidbody.position + positionBehind;