Converting eulerAngles to "Inspector rotation"

Question

The inspector shows certain rotation values for Game Objects.

I would like to work with these instead of the eulerAngles (which are the rotation values that I can access by a script).

To get these rotation values shown by the Inspector, I found out that the eulerAngles of the game object's localRotation could be of help.

I'm not sure if my approach is correct.

Can somebody tell me what I'm actually trying to do here (I guess there is a name for it) and how to do that correctly?

My current approach is this:

private float EulerToRotation(float value)
{
    if (value > 180)
    {
        return value - 360f;
    }
    else if (value < -180)
    {
        return value + 360f;
    }
    else
    {
        return value;
    }
}

Answer 1

The angles shown in the Unity inspector are Euler angles, relative to the parent's coordinate space. They correspond to:

transform.localEulerAngles

As long as you're using these to represent an orientation, then differences in the exact numbers you get aren't significant. As explained in this answer, there's an infinite number of ways to represent a given orientation as an Euler angle triplet, all equivalent in effect. So adding / subtracting 360 degrees doesn't make a difference to the net orientation that the triplet represents.

If you're in a situation where the exact numeric value of two equivalent Euler angle triplets makes a difference in your application, then you're probably using the wrong rotation representation for that situation.

For instance, if you want to compare whether an orientation matches a reference orientation, don't compare angles: compute the difference as a quaternion, something like this...

bool RotationMatch(Quaternion a, Quaternion b) {
    return Math.Approximately(Quaternion.Angle(a, b), 0f);        
}

Or, without the trig, using the fact that the quaternion dot product is the cosine of the half the angle between the rotations:

bool RotationsMatch(Quaternion a, Quaternion b) {
    return Mathf.Approximately(Mathf.Abs(Quaternion.Dot(a, b)), 1f));
}