QuaternionExtensions.cs

using UnityEngine;

public static partial class QuaternionExtensions
{
    /// <summary>
    /// Gradually changes a quaternion towards a desired goal over time.
    /// The quaternion is smoothed by some spring-damper like function, which will never overshoot.
    /// </summary>
    /// <param name="current">Current rotation to interpolate from.</param>
    /// <param name="target">Target rotation to interpolate to.</param>
    /// <param name="velocity">Temporary rotation velocity coefficient, modified in each function iteration.</param>
    /// <param name="time">Time of interpolation.</param>
    /// <returns>Result of the iteration.</returns>
    public static Quaternion SmoothDamp(this Quaternion current, Quaternion target, ref Quaternion velocity, float time)
    {
        var dot = Quaternion.Dot(current, target);
        var scale = dot > 0f ? 1f : -1f;
        target.x *= scale;
        target.y *= scale;
        target.z *= scale;
        target.w *= scale;

        var result = new Vector4(
            x: Mathf.SmoothDamp(current.x, target.x, ref velocity.x, time),
            y: Mathf.SmoothDamp(current.y, target.y, ref velocity.y, time),
            z: Mathf.SmoothDamp(current.z, target.z, ref velocity.z, time),
            w: Mathf.SmoothDamp(current.w, target.w, ref velocity.w, time)
        ).normalized;

        var dt = 1f / Time.deltaTime;
        velocity.x = (result.x - current.x) * dt;
        velocity.y = (result.y - current.y) * dt;
        velocity.z = (result.z - current.z) * dt;
        velocity.w = (result.w - current.w) * dt;

        return new Quaternion(result.x, result.y, result.z, result.w);
    }
}