Smooth/progressive transition between 2 floats in a certain amount of time

[GuirieSanchez]

I’m trying to get an initial speed (let’s say, 20 units) to a target speed (say, 10) smoothly in 0.2seconds.

I used lerp methods like this one Mathf.Lerp(initial velocity, target velocity, time), but they don’t seem to work as I expected.

Is there anyone who knows well how to implement the Mathf.Lerp function (or maybe other methods to achieve this)?

So far, I was suggested the following code, that I have in an Update loop :

 private void Update()
    {
        if(!_stop) return;

        velocity.x = (Mathf.Lerp(initialVelocity, targetVelocity,
        time) * Time.deltaTime;
        time += 0.5f * Time.deltaTime;

        if(time > 1)
        {
            time = 0f;
            _stop = false;
        }

    }

and I tried changing the time values, but I never got my expected lerp in .2s since I don’t know precisely how this multiplier is working, or what the time in the lerp function represents exactly. I hope anyone can let me know. Thanks

[PraetorBlue]

The right way to Lerp in Unity (with examples)

[GuirieSanchez]

As an aside question, the blogger in this article said that when using lerp, sometimes the movement gets stuttery and jerky in the editor, and indeed it happened to me as well:

When I use Lerp, the movement stutters and jerks. Why isn’t it smooth?
Sometimes when using Lerp, for example, to move an object, you may notice that the movement is not completely smooth, that it jerks around or appears bumpy.

For example the travel of the object stutters and jumps along its path, even though the movement is linear.

If this is happening to you, don’t worry.

While there are real issues that can cause this, the most likely reason is simply that you’re viewing it in the editor.

And, once you build the project, you’ll notice that the movement in the finished application is buttery smooth.

No need to worry.

As he said, it works great (smoothly) in the build. But I wonder if you (or anyone) know of a fix to this, because mostly all the testing is done in the editor, and it doesn’t feel great to deal with this stuttery movement all the time. Thanks

[Kurt-Dekker]

Smoothing movement between any two particular values:

Beginner - need help with SmoothDamp

The problem is the choice of integer values for lanes. They can only either be lane 0, 1 or 2. They can’t be in between round numbers. It needs to be a floating point value so that it can be between lanes. This type of question comes up so universally I have finally just made a sample package to demonstrate the basic concept. Read my first post above and see if you can correlate each part of the code to the steps indicated. Code located here: SmoothMovement.cs · GitHub 6430100–719246–SmoothMo…

You have currentQuantity and desiredQuantity.

• only set desiredQuantity
• the code always moves currentQuantity towards desiredQuantity
• read currentQuantity for the smoothed value

Works for floats, Vectors, Colors, Quaternions, anything continuous or lerp-able.

The code: SmoothMovement.cs · GitHub

Another approach would be to use a tweening package line LeanTween, DOTween or iTween.

For score count-up (like a cash register whizzing lots of numbers upwards), I like this approach:

Create Score increasing effect

I like to have two quantities for this: int actualScore; int displayedScore = -1; When the game logic adds points, it does this: actualScore += 12345; Now over in the display logic you periodically: adjust displayedScore towards actualScore (magic happens here!) output displayedScore Now… onto the magic. Obviously if you count one point (or any constant amount) it is pretty uninteresting… a huge score add might take forever to get together. Keeping it all as integers, here is the …

Fading, simple and easy:

How can I fade in/out a canvas group alpha color with duration time ?

Don’t use Mathf.Lerp(). Use Mathf.MoveTowards(). And definitely DO NOT USE COROUTINES (see my post above). make some member variables: private float desiredAlpha; private float currentAlpha; The work: void Update() { currentAlpha = Mathf.MoveTowards( currentAlpha, desiredAlpha, 2.0f * Time.deltaTime); } Now, wherever you need to set fadedness of any object, use currentAlpha. colorProperty.a = currentAlpha; When you want to change fadedness, only set desiredAlpha equal to 0 or 1. desir…

[GuirieSanchez]

@Kurt-Dekker Quick question. I want to try your implementation, but it says that only the desiredQuantity has to be set. What if I want this smooth transition to happen in 0.2 seconds, which other value should I modify?

EDIT: Maybe I should set this const float MovementPerSecond = 2.0f; value to 0.2f?

[Kurt-Dekker]

If you are at A and you want to get to B, you must change by the amount (B - A).

If you want to change that in T seconds, then the movement rate would be:

MovementPerSecond = (B - A) / T;

You would compute that ONCE, at the point where you begin the movement, obviously.

[Bunny83]

@GuirieSanchez

velocity.x = (Mathf.Lerp(initialVelocity, targetVelocity,
        time) * Time.deltaTime;

What’s the point of the Time.deltaTime multiplication at the end? It makes no sense, remove it

ps: your code would not compile as you have two opening brackets in that line of code and just one closing. So this does not add up.

pps: this line of code is correct, but will make the transtion last for 2 seconds:

time += 0.5f * Time.deltaTime;

The overall logic would be

time += Time.deltaTime / duration;

So if you want the transition to last 0.2f seconds, just set duration to 0.2f. Though dividing by 0.2 is the same as multiplying by 5. So you could also do

time += 5f * Time.deltaTime;

to get the same result ((1f/0.2f) == 5f)

[GuirieSanchez]

@Kurt-Dekker

If you are at A and you want to get to B, you must change by the amount (B - A).

If you want to change that in T seconds, then the movement rate would be:

MovementPerSecond = (B - A) / T;

You would compute that ONCE, at the point where you begin the movement, obviously.

That makes sense, all clear then, thanks. I’ll let you know how it works here.

[Kurt-Dekker]

@Bunny83

pps: this line of code is correct, but will make the transtion last for 2 seconds:

@Bunny83

time += 0.5f * Time.deltaTime;

Tying what Bunny wrote above into what I said about (B-A)/T:

• with Lerp() alpha, you are changing the alpha by a quantity of 1.0 for full deflection
• Bunny’s code is moving by 0.5f per second
• A = 0
• B = 1
• T = 2
• so 1.0f / 0.5f —> 2 seconds, as Bunny correctly states

Or put another way, 1.0f / 2 gives you a rate of movement of 0.5f

Math!

[GuirieSanchez]

@Bunny83

What’s the point of the
Time.deltaTime
multiplication at the end? It makes no sense, remove it

It’s needed in this case because I’m computing the velocity right there; then in my Move() method I just do transform.Translate(velocity); (so the Time.deltaTime is calculated earlier)

@Bunny83

ps: your code would not compile as you have two opening brackets in that line of code and just one closing. So this does not add up.

Probably I made a typo while writing the code here from scratch, sorry about that!

@Bunny83

pps: this line of code is correct, but will make the transtion last for 2 seconds:

The overall logic would be

So if you want the transition to last 0.2f seconds, just set duration to 0.2f. Though dividing by 0.2 is the same as multiplying by 5. So you could also do

to get the same result ((1f/0.2f) == 5f)

Thank you for letting me know how that “time” from the Unity’s example works! that was very instructive, I’ll give it a try.
PS: do you know why this provokes the stuttery movement in the Editor?