Quaternion SmoothDamp Function

2025-02-01 21:47 UTC o3-mini Open in ChatGPT ↗

You

Create a unity function that performs the same logic as SmoothDamp, but on quaternions

ChatGPT

Below is one way to implement a “SmoothDamp” for quaternions. The idea is to measure the difference between the current and target rotations as an “angular difference vector” (in radians) and then use Unity’s built‐in Vector3.SmoothDamp to smooth that vector. Finally, we “apply” the smoothed rotation difference onto the current rotation. (Note that quaternions don’t form a vector space so we work in angle–axis space.)

You can use the function as follows:

• Call it every frame.
• Pass a reference to a Vector3 that stores the current angular velocity (in radians per second).
• Supply a smoothing time and (optionally) a maximum angular speed.

Below is the complete code:

using UnityEngine;

public static class QuaternionExtensions
{
    /// <summary>
    /// Smoothly damps between two rotations.
    /// </summary>
    /// <param name="current">The current rotation.</param>
    /// <param name="target">The target rotation.</param>
    /// <param name="angularVelocity">The current angular velocity (in radians per second). This is modified by the function.</param>
    /// <param name="smoothTime">Approximately the time it will take to reach the target. Smaller values will reach the target faster.</param>
    /// <param name="maxAngularSpeed">Optionally, the maximum angular speed (in radians per second). Use Mathf.Infinity if no limit is desired.</param>
    /// <param name="deltaTime">The time step to use (for example, Time.deltaTime).</param>
    /// <returns>The new rotation after smoothing.</returns>
    public static Quaternion SmoothDamp(Quaternion current, Quaternion target, ref Vector3 angularVelocity, float smoothTime, float maxAngularSpeed, float deltaTime)
    {
        // If no time passed, just return the current rotation.
        if (deltaTime < Mathf.Epsilon)
            return current;

        // Compute the relative rotation from current to target.
        // Note: The multiplication order matters.
        Quaternion deltaRotation = target * Quaternion.Inverse(current);

        // To ensure the shortest path is taken, we may need to negate the rotation.
        if (deltaRotation.w < 0f)
        {
            deltaRotation.x = -deltaRotation.x;
            deltaRotation.y = -deltaRotation.y;
            deltaRotation.z = -deltaRotation.z;
            deltaRotation.w = -deltaRotation.w;
        }

        // Convert the relative rotation to angle-axis form.
        deltaRotation.ToAngleAxis(out float angleInDegrees, out Vector3 rotationAxis);
        // When the angle is very small, ToAngleAxis might return NaN for the axis.
        if (float.IsNaN(rotationAxis.x))
            rotationAxis = Vector3.zero;

        // Clamp the angle between -180 and 180 degrees.
        if (angleInDegrees > 180f)
            angleInDegrees -= 360f;

        // Convert angle to radians for our damping calculations.
        float angleInRadians = angleInDegrees * Mathf.Deg2Rad;

        // The angular difference (as a vector) is the rotation axis multiplied by the angle (in radians).
        Vector3 deltaAngle = (rotationAxis.normalized * angleInRadians);

        // Smoothly damp the deltaAngle from 0 towards our desired delta.
        // We use Vector3.SmoothDamp here. The “current” value is zero because we are measuring the delta.
        Vector3 smoothedDeltaAngle = Vector3.SmoothDamp(Vector3.zero, deltaAngle, ref angularVelocity, smoothTime, maxAngularSpeed, deltaTime);

        // Convert the smoothed angular difference back into a quaternion.
        // (Remember that Quaternion.AngleAxis expects degrees.)
        Quaternion smoothedRotation = Quaternion.AngleAxis(smoothedDeltaAngle.magnitude * Mathf.Rad2Deg,
                                                             smoothedDeltaAngle.sqrMagnitude < 1e-6f ? Vector3.up : smoothedDeltaAngle.normalized);

        // Apply the smoothed rotation onto the current rotation.
        return smoothedRotation * current;
    }
}

How It Works

1. Compute the Relative Rotation:
   We compute deltaRotation = target * Quaternion.Inverse(current). This represents the rotation needed to go from the current rotation to the target rotation. We also ensure that the quaternion represents the shortest path by flipping it if needed.

2. Convert to Angle–Axis:
   We extract the angle (in degrees) and axis from deltaRotation. We then convert the angle to radians.

3. Smooth the Angular Difference:
   We build an angular difference vector (deltaAngle) by multiplying the (normalized) axis by the angle in radians. Using Vector3.SmoothDamp, we smoothly approach this target difference from zero. The angularVelocity vector is updated by SmoothDamp (just like in the float and Vector3 versions).

4. Reconstruct the Quaternion:
   Finally, we convert the smoothed angular difference back into a quaternion using Quaternion.AngleAxis (note that it expects degrees) and apply that rotation on top of the current rotation.

Usage Example

Here’s an example of how you might use the function in a MonoBehaviour:

using UnityEngine;

public class SmoothDampRotationExample : MonoBehaviour
{
    public Transform targetTransform;
    public float smoothTime = 0.3f;
    public float maxAngularSpeed = Mathf.Infinity;
    private Vector3 angularVelocity = Vector3.zero;

    void Update()
    {
        if (targetTransform != null)
        {
            transform.rotation = QuaternionExtensions.SmoothDamp(
                transform.rotation,
                targetTransform.rotation,
                ref angularVelocity,
                smoothTime,
                maxAngularSpeed,
                Time.deltaTime);
        }
    }
}

This script will smoothly rotate the GameObject’s transform to match that of the targetTransform using our custom quaternion smoothing function.

Feel free to adjust the parameters and test the function to see how it behaves for your needs.

You

turn it into an actual extension method

ChatGPT

Below is the code transformed into an extension method. You can now call SmoothDamp directly on any Quaternion instance:

using UnityEngine;

public static class QuaternionExtensions
{
    /// <summary>
    /// Smoothly damps between two rotations.
    /// </summary>
    /// <param name="current">The current rotation (as the 'this' extension parameter).</param>
    /// <param name="target">The target rotation.</param>
    /// <param name="angularVelocity">
    /// The current angular velocity (in radians per second). This is modified by the function.
    /// </param>
    /// <param name="smoothTime">
    /// Approximately the time it will take to reach the target. Smaller values will reach the target faster.
    /// </param>
    /// <param name="maxAngularSpeed">
    /// Optionally, the maximum angular speed (in radians per second). Use Mathf.Infinity if no limit is desired.
    /// </param>
    /// <param name="deltaTime">
    /// The time step to use (for example, Time.deltaTime).
    /// </param>
    /// <returns>The new rotation after smoothing.</returns>
    public static Quaternion SmoothDamp(this Quaternion current, Quaternion target, ref Vector3 angularVelocity, float smoothTime, float maxAngularSpeed, float deltaTime)
    {
        // If no time has passed, return the current rotation.
        if (deltaTime < Mathf.Epsilon)
            return current;

        // Compute the relative rotation from current to target.
        Quaternion deltaRotation = target * Quaternion.Inverse(current);

        // Ensure the shortest path is taken.
        if (deltaRotation.w < 0f)
        {
            deltaRotation.x = -deltaRotation.x;
            deltaRotation.y = -deltaRotation.y;
            deltaRotation.z = -deltaRotation.z;
            deltaRotation.w = -deltaRotation.w;
        }

        // Convert the relative rotation to angle-axis form.
        deltaRotation.ToAngleAxis(out float angleInDegrees, out Vector3 rotationAxis);
        if (float.IsNaN(rotationAxis.x))
            rotationAxis = Vector3.zero;

        // Clamp the angle to be between -180 and 180 degrees.
        if (angleInDegrees > 180f)
            angleInDegrees -= 360f;

        // Convert the angle to radians.
        float angleInRadians = angleInDegrees * Mathf.Deg2Rad;

        // Compute the angular difference as a vector.
        Vector3 deltaAngle = rotationAxis.normalized * angleInRadians;

        // Smooth the angular difference using Vector3.SmoothDamp.
        Vector3 smoothedDeltaAngle = Vector3.SmoothDamp(Vector3.zero, deltaAngle, ref angularVelocity, smoothTime, maxAngularSpeed, deltaTime);

        // Reconstruct the quaternion from the smoothed angular difference.
        // Use a fallback axis if the smoothed angle is very small.
        float smoothedAngle = smoothedDeltaAngle.magnitude;
        Quaternion smoothedRotation = Quaternion.AngleAxis(smoothedAngle * Mathf.Rad2Deg,
                                                             smoothedAngle < 1e-6f ? Vector3.up : smoothedDeltaAngle.normalized);

        // Apply the smoothed rotation to the current rotation.
        return smoothedRotation * current;
    }
}

How to Use the Extension Method

With this extension in place, you can call it directly on any Quaternion. For example, in a MonoBehaviour:

using UnityEngine;

public class SmoothDampRotationExample : MonoBehaviour
{
    public Transform targetTransform;
    public float smoothTime = 0.3f;
    public float maxAngularSpeed = Mathf.Infinity;
    private Vector3 angularVelocity = Vector3.zero;

    void Update()
    {
        if (targetTransform != null)
        {
            // Now you can call SmoothDamp as an extension method on the current rotation.
            transform.rotation = transform.rotation.SmoothDamp(
                targetTransform.rotation,
                ref angularVelocity,
                smoothTime,
                maxAngularSpeed,
                Time.deltaTime);
        }
    }
}

This will smoothly rotate the GameObject from its current rotation to the target rotation over time using a damped angular velocity.

You

this script does nothing

ChatGPT

Below is an updated version of the extension method with some extra commentary and minor adjustments that may help if you’re not seeing any visible change. In many cases when “nothing happens” it’s because of one (or more) of the following reasons:

1. Very Small Rotation Difference:
   If your current and target rotations are nearly the same, the computed difference is tiny—resulting in little or no perceptible change. Make sure your target rotation is meaningfully different from the current rotation.

2. Smoothing Parameters Too High/Low:
   A very long smoothing time or extremely high damping can make the rotation change extremely slowly (or too abruptly). Experiment with different smoothTime and maxAngularSpeed values.

3. Angular Velocity Not Persisted:
   The angular velocity must be stored between frames (for example, as a member variable) so that the damping function has memory of its past state. If it’s declared locally (or reinitialized each frame), the smoothing effect won’t accumulate properly.

Below is a revised extension method that implements quaternion smoothing using a similar approach to Vector3.SmoothDamp:

using UnityEngine;

public static class QuaternionExtensions
{
    /// <summary>
    /// Smoothly damps between two rotations.
    /// </summary>
    /// <param name="current">The current rotation (this extension parameter).</param>
    /// <param name="target">The target rotation.</param>
    /// <param name="angularVelocity">
    /// The current angular velocity (in radians per second). This is updated by the function.
    /// Must be stored outside of this function to accumulate the damping state between frames.
    /// </param>
    /// <param name="smoothTime">
    /// Approximately the time it will take to reach the target. Smaller values reach the target faster.
    /// </param>
    /// <param name="maxAngularSpeed">
    /// Optionally, the maximum angular speed (in radians per second). Use Mathf.Infinity if no limit is desired.
    /// </param>
    /// <param name="deltaTime">
    /// The time step to use (for example, Time.deltaTime).
    /// </param>
    /// <returns>The new smoothed rotation.</returns>
    public static Quaternion SmoothDamp(this Quaternion current, Quaternion target, ref Vector3 angularVelocity, float smoothTime, float maxAngularSpeed, float deltaTime)
    {
        // If no time has passed, return the current rotation.
        if (deltaTime < Mathf.Epsilon)
            return current;

        // Compute the relative rotation from current to target.
        // Using: q = Inverse(current) * target, then reapply to current.
        Quaternion q = Quaternion.Inverse(current) * target;

        // Ensure the quaternion represents the shortest path.
        if (q.w < 0f)
        {
            q.x = -q.x;
            q.y = -q.y;
            q.z = -q.z;
            q.w = -q.w;
        }

        // Extract the angle (in degrees) and axis from the relative rotation.
        q.ToAngleAxis(out float angleInDegrees, out Vector3 rotationAxis);

        // If the angle is very small, there's nothing to do.
        if (Mathf.Abs(angleInDegrees) < 0.001f)
            return target;

        // Clamp the angle to be between -180 and 180.
        if (angleInDegrees > 180f)
            angleInDegrees -= 360f;

        // Convert angle to radians.
        float angleInRadians = angleInDegrees * Mathf.Deg2Rad;

        // Compute the angular difference vector.
        Vector3 deltaAngle = rotationAxis.normalized * angleInRadians;

        // Smoothly damp the deltaAngle from 0 to the desired delta using Vector3.SmoothDamp.
        Vector3 smoothDeltaAngle = Vector3.SmoothDamp(Vector3.zero, deltaAngle, ref angularVelocity, smoothTime, maxAngularSpeed, deltaTime);

        // Reconstruct the rotation step from the smoothed delta angle.
        // If smoothDeltaAngle is nearly zero, use the original axis (avoiding divide-by-zero).
        float smoothAngleDegrees = smoothDeltaAngle.magnitude * Mathf.Rad2Deg;
        Quaternion stepRotation = Quaternion.AngleAxis(smoothAngleDegrees,
            smoothDeltaAngle.sqrMagnitude < 1e-6f ? rotationAxis : smoothDeltaAngle.normalized);

        // Apply the step rotation to the current rotation.
        return current * stepRotation;
    }
}

Usage Example

Make sure that you store the angular velocity between frames (for example, as a field in your MonoBehaviour). Then call the extension method every frame:

using UnityEngine;

public class SmoothDampRotationExample : MonoBehaviour
{
    public Transform targetTransform;
    public float smoothTime = 0.3f;
    public float maxAngularSpeed = Mathf.Infinity;

    // This angular velocity vector must persist between frames.
    private Vector3 angularVelocity = Vector3.zero;

    void Update()
    {
        if (targetTransform != null)
        {
            transform.rotation = transform.rotation.SmoothDamp(
                targetTransform.rotation,
                ref angularVelocity,
                smoothTime,
                maxAngularSpeed,
                Time.deltaTime);
        }
    }
}

Troubleshooting Tips

• Verify Input Rotations:
  Ensure that your targetTransform actually has a different rotation from your current transform. A nearly identical rotation can result in negligible change.

• Adjust Smoothing Parameters:
  Try lowering smoothTime to see a quicker response, or experiment with a finite value for maxAngularSpeed instead of Mathf.Infinity.

• Persist Angular Velocity:
  The angularVelocity must be maintained between frames. If it is reset every frame (for instance, if declared locally in Update()), the smoothing effect will not accumulate.

• Logging:
  You can add some debug logs (e.g., print out the computed angles or delta values) to verify that your function is calculating a non-zero rotation when expected.

With these adjustments and checks, you should see your GameObject gradually rotate from its current rotation toward the target rotation. If you still encounter issues, please let me know what your scene setup is and any specific parameter values so we can further diagnose the problem.