【Unity】Mastering Quaternion in Unity: A Complete Guide to Rotation Basics and Practical Usage

Overview

Many beginners starting Unity game development find it intuitive to understand position (position) and scale (localScale) of objects, but encounter confusion when dealing with rotation (rotation) due to the term Quaternion.

You might think, "Isn't specifying rotation with X, Y, Z angles (Euler angles) sufficient?" However, this intuitive Euler angle approach has a phenomenon called "Gimbal Lock" that can be fatal in game development. This occurs when two rotation axes overlap at a certain angle, causing loss of a degree of freedom in rotation. Especially in complex rotation controls like character gaze tracking or camera work, gimbal lock can cause unexpected bugs and unnatural movements.

This article explains the basic concepts of Quaternion, the differences from Euler angles, and practical C# code for achieving smooth rotation in Unity, all in a beginner-friendly manner.

What is Quaternion?

Quaternion is a mathematical concept for representing rotation, consisting of four elements (x, y, z, w), similar to complex numbers. In Unity, it's used as the rotation property of the Transform component.

While the Euler angles we commonly use (X degrees, Y degrees, Z degrees) express "how much to rotate around which axis," Quaternion expresses "the state of having rotated around which axis by how much." This representation method allows for always smooth and accurate rotation handling while avoiding gimbal lock.

Terminology Notes

• Euler Angles: A human-intuitive representation using rotation angles for X-axis (pitch), Y-axis (yaw), and Z-axis (roll). This is what's displayed as rotation values in Unity's Inspector.
• Gimbal Lock: In Euler angle representation, when a specific rotation (e.g., Y-axis at 90 degrees) is reached, the remaining two axes (X and Z) point in the same direction, losing one degree of freedom.

Choosing Between Euler Angles and Quaternion

In Unity, you can access Euler angles through the transform.eulerAngles property, but internally this is converted to Quaternion for processing.

Feature	Euler Angles (transform.eulerAngles)	Quaternion (transform.rotation)
Representation	3 angles (X, Y, Z)	4 elements (x, y, z, w)
Intuitiveness	High (human-friendly)	Low (mathematically complex)
Issues	Gimbal lock can occur	No gimbal lock
Usage	Inspector settings, initial values	Calculations in scripts, rotation interpolation

Common Pitfall for Beginners

When trying to set rotation values with Euler angles, writing code like the following can lead to unintended results.

// Error-prone code example: Directly manipulating Euler angles
// Directly assigning values to transform.eulerAngles can cause unexpected axis rotations.
// Also, while this value is not read-only, it's converted to Quaternion internally,
// which can cause unintended "side effects."
transform.eulerAngles = new Vector3(0, 90, 0);

Solution: Even when specifying rotation with Euler angles, always use the Quaternion.Euler() method to convert to Quaternion before assigning.

// Correct code example: Using Quaternion.Euler()
// Convert Euler angles (0, 90, 0) to Quaternion and assign
transform.rotation = Quaternion.Euler(0, 90, 0);

Practical Quaternion Usage and Code Examples

Quaternion's true value shines when generating specific rotation states or smoothly interpolating between rotations.

1. Generating Rotation to Look at a Direction (Quaternion.LookRotation)

When you want to make a character face a specific target, Quaternion.LookRotation is very useful.

using UnityEngine;

public class LookAtTarget : MonoBehaviour
{
    public Transform target; // Target's Transform

    void Update()
    {
        if (target == null) return;

        // 1. Calculate direction vector to target
        Vector3 direction = target.position - transform.position;

        // 2. Generate Quaternion to face that direction
        // Specifying up direction (Vector3.up) as second argument prevents head tilting
        Quaternion targetRotation = Quaternion.LookRotation(direction, Vector3.up);

        // 3. Apply generated Quaternion to current rotation
        transform.rotation = targetRotation;
    }
}

2. Smooth Rotation Interpolation (Quaternion.Slerp)

In games, there are many situations where you want object rotation to change smoothly over time rather than instantly. This is where Quaternion.Slerp comes in. Slerp stands for "Spherical Linear Interpolation" and interpolates Quaternion rotations most efficiently and naturally.

using UnityEngine;

public class SmoothRotation : MonoBehaviour
{
    public Transform target;
    public float rotationSpeed = 5.0f; // Rotation speed

    void Update()
    {
        if (target == null) return;

        // 1. Calculate target Quaternion to face target
        Vector3 direction = target.position - transform.position;
        Quaternion targetRotation = Quaternion.LookRotation(direction);

        // 2. Interpolate between current rotation and target rotation using Slerp
        // Control interpolation rate with Time.deltaTime * rotationSpeed for frame-rate independent smooth motion
        transform.rotation = Quaternion.Slerp(
            transform.rotation, // Current rotation
            targetRotation,     // Target rotation
            Time.deltaTime * rotationSpeed // Interpolation rate
        );
    }
}

Difference Between Lerp and Slerp

Using Vector3.Lerp (linear interpolation) for rotation can result in unnatural motion where speed changes during rotation or doesn't take the shortest path. On the other hand, Quaternion.Slerp moves along the shortest distance on a sphere, always achieving the most natural rotation at a constant speed. Always use Slerp for rotation interpolation.

Summary

This article explained Quaternion, the key to rotation control in Unity development. While Quaternion may seem complex, understanding its role and basic usage enables more advanced and natural game expressions.

Here are the key takeaways:

• Quaternion is a mathematical representation that avoids gimbal lock and enables smooth rotation.
• While Euler angles displayed in the Inspector are intuitive, Quaternion is recommended for handling rotation in scripts.
• When specifying rotation with Euler angles, always use the Quaternion.Euler() method to convert to Quaternion before assigning.
• Use Quaternion.LookRotation() to make objects face a specific direction.
• Using Quaternion.Slerp() (spherical linear interpolation) is essential for smoothly changing rotation over time.

Mastering these fundamentals will significantly improve rotation control in your Unity projects.