Game Development Stack Exchange is a question and answer site for professional and independent game developers. It's 100% free, no registration required.

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

I am debugging my Lerping to see how it works. It is rotating a card and it looks good. However the lerping contains way beyind the card is visually done rotating. I understand it has to do with the mathematics. Is thera a way i can fix it? Is it unavoidable with Lerp/Slerp? Basically what i want is the function to be done when the card has rotated enough so that steps are no longer visible.

public IEnumerator LerpRotationY (float durationSeconds, FlipsSide flipSide)
            int targetAngle = FlipSideEnumToDegrees (flipSide);

            //float flipSpeed = 3F; 
            var flipRotation = Quaternion.Euler (0, targetAngle, 0);
            float t = Time.deltaTime;
            var cardRotation = cardSides.rotation;
            var timePassed = Time.time;
            print ("SLERPING! ");
            while (t < durationSeconds) {

                    cardSides.rotation = Quaternion.Slerp (cardSides.rotation, flipRotation, t);

                    yield return null;
                    t += Time.deltaTime;
            print ("SLERPING FINISHED: " + (Time.time - timePassed).ToString ());}
share|improve this question
up vote 3 down vote accepted

I'm having trouble visualizing the problem you are describing, however I can see two issues with the implementation posted.

The first issue is that you are using the updated rotation as the first parameter of the lerp function. Doing this will produce a movement that will start off quickly but then slow down towards the end. This effect is great for camera movement but would look a little off for rotating a card.

Another issue is that you are using t (elapsed time) as the third parameter for lerp, this will produce varying (and possibly unexpected) results for those occasions where durationSeconds is not equal to 1. The solution is to use t / durationSeconds as this will smoothly travel from 0 to nearly 1. At the end of the loop you can then force the final rotation to ensure a predictable final state.

A smooth and complete lerp requires stable start and end parameters and a t parameter that ranges between 0 and 1.

Please try this version with these changes applied:

public IEnumerator LerpRotationY (float durationSeconds, FlipsSide flipSide) {       
        int targetAngle = FlipSideEnumToDegrees(flipSide);
        var flipRotation = Quaternion.Euler(0, targetAngle, 0);
        // store starting rotation:
        var startingRotation = cardSides.rotation;
        float t = Time.deltaTime;

        while (t < durationSeconds) {
                // First parameter changed to startingRotation
                // Third parameter changed to t / durationSeconds
                cardSides.rotation = Quaternion.Slerp(startingRotation, flipRotation, t / durationSeconds);
                yield return null;
                t += Time.deltaTime;
        // force final rotation:
        cardSides.rotation = flipRotation;
share|improve this answer
Thanks! Am i correct in observing that the only change you made is to divide t with durationSeconds? – Lautaro Jan 1 '14 at 16:09
@Lautaro I've added some comments to highlight the changes. – Kelly Thomas Jan 1 '14 at 16:13
Hey that works beautifully! THANKS! – Lautaro Jan 1 '14 at 17:52

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.