Rotate the shortest way?

Questions & Answers
1

Hi there…

I got stuck in a problem…
I´ve written this small code to rotate my player smoothly into a given direction:’

void Rotate_to(){
    rotate_t += Time.deltaTime * RotateSpeed;
    PlayerHolder.transform.eulerAngles = new Vector3(0, Mathf.Lerp(PlayerHolder.transform.eulerAngles.y, new_direction, rotate_t), 0);
}

The problem is: He is rotating always to the right…
if the players rotation is at 45°, and he needs to rotate to -45° (315°), he is rotating rightways… instead of the shorter left way…

So i tried for some time now, to ask for the shorter way… But couldn´t find an answer…
I heard of Mathf.DeltaAngle or asking for Mathf.Abs differences… But it´s not working…

Can someone help me out here? :frowning:

The complete code:
Third Person Controller (Pastebin.com)

5

or use Mathf.LerpAngle :slight_smile:

2

Here, I wrote these functions for your needs:

// If the return value is positive, then rotate to the left. Else,
// rotate to the right.
float CalcShortestRot(float from, float to)
{
	// If from or to is a negative, we have to recalculate them.
	// For an example, if from = -45 then from(-45) + 360 = 315.
	if(from < 0) {
		from += 360;
	}
	
	if(to < 0) {
		to += 360;
	}

	// Do not rotate if from == to.
	if(from == to ||
	   from == 0  && to == 360 ||
	   from == 360 && to == 0)
	{
		return 0;
	}
	
	// Pre-calculate left and right.
	float left = (360 - from) + to;
	float right = from - to;
	// If from < to, re-calculate left and right.
	if(from < to)  {
		if(to > 0) {
			left = to - from;
			right = (360 - to) + from;
		} else {
			left = (360 - to) + from;
			right = to - from;
		}
	}

	// Determine the shortest direction.
	return ((left <= right) ? left : (right * -1));
}

// Call CalcShortestRot and check its return value.
// If CalcShortestRot returns a positive value, then this function
// will return true for left. Else, false for right.
bool CalcShortestRotDirection(float from, float to)
{
	// If the value is positive, return true (left).
	if(CalcShortestRot(from, to) >= 0) {
		return true;
	}
	return false; // right
}

Example:

void Update()
{
	// The turn direction should be right.
	Debug.Log("Turn direction: " + (CalcShortestRotDirection(45, -45) ? "Left" : "Right"));
	// Turn -90.
	Debug.Log("Turn value: " + CalcShortestRot(45, -45));
	
	// The turn direction should be left.
	Debug.Log("Turn direction: " + (CalcShortestRotDirection(45, 90) ? "Left" : "Right"));
	// Turn +45.
	Debug.Log("Turn value: " + CalcShortestRot(45, 90));
}

Please don’t forget to read the comments.

3

Both Mathf.Lerp() and Vector3.Lerp() are literal, so you have to give it values that make the code rotate the way you want. Let me start with a quick patch to your code:

void Rotate_to(){
    rotate_t += Time.deltaTime * RotateSpeed;
    float f = PlayHolder.transform.eulerAngles.y;
    if (f > 180.0f)
        f -= 360.0f;
    PlayerHolder.transform.eulerAngles = new Vector3(0, Mathf.Lerp(f, new_direction, rotate_t), 0);
}

The code takes the eulerAngles.y value and normalized it to -180 to 180, so now a -45 will rotate in the correct direction. But reading eulerAngles has issues. As long as the X and Z rotation is 0, your code should work fine. But if you start combining this rotation with an X and Z rotations, then you may run into serious issues. The problem is that eulerAngles is derived from Transform.rotation (a Quaternion) and the values output may not stay in the expected representation. Assuming this is the only code changing the rotation of the object, a safer method would be to maintain your own Vector3 and treat eulerAngles as write only. So at the top of the class you declare:

Vector3 myRotation = Vector3.zero;

Then your Rotate_to() becomes:

void Rotate_to(){
    rotate_t += Time.deltaTime * RotateSpeed;
    myRotation.y = Mathf.Lerp(myRotation.y, new_direction, rotate_t);
    PlayerHolder.transform.eulerAngles = myRotation;
}

You can use myRotation.y because it will always be in the representation you set it to. So if you use -180 to 180, those are the values you will read back. On the other hand, if you set eulerAngles to -45, you are going to get 315 back.

4

Old question, API must have changed. I’m using this to great effect:

            bool left = Mathf.DeltaAngle(currentAngle, targetAngle) < 0f;
6

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class RotateQuaNoneShortWay : MonoBehaviour
{
    public float rotateAngle;
    public float speed;

    Quaternion targetRot;

    float targetAngle;
    float currentAngle;

    Quaternion firstRotation;

    public bool canRotate;

    Transform c_Transform;

    private void Start()
    {
        c_Transform = GetComponent<Transform>();

        firstRotation = c_Transform.rotation;
    }
    void Update()
    {
        if (Input.GetKeyDown(KeyCode.R))
        {
            targetAngle += rotateAngle;

            if (!canRotate)
            {
                firstRotation = c_Transform.rotation;

                canRotate = true;
            }
        }
        if (canRotate)
        {
            currentAngle = Mathf.Lerp(currentAngle, targetAngle, Time.deltaTime * speed);
            targetRot = Quaternion.AngleAxis(currentAngle, c_Transform.up) * firstRotation;
            c_Transform.rotation = Quaternion.Slerp(c_Transform.rotation, targetRot, Time.deltaTime * speed);

            if (Quaternion.Angle(c_Transform.rotation,targetRot) < 0.2f)
            {
                c_Transform.rotation = targetRot;
                currentAngle = 0;
                targetAngle = 0;

                canRotate = false;
            }
        }
    }
}
7

i use this:

//difference from current angle to target angle
float myTargetAngle = 0f; //example input
float myCurrentAngle = 999f; //example input
float diff = (myCurrentAngle % 360) - _myTargetAngle;
if (diff >= 360) diff -= 360; else if (diff <= -360) diff += 360;
    
//rotation direction - left/right - the short way
if (diff >= 180) myCurrentAngle += 360 - diff; //twisted minus
else if (diff <= -180) myCurrentAngle += -360 - diff; //twisted plus
else myCurrentAngle -= diff; //standard