stupid camera jitter.

HOKAY, so here’s my issue. In the following code, I’m having an issue where I don’t want to use the smooth camera (mostly because I hate the look of it), so I found some nice code for a camera that “slides” into place whenever you turn. It really looks quite nice when you’re turning. Unfortunately, whenever you stop moving, the camera still attempts to slide into place, even though there’s nowhere to slide. This causes it to slowly flip-the-hell-out, shooting from side to side. It also has the issue that when you first get into car, it’s always facing to the side, rather than just automatically setting behind the car. Halp plz!

public class CarCamera : MonoBehaviour
	public Transform target = null;
	public float height = 1f;
	public float positionDamping = 3f;
	public float velocityDamping = 3f;
	public float distance = 4f;
	public LayerMask ignoreLayers = -1;

	private RaycastHit hit = new RaycastHit();

	private Vector3 prevVelocity =;
	private LayerMask raycastLayers = -1;
	private Vector3 currentVelocity =;
	void Start()
		raycastLayers = ~ignoreLayers;

	void FixedUpdate()
		currentVelocity = Vector3.Lerp(prevVelocity, target.root.rigidbody.velocity, velocityDamping * Time.deltaTime);
		currentVelocity.y = 0;
		prevVelocity = currentVelocity;
	void LateUpdate()
		float speedFactor = Mathf.Clamp01(target.root.rigidbody.velocity.magnitude / 70.0f);
		camera.fieldOfView = Mathf.Lerp(55, 72, speedFactor);
		float currentDistance = Mathf.Lerp(7.5f, 6.5f, speedFactor);
		currentVelocity = currentVelocity.normalized;
		Vector3 newTargetPosition = target.position + Vector3.up * height;
		Vector3 newPosition = newTargetPosition - (currentVelocity * currentDistance);
		newPosition.y = newTargetPosition.y;
		Vector3 targetDirection = newPosition - newTargetPosition;
		if(Physics.Raycast(newTargetPosition, targetDirection, out hit, currentDistance, raycastLayers))
			newPosition = hit.point;
		transform.position = newPosition;

I suspect that this might be a "physics" issue rather than a camera issue. You should assure that's the case or not by attaching the camera script to a static object in the scene.

If the issue is physics related (it's your camera's target jittering, not the camera), you'll need to tweak your camera target's motor. On the other case, you might just need a dampener value for your camera interpolations which are possibly better off like

camera.fieldOfView = Mathf.Lerp(55, 72, speedFactor * Time.deltaTime);
float currentDistance = Mathf.Lerp(7.5f, 6.5f, speedFactor * Time.deltaTime);

oh and regarding the camera's initial rotation: let's just solve one problem at a time

If your currentVelocity is 0, newPosition and newTargetPosition will refer to the same location. At the end of your code you set the transform’s position to newPosition, and then try to look at newTargetPosition, which in this case, is the same point.

I am not sure how transform.LookAt() behaves in such a case, but in theory it should be undefined, because it can’t determine a viewing direction if your position and the lookat-target are identical.

Similarly, I can well imagine that transform.LookAt() will start to behave unpredictable and jerky once currectVelocity approaches zero (for example if the car slows down and stops), since the length of the viewing direction vector, required to determine the transform’s rotation, will also approach zero.

A solution to this dilemma could be, to define a “forward” direction, and always subtract this forward vector (or a fraction of it) from newTargetPosition. This will not only prevent the zero-length problem, but also solve the issue of initial orientation, and making sure that your follower will always adjust itself directly behind your object, looking towards it, once your object becomes static.