Game Development Stack Exchange is a question and answer site for professional and independent game developers. Join them; it only takes a minute:

Sign up
Here's how it works:
  1. Anybody can ask a question
  2. Anybody can answer
  3. The best answers are voted up and rise to the top

In Unity3D (all versions, I believe), there is a static function for the Vector3D class called "lerp". It interpolates a point between two points a point, based off a provided percentage related to the desired distance between the two.

Alternatively, I could just get the direction I want to go as a point, subtract it from my current position, Normalize() the resulting vector, then multiply that times a speed value.


  • Is one way faster than another?


  • Is there a third better/faster/easier/more efficient way I don't know about?


share|improve this question
In your first example you mention a "desired distance", yet in the second one you use a "speed value". Can you maybe clarify? Anyway, lerp() is only one scalar-vector multiplication and a few additions; it should be extremely fast. – sam hocevar Feb 11 '13 at 16:15
Honestly, unless you're doing this a LOT (and I really mean a LOT) of times per frame, it's just going to be down in the noise on any performance graph. – Le Comte du Merde-fou Feb 11 '13 at 16:19
For the sake of consistency, lets say we still using rates, but recorded differently. So the first one would use 5%/sec, while the other would be 5units/sec. True to Unity form, these would get Time.deltaTime 'd . – Kirbinator Feb 11 '13 at 16:20
As with all performance questions, benchmark. It would be trivial to write a little script that does this, crank up the data to appropriate levels, and then test it on whatever target platform you're using (assuming you have Unity pro with the profiler). – Tetrad Feb 11 '13 at 17:49
That being said I highly doubt either approach would be slowing you down by any measurable amount, why are you asking if one is better? Just use whichever one is the cleanest/most maintainable until you reach a point where you have to optimize something. – Tetrad Feb 11 '13 at 17:50
up vote 4 down vote accepted

Velocity and lerping are for different purposes. Lerping is great when you know you're going to end at the target in a given time; it's good for many UI animations, for example.

Use velocity when what you have is the speed of movement and the intent to get to a target at that constant speed. Using the velocity let's you smoothly change directions mid-course, slow down or speed up, etc. I had a place I was lerping vectors and changed to steering (velocty/force) because then I could make objects twist and "dodge" each other if they crossed paths.

In general, use lerp for static animations, use velocity (or full physics) for in-game character/object movement.

share|improve this answer
Ah, I see, they are more for framing movement in different ways. – Kirbinator Feb 12 '13 at 19:08

In the two situations you give, the former will always go whatever percent you enter in regardless of distance and in the second you'll always go the distance (speed * time) you enter in regardless of end goal distance.

Calculating a speed and multiplying by the normalized vector will give you a consistent speed of travel toward the destination at the cost of normalizing (which uses sqrt). This is a pretty straightforward way of doing what you want and has the advantage of making it easier to store current momentum for if the target position changes.

Using Lerp will allow you to travel a percent distance between the two points very easily, but it will not only be dependent on the end point, it will also vary behavior on framerate if you do so repeatedly while updating the source position and leaving the destination. This is not an issue if you only update the percent value over time like you mention in your comment while leaving the start and end points the same. That being said you can do an extremely cheap elastic band effect by giving Lerp a fixed percentage and moving the start point to the current.

Overall they are two different tools with different purposes that can be used to the same effect (as per your example). While Lerp is going to be the faster between the two, the actual effect probably won't be felt unless you're doing it a lot (for instance, if you were doing it for every particle in a very busy particle system). To see if the speed difference matters for your purposes: try it, measure, then see if it's enough actively concern you.

As to the last part of your question, take a look at Vector3.MoveTowards. I'm pretty sure it's doing basically what you describe in your first example behind the scenes, but it's set up in a fashion similar to Lerp with the third piece being a distance instead of a percentage.

share|improve this answer
MoveTowards is something I've been looking for, thanks! – Kirbinator Feb 12 '13 at 19:15

For velocity, you probably need directional vector (normalization). With lerp, velocity would depend on distance between two points (maybe you want that).

Normalize may be slower because it performs sqrt.

share|improve this answer

Your Answer


By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.