Rigidbody Jerk

Unity Engine
1

Hello,

I am having some problems with a Rigidbody object ‘jerking’ (essentially jumping instead of moving smoothly.

Here is the scene, a ship is being moved by rigidbody force and a camera is lerped behind the ship and takes the ships rotation value.

The relevant code is below:

var ship : Transform;
var maxSpeed = 20;
var speed : float = 0.0;
public var wantedPosition;

function FixedUpdate () {

var thrustFactor : BasicGUI = gameObject.GetComponent(BasicGUI);

speed = (maxSpeed * thrustFactor.mySlider) /100;

ship.rigidbody.AddRelativeForce (Vector3.forward * speed);
wantedPosition= ship.TransformPoint(0, 1, -5);

}

function LateUpdate () {

transform.position = Vector3.Lerp(transform.position,wantedPosition, Time.deltaTime * 6);
transform.rotation =(Quaternion.Lerp (transform.rotation, ship.rotation, 1));

}

If it is relevant, the rigidbody for the ship has 1 mass and 1 drag.

Any help with this would be much appreciated, thank you.

2

I’ve struggled with this problem too. I suspect it has to do with the render being out of sync with the physics.

What seems to fix it for me is to not lerp on global positions. Instead only lerp positions relative to the physics object and add them together.

I hope that makes sense. I’ll post my camera script tomorrow (not on my work computer now).

3

Have you tried one of the Interpolate settings under your Rigidbody settings?

Stuart.

4

Yes I have tried using interpolate on both the camera and the object (and both independantly) and this just makes it even more jerky I am sad to say.
Thanks Yorick, I look forward to seeing your method!

5

If you want smoothness, always update the camera in the update loop. FixedUpdate() runs on a fixed schedule, but Update runs on a variable frame rate. As such, the time between FixedUpdate() calls is variable and causes jerking.

The solution is to always make your movements either in Update() (if you don’t care about Physics) or in LateUpdate() (if you want to overwrite Physics). I’ve made numerous smooth cameras, and FixedUpdate() does not agree with them when frame rates drop below the frame rate limit or the frame rate is variable.

One particular note is that you should generally have the camera update in LateUpdate() if following something affected by Physics. The camera would move before the object or character, otherwise, causing jerkiness.

6

@GargerathSunman
Isn’t that exactly what he’s doing now? He updates physics in FixedUpdate and updates the cameraposition in LateUpdate.

@mark104
I’ve attached my camerascript
I don’t know if this script helps because I hardly understand it myself anymore :sweat_smile:

It will follow a target based on it’s velocity. So even if the Target is slipping the camera will look in the direction the target is traveling.

// The target we are following
var target : Transform;
var distance = 2.1;
var height = 0.6;
var heightDamping = 2.0;
var rotationDamping = 3.0;
var distanceLerped : float;
var heightLerped : float;

function LateUpdate () {
	
	if(target.rigidbody)
	{
	
	//Calculate the angle the target is travelling in
	var velocityVector = new Vector3(target.rigidbody.velocity.x,0,target.rigidbody.velocity.z);
	
	var angleRad = Mathf.Atan2(velocityVector.x, velocityVector.z);
	var angleDeg = (angleRad/6.28) * 360;
	wantedRotationAngle = angleDeg;
	wantedRotation = Quaternion.Euler (0, wantedRotationAngle, 0);
	
	currentRotationAngle = transform.eulerAngles.y;
	currentRotationAngle = Mathf.LerpAngle (currentRotationAngle, wantedRotationAngle, rotationDamping * Time.deltaTime);
	currentRotation = Quaternion.Euler (0, currentRotationAngle, 0);
	
	distance = 1.4 + ((target.rigidbody.velocity.magnitude/35)*1.2);
	distanceLerped = Mathf.Lerp(distanceLerped, distance, Time.deltaTime);
	
	height = 0.4 - ((Mathf.Clamp(target.rigidbody.velocity.y,-12,12) / 12)*1.1);
	heightLerped = Mathf.Lerp(heightLerped,height, Time.deltaTime * 6);	
	
	wantedHeight = target.position.y + heightLerped;
	wantedCamPos = target.position - (currentRotation * Vector3.forward * distanceLerped);
	wantedCamPos.y = wantedHeight;
	
	//shoot a raycast to the desired Cam position to see if we hit anything
	var hitInfo:RaycastHit;
	var targetPos:Vector3;	
	if (Physics.Raycast(target.position, wantedCamPos - target.position , hitInfo, distanceLerped))
	{		
		targetPos = hitInfo.point;
	}
	else
	{
		targetPos = wantedCamPos;
	}	
	transform.position = targetPos;
	
	// Always look at the target
	transform.LookAt (target.position);
	}
}
7

Thanks for the code Yorick, sadly (although I too don’t understand it fully) is what im looking for.
Although indeed that script does keep up with the ship, what im trying to do is to keep the lerp rather than with a set position.
The reasoning for this is to give a sense of rotation for when the ship turns, the camera taking time to catch up really lets the player see their ship turn.

Any suggetions on how to go about that? Im looking into it myself but not to much avail sadly. :frowning:

8

Unfortunately camera logic is always more tricky then you think. Good luck with it. Please post if you have any revelations.

9

@Yorick: True. I apparently misread the code. Still, the issue is related.

The frame rate is constant for FixedUpdate and variable for LateUpdate. When you lerp, you’ll have multiple frames of lerping for every frame of movement. (Or at least that’s what appears to happen, anyway) The number of frames of lerp is variable, so you end up with a terrible stutter.

In a case like this, you might be best off just assigning a velocity to the camera and making it a rigidbody as well. You can follow by mimicking the velocity of the ship until the camera is looking at it properly and the correct distance away. The only real tricky part would be getting the angular velocity correct.

10

Does this suggest to handle the camera just in fixed update too because it will then be driven by physics?

I’m playing around with the same issue. The camera displays choppy images when I handle the Camera movement in LateUpdate(). My race game project handles a lot of physics in FixedUpdate(). I tried already a few things like increase the time-stamp from 0.02 to 0.03 or increasing the solver iteration count.

However I can solve the problem with just disabling the Rigidbody Interpolation and handle all camera movement from the SmoothFollow script in fixedUpdate(). The whole thing starts to run just awesome smooth. I guess that the major drawback will at an later time performance if the game project got heavier populated.

Further suggestion how to sync Physics in LateUpdate() ?

Peter.

11

The problem in this case is that the lerping won’t be constant even when multiplying by Time.deltaTime. The reason behind it is that the percentage of movement is not always the same as the percentage of movement multiplied by Time.deltaTime for the extra number of frames. If you move 5% once every 20 frames, that would give you a .95 remaining distance. If you move 5% / 20 frames every frame, you get a .9517 remaining distance. The disconnect causes the jitter.

You can usually use a set position relative to the object, though, which is generally smooth. Alternatively, you can smooth-move the camera using a rigidbody, which also works well. You’d basically assign a velocity and angularVelocity every frame that’s designed to get the camera to reach a certain optimum distance and difference in angle.

Update() or LateUpdate() would only really be useful in the assigning of a position relative to the object followed or when player input would affect the positioning of the camera. All movement based on Physics is best kept inside FixedUpdate() at a later line than the code affecting an object’s position or rotation.

12

For what it is worth:

I got rid of my choppy Camera movement in LateUpdate() trough an combined mesh that the camera is following. http://forum.unity3d.com/viewtopic.php?t=23900&postdays=0&postorder=asc&start=0. I placed in my Car Physics script things like wheel rotation or steering graphics also in LateUpdate() and the hole thing is just running smooth!

Peter.

13

Is there a solution to this?

14

My rigidbody had choppy movement until I turned off interpolation. It doesn’t seem like a universal solution but it worked for me.

1 Like
15

That way of using Lerp with deltaTime in the 3rd parameter is plain wrong and yet so much used. If you want to do damping use: http://docs.unity3d.com/ScriptReference/Vector3.SmoothDamp.html

It seems that lerping is often confused with damping or tweening, which are 3 different techniques.

That simplifies to:

transform.rotation = ship.rotation;