Quaternion.Lerp does not actually rotate object when called inside an "if" clause

Question

Let's say I have a RotatableObject class, which inherits from MonoBehaviour. Here is its Start() method:

private void Start() {
    this.startingLocalRotation = this.transform.localRotation;
    this.finalLocalRotation = Quaternion.Euler(this.startingLocalRotation.eulerAngles.x, -150f, this.startingLocalRotation.eulerAngles.z);

    // Initialize other private fields
}

It has a method called Rotate(), defined as follows:

private void Rotate() {
    this.transform.localRotation = Quaternion.Lerp(this.startingLocalRotation, this.finalLocalRotation, 0.2f);
}

Given the following Update() method, the object rotates as expected:

private void Update() {
    this.Rotate();
}

However, if I make the following changes to Update(), then the object does not actually rotate, even though the Rotate() method is hit:

private void Update() {
    if (this.SomeCondition) {
        this.Rotate();
    }
}

this.SomeCondition always has the value true over multiple frames.

What is my mistake, and how can I fix it?

EDIT:

In response to this comment:

When you say "the object rotates as expected" do you mean that the object rotates from starting angles until final angles and then stops rotating (without the if) ?

Yes.

could you provide some more details about what SomeCondition is?

this.SomeCondition is determined by the state of another object, say, Puppy. E.g. if puppyInstance.Mood == Mood.Happy, then this.SomeCondition is true.

Did you try replacing the condition with the word true

No, I have not tried that. However, when stepping through the call stack in debug mode, I can see that this.SomeCondition is true and Rotate() is called -- I managed to step into the Rotate() method itself.

EDIT:

I tried the first approach described in this answer. However, it did not produce the effects that I was aiming for.

I set a breakpoint here:

transform.localRotation = Quaternion.Lerp(
   startingLocalRotation, 
   finalLocalRotation, 
   _rotationProgress
);

Every single time the breakpoint was hit in the Update() call, I could see that the value of _rotationProgress was steadily increasing. However, the value of transform.localRotation never actually changed -- it was always (-0.7, 0.7, 0.0, 0.0).

If I updated transform.localRotation outside of an if clause, however, that game object rotates as expected -- transform.localRotation gets updated as _rotationProgress gets updated.

EDIT:

Never mind, I am an idiot. The problem lies elsewhere in the code. The suggested approach works and I have accepted it as the answer.

Answer 1

You need to accumulate some progress between your start and your end. For instance...

[Tooltip("How long the rotation should take to complete, in seconds")]
public float rotationDuration = 2f;
float _rotationProgress = 0f;

private void Rotate() {
    // Accumulate rotation progress.
    _rotationProgress = Mathf.Clamp01(_rotationProgress + Time.deltaTime/rotationDuration);

    // Blend to the appropriate fraction of the way between start & final
    transform.localRotation = Quaternion.Lerp(
       startingLocalRotation, 
       finalLocalRotation, 
       _rotationProgress
    );
}

Or you can use the current localRotation itself as your progress measure, using an exponential ease-out style of Lerp:

[Range(0f, 1f)]
public float smoothness = 0.9f;

private void Rotate() {
    // Correct the exponential blend speed for the current framerate.
    float blend = 1f - Mathf.Pow(smoothness, Time.deltaTime * 30f);

    // Blend a small incremental step from where we are now to where we're going.
    transform.localRotation = Quaternion.Lerp(
       transform.localRotation, 
       finalLocalRotation, 
       blend
    );
}

Or using the RotateTowards method:

[Tooltip("Speed to rotate, in degrees per second")]
public float rotationSpeed = 180f;

private void Rotate() {
    // Rotate at a fixed speed toward the destination.
    transform.localRotation = Quaternion.RotateTowards(
       transform.localRotation, 
       finalLocalRotation, 
       rotationSpeed * Time.deltaTime
    );
}

Answer 2

Try multiplying the last value in the Lerp function by Time.deltaTime. I’m not by my computer to check my old scripts where I used the Lerp function, but I think I remember doing something with Time.deltaTime