Cat Racer MMV

The rig is core of it. There’s a parent gameobject for the camera that in the scene setup is attached to the car. All the camera’s motion is relative to this gameobject. I don’t actually move the camera at all in this simple setup, I’m only moving the root node.

On the scene’s start, I detach the camera parent object from the car so that it can move freely. 

If I did nothing else, this would leave the camera behind as the car drives away, so every frame (fixedUpdate in this case because it simplifies things) I do a simple lerp to move the parent to the car’s position. Lerping (or linear interpolation) is a simple way to get smooth motion out of anything. This lerping is also why when the car starts driving away, the camera pulls back a little and lags behind.

// Moves the camera to match the car’s position.rootNode.position = Vector3.Lerp(rootNode.position, car.position, cameraStickiness * Time.fixedDeltaTime);

The built in Unity follow script does this too, but I don’t think it works well for a car camera because all it does is look at what it’s following.

The way I did it instead was to make the camera rig, look towards the car’s velocity vector. This has several advantages. If your game has a lot of drifting, the camera will look at where the car is going rather than where the car is pointing. If your game has jumps, the camera will automatically look down towards where you’re going to land. If you go into reverse, the camera will automatically look behind you.

The only trick to this is that Quaternions hate zero values. It’s also advantageous to make it so that if you’re not moving, or moving slowly, the camera just defaults to looking forwards. Here’s how I get the look rotation:

// If the car isn’t moving, default to looking forwards. Prevents camera from freaking out with a zero velocity getting put into a Quaternion.LookRotationif (carPhysics.velocity.magnitude < rotationThreshold)    look = Quaternion.LookRotation(car.forward);else    look = Quaternion.LookRotation(carPhysics.velocity.normalized);

From there, it’s just performing the actual rotation. Like before, I use a slerp (basically the rotation version of lerp) to make sure that the rotations are smooth.

// Rotate the camera towards the velocity vector.look = Quaternion.Slerp(rootNode.rotation, look, cameraRotationSpeed * Time.fixedDeltaTime);                rootNode.rotation = look;

And that’s really it. Aside from some trivial book keeping code that’s all that drives the camera. If I were to use this for a real project I would add some other little features like a limit to how far away the camera is allowed to go or maybe some kind of predictive lookahead, but this works as a simple base for whatever you might want to expand it into doing.

GT Tee pre-orders are closed!

Thanks to everyone for your orders. Backers should have all received their $5.00 off at this time.