Interpolating rigidbody rotations properly? [SOLVED, I have code people can use!]

Unity Engine
1

Hey guys, here to ask two questions.

Basically, for a racing game, I am setting a custom rotation each fixed update so that the car aligns with the ground. Obviously, setting a rigidbody’s rotation via rigidbody.rotation doesn’t allow it to interpolate, so I’m using MoveRotation() to do it.

Now, using rigidbody’s interpolation, the actual movement is silky smooth. And according to the docs, using MoveRotation should also smoothly interpolate between fixed updates.

However, this isn’t the result; instead, the car moves smoothly, but rotations look like they’re occurring at half the frame rate or in a very jerky fashion, suggesting interpolation isn’t working as intended. Is this a bug or am I doing something wrong?

(Oh, and inb4 “use addtorque,” that isn’t feasible here where I need precise control of the rotations)

1 Like
2

The rigidbody should be kinematic for that scenario to work. Otherwise, both you and the physics are calculating different rotations, and the transform will be interpolated using the value calculated by the physics.

This is what’s happening right now:

  • FixedUpdate: you set a custom rotation.
  • Internal Physics Update: physics uses your custom rotation as current state, then calculates a new rotation out of it.
  • Visual Update cycle: the transform’s rotation is interpolated using the new rotation calculated by the physics, not yours.

Hence you have the jerky rotation.

Possible solutions:

  • Use a kinematic rigidbody and apply both position and rotation.
  • Set your rotation after the internal physics update and before the visual update. Currently, the only way to do this in a reliable way is is from the OnTriggerStay event, which is executed right after the internal physics update. It’s an ugly hack that requires you to have a large collider marked as trigger in your scene, so you could get the OnTriggerStay method triggered in your car’s rigidbody every fixed frame.
  • Continue as now, but interpolate the rotation yourself in the Update (LateUpdate?) method.
3
  1. I could try that later when I get back to my PC, but due to wanting to use velocity for realistic acceleration, I generally stay away from kinematic stuff

EDIT: Kinematic also can’t collide so that’s out
2) as you said, ugly hack, so probably a big fat nope
3) This one I actually tried, but I just can’t get the interpolation factor right…

In any case, thank you for your help :slight_smile:

1 Like
4

Just a side note: calling MovePosition in each FixedUpdate frame populates Rigidbody.velocity in a kinematic rigidbody correctly. Same with MoveRotation and angularVelocity.

5

I’ve been trying to get an angularVelocity update routine made to have it function like MoveRotation (give it a quaternion). I attempted a PID-like controller for quaternions, but either I can’t find the right values to give it or I’ve seriously misunderstood something here.

Code:

using UnityEngine;

[System.Serializable]
public class quatPID {
    public float pFactor, iFactor, dFactor;
       
    float integralAngle = 0;
    Vector3 integralAxis = new Vector3();
    float lastErrorAngle = 0;
    Vector3 lastErrorAxis = new Vector3();
   
   
    public quatPID(float pFactor, float iFactor, float dFactor) {
        this.pFactor = pFactor;
        this.iFactor = iFactor;
        this.dFactor = dFactor;
    }
   
   
    public Quaternion Update(Quaternion setpoint, Quaternion actual, float timeFrame) {
        float setpointAngle;
        Vector3 setpointAxis;
        setpoint.ToAngleAxis(out setpointAngle, out setpointAxis);
        float actualAngle;
        Vector3 actualAxis;
        actual.ToAngleAxis(out actualAngle, out actualAxis);

        float presentAngle = setpointAngle - actualAngle;
        integralAngle += timeFrame * presentAngle;

        Vector3 presentAxis = setpointAxis - actualAxis;
        integralAxis += timeFrame * presentAxis;

        float derivAngle = (presentAngle - lastErrorAngle) / timeFrame;
        lastErrorAngle = presentAngle;

        Vector3 derivAxis = (presentAxis - lastErrorAxis) / timeFrame;
        lastErrorAxis = presentAxis;

        Quaternion ret = Quaternion.AngleAxis(presentAngle * pFactor + integralAngle * iFactor + derivAngle * dFactor, presentAxis * pFactor + integralAxis * iFactor + derivAxis * dFactor);

        return ret;
    }


    public Vector3 UpdateAngularVelocity(Quaternion setpoint, Quaternion actual, float timeFrame)
    {
        float setpointAngle;
        Vector3 setpointAxis;
        setpoint.ToAngleAxis(out setpointAngle, out setpointAxis);
        float actualAngle;
        Vector3 actualAxis;
        actual.ToAngleAxis(out actualAngle, out actualAxis);

        float presentAngle = setpointAngle - actualAngle;
        integralAngle += timeFrame * presentAngle;

        Vector3 presentAxis = setpointAxis - actualAxis;
        integralAxis += timeFrame * presentAxis;

        float derivAngle = (presentAngle - lastErrorAngle) / timeFrame;
        lastErrorAngle = presentAngle;

        Vector3 derivAxis = (presentAxis - lastErrorAxis) / timeFrame;
        lastErrorAxis = presentAxis;

        // Rotation Axis * Rotation Speed
        Vector3 ret = (presentAxis * pFactor + integralAxis * iFactor + derivAxis * dFactor).normalized * (presentAngle * pFactor + integralAngle * iFactor + derivAngle * dFactor);
        return ret;
    }
}

I can PID a Vector3 position by updating velocity with this algorithm, but for whatever reason I can’t seem to get it working with angularVelocity :frowning:
When I have it try to keep something upright (Quaternion.identity) and move the x axis, it will spin for a moment and then twitch around the upright position as though it’s sorta working. Then, any sort of angular motion throws it into instability and it just spins out of control. :rage:

6

huh, that’s interesting. thanks for the clarification.

Is it possible that interpolation isn’t working due to having the rotation axis frozen?

try zeroing your angular velocity first before modifying it, that’s the best thing I can think of.

7

I just now tried changing it to set the angularVelocity directly instead of accelerating it. It was the exact same outcome. :face_with_spiral_eyes: PID magic I says!

8

Just replying to say that I have a partial solution, and that is to split the mesh + particle systems into their own object, have colliders + rigidbody in another object, and interpolate the render object transform every update frame. (This also means disabling rigidbody interp completely)
It stutters a little sometimes, but it is a LOT better than before.

To benefit others, I will make a separate script that can be put on any object to do this

9

I’ve asked @yant (Unity Physics dev) and he pointed out another solution: set Physics.autoSimulation to false and write your own physics loop by calling Physics.Simulate yourself. There’s a handy sample code here:

So this seems the officially supported way of accessing the transforms right after being updated by the physics. The interpolation and everything else should work properly when modifying the rotation right after calling Physics.Simulate.

10

tfw you’re still using 5.4.3f1 :confused:
Hence why I rolled my own interpolation.
For mine, the idea is to put all your visual objects like meshes, particle systems, etc. into their own object, put colliders and stuff into another object, then at runtime, detach the rendered object and fully control it via script.
An example of what I am roughly doing is this:

Quaternion previousRotation; //previous rigidbody rotation
Vector3 previousPosition; //previous rigidbody position
Rigidbody cache; //Rigidbody cache
Transform renderNode; //transform with renderers/particle system objects as children.

void Start () {
cache = GetComponent<Rigidbody>();
previousPosition = cache.position;
previousRotation = cache.rotation;
renderNode.parent = null; //detach, we are now in control!
}

void Update () {
float interpFactor = (Time.time - Time.fixedTime) / Time.fixedDeltaTime;
renderNode.position = Vector3.Lerp(previousPosition, cache.position, interpFactor);
renderNode.rotation  = Quaternion.Lerp(previousRotation, cache.rotation, interpFactor);
}

void FixedUpdate () {
renderNode.position = cache.position;
renderNode.rotation = cache.rotation;
previousPosition = renderNode.position;
previousRotation = renderNode.rotation;
//do physics stuff here:
//blah blah blah
}

Obviously, for my case, I’ve gone and integrated this directly into my main vehicle script, rather than using a separate component.
Also, if you decide to use this (I’m putting this out for free, do whatever you want with it! :)) make sure to TURN OFF rigidbody interpolation as it is now handled by the script.

1 Like
11

I think Slerp might give you better interpolation for your rotation.

2 Likes
12

Yea, generally, I’d use Slerp, but I didn’t see any difference between it and lerp tbh.
That said, if you’re going to use that code, feel free to change it, I won’t stop you. :slight_smile:

13

I had similar issues with jittering that I managed to resolve and wanted to share (hope it helps someone else).

I have a custom third person character controller that is physics based.
I use Cinemachine + ‘CinemachineInputProvider’ for controlling cameras.
When rotating camera, character is rotating towards the camera forward direction.
I use the new Input System.

Explanation of what you should be mindful of to eliminate jittering/stutter (if you have physics based controller):

  • You should read inputs in ‘Update()’
  • You should use ‘InputValueGain’ in Cinemachine camera aim section, to make Input framerate independent.
    CineMachine and Framerate
  • You should set appropiate values of acceleration and decceleration on Cinemachine camera aim section (it doesn’t fix jitter per se, but it makes overall feeling more smoothed)
  • You should apply movement by using ‘Rigidbody’ methods eg. ‘rigidbody.Move()’, ‘rigidbody.AddForce()’ and etc
  • You should NOT manipulate transform position directly, to move object
  • You should apply movement in ‘FixedUpdate()’
  • You should set ‘Interpolation’ mode on ‘Rigidbody’ to ‘Interpolate’
  • Because rotation of the player is depending on camera forward direction you need to apply player rotation AFTER camera has rotated. Camera is rotating on ‘Update’ calls, because of that you can not apply player rotation in
    ‘FixedUpdate()’ - ‘FixedUpdate()’ in Unity is called before ‘Update()’. So you need to create a delayed/late ‘FixedUpdate()’ and apply player rotation there (example provided below).
  • When rotating the player it is often that before the player fully rotates towards the camera forward direction, the camera will change to face a new direction.
    In that case the player will start rotating to the newer forward direction of the camera (before the player finished his first rotation).
    This could lead to some other type of jittering, that can be smoothed by using ‘SmoothDampAngle()’ or ‘SmoothDamp()’.
    Unity - Scripting API: Mathf.SmoothDampAngle
    Unity - Scripting API: Vector3.SmoothDamp
  • My full project is publicly available and can be accessed via
    GitHub - mnijaki/AutoAimBowAndArrow
private readonly WaitForFixedUpdate _waitForFixedUpdate = new();
private float _tmpRotationVelocity;
[SerializeField]
private float _rotationSmoothTime = 0.1F;

private void Awake()
{
   StartCoroutine(LateFixedUpdate());
}

private IEnumerator LateFixedUpdate()
{
  while(true)
  {
    yield return _waitForFixedUpdate;
    HandleRotation();
   }
}

private void HandleRotation()
{
  // Rotate player in direction where camera is facing ('SmoothDampAngle' is used, so no jitter occurs).
  var targetHorizontalAngle = Mathf.SmoothDampAngle(_rigidbody.rotation.eulerAngles.y,
                                                    _cameraTransform.eulerAngles.y,
                                                    ref _tmpRotationVelocity,
                                                    _rotationSmoothTime,
                                                    float.MaxValue,
                                                    Time.fixedDeltaTime);
  Quaternion targetRotation = Quaternion.Euler(0.0F,targetHorizontalAngle,0.0F);
  _rigidbody.MoveRotation(targetRotation);
}
3 Likes
14

Just wanted to thank you for this code. I was shocked once I implemented it. Beautifully smooth!

1 Like
15

I previously just took a ready-made solution from the forums and used it in my projects. But now I am ready to leave my first comment to thank you for this solution!