Skip to content

Camera Motion

Sometimes you just want to add a little motion to your camera to convey a mood or just to make things a little more dynamic than a static shot allows. You could use a cutscene to do that, but it's a bit cumbersome to do that if all you want is some basic motion. This section describes a number of dynamic motion effects you can add to cameras.

Waiting for Camera Motions

All of the motions in this page run in parallel; if you want to wait for them to complete, use the WaitCamera event:

[event WaitCamera]

See Waiting for Things for other wait commands.

How cameras are modified

All the motion effects in this section are applied using a dynamic Camera Modifier. This means that the actual properties of the camera are never changed, so you never have to worry about resetting them afterwards or anything.

Argument structure

All of the motions in this section use the same argument structure; the only difference is which camera value is being modified and how (the position along its local forward vector, or its FOV for example).

After the event name, the arguments are always:

Argument Default Description
Start Delta None (required) The offset from the camera's usual state at the start of the motion. Exactly what this is (distance, angle etc) depends on the modifier
End Delta None (required) The offset from the camera's usual state at the end of the motion
Duration None (required) The length of time that the motion should take
Easing Function `CubicInOut` Optional easing function. See Motion Easing Functions

Start and End Deltas

All of the motions here are expressed as deltas, at the start and end of the motion. Deltas are always measured from whatever is the camera's property before any modifiers. You can express them as positive or negative offsets, and there are start and end values so that you can begin and end the motion at whatever offset you want.

If you wanted to move away from the standard camera state, you'd use 0 for the starting delta, and non-zero for the end. Conversely if you want to move into the final state you'd use an non-zero delta for the start, and 0 for the end. Or you could move through the standard value by having a non-zero delta for both.

Push In / Pull Out

The CameraPushInOut event lets you move the camera along its local forward vector, either "pushing in" towards the subject (positive values) or "pulling out" away from the subject (negative values).

Here's an example:

[event CameraPushInOut 0, 100, 3, `CubicInOut`]

See Argument structure for details of the arguments; in this case the value being modified is the position, with the delta meaning distance along the camera's forward vector.

Zoom

The CameraZoom event changes the field of view of the camera so that it zooms in or out. In this example, the camera changes from its normal field of view, to one that's 15 degrees narrower over 3 seconds:

[event CameraZoom 0, -15, 3]

See Argument structure for details of the arguments; in this case the value being modified is the field of view in degrees.

Dolly

Dollying is a sideways camera motion, which you ask for with the CameraDolly event. Often it works well when combined with a fade to give a cinematic feeling effect.

Here's a slow Dolly into the final camera position:

[event CameraDolly -100, 0, 7, `CubicOut`]

See Argument structure for details of the arguments; in this case the value being modified is the position, with the delta meaning distance along the camera's right vector.

Boom

A Boom movement, invoked with the CameraBoom event, is named after the crane that usually does it in movies. It's a vertical movement of the camera, by default along the world Z.

Here's a boom moving the camera down into its final position:

[event CameraBoom 100, 0, 7, `CubicOut`]

See Argument structure for details of the argument; in this case the value being modified is the position, with the delta meaning distance along the global Z axis.

Boom motions are usually along the global Z, but if you want to move along the camera's local up vector, you can do that by using CameraBoomLocal instead of CameraBoom.

Pan

Pan is a rotation of the camera around the global Z axis, via the CameraPan event. Here's an example:

[event CameraPan -90, 0, 1, `ExpoInOut`]

This is a Whip Pan because it's a fast 90 degree pan (Wes Anderson uses these a lot).

See Argument structure for details of the arguments; in this case the value being modified is the rotation, with the delta meaning angle in degrees around the global Z axis.

It usually makes most sense to pan around the global Z axis, otherwise if the camera is tilted, you end up rolling the camera when you rotate. However, if you really want a local Z rotation, use the CameraPanLocal event instead.

Tilt

A Tilt is a rotation around the camera's local right hand axis, with the CameraTilt event. You might also think of it as a change in pitch, although Tilt is the cinematic term.

[event CameraTilt -80, 0, 5]

See Argument structure for details of the arguments; in this case the value being modified is the rotation, with the delta meaning angle in degrees around the camera's local right-hand axis.

Roll

With the CameraRoll event you can rotate the camera around its local forward axis:

# Do a barrel roll!
[event CameraRoll 0, 360, 3]

See Argument structure for details of the arguments; in this case the value being modified is the rotation, with the delta meaning angle in degrees around the camera's local forward axis.

Combining Motions

By default, all camera motions run in parallel, meaning the next line in the dialogue script executes immediately, unless you explicitly wait for it. This means you can combine camera motions into compound effects if you want.

Here's a classic example of the "Dolly-Zoom" effect (Jaws example on YouTube), combining a "Push In" and a "Zoom Out" at the same time (you can also do the reverse).

# Both of these run simultaneously
[event CameraPushInOut 0, 200, 3]
[event CameraZoom 0, 20, 3]

You can of course combine any of the others, such as a boom and dolly at the same time, etc.

Motion Easing functions

All of the camera motions have an optional easing function argument, which defaults to `CubicInOut`.

The easing functions are the same as the ones shown at Easings.net, and you refer to them in event arguments like this:

  • `Linear`
  • `SineIn` / `SineOut` / `SineOut`
  • `CubicIn` / `CubicOut` / `CubicInOut`
  • `QuadIn` / `QuadOut` / `QuadInOut`
  • `QuartIn` / `QuartOut` / `QuartInOut`
  • `QuintIn` / `QuintOut` / `QuintInOut`
  • `ExpoIn` / `ExpoOut` / `ExpoInOut`
  • `CircIn` / `CircOut` / `CircInOut`
  • `BackIn` / `BackOut` / `BackInOut`
  • `ElasticIn` / `ElasticOut` / `ElasticInOut`
  • `BounceIn` / `BounceOut` / `BounceInOut`