camera-controls

A camera control for three.js, similar to THREE.OrbitControls yet supports smooth transitions and more features.

documentation

Examples

• basic
• fit-and-padding
• fit-to-rect
• fit-to-bounding-sphere
• infinity dolly
• boundary
• focal offset
• click to set orbit point
• look in the point direction
• viewport within the canvas
• multiple camera-controls and viewport
• z-up camera
• orthographic
• event attach / detach
• user input config
• mouse drag with modifier keys
• combined gestures
• keyboard events
• rest and sleep events
• changing the cursor
• collision
• collision (custom)
• first-person
• third-person (with meshwalk)
• pointer lock
• auto rotate
• view offset translate
• camera shake effect
• rotate with time duration and easing (with gsap)
• path animation (with gsap)
• complex transitions with await
• set view padding
• outside of iframe dragging
• in react-three-fiber (simplest)
• in react-three-fiber (drei official) (see doc)

Usage

(The below code is for three.js users. If you use react-three-fiber (aka R3F), r3f-ready camera-controls is available on @react-three/drei

import * as THREE from 'three';
import CameraControls from 'camera-controls';

CameraControls.install( { THREE: THREE } );

// snip ( init three scene... )
const clock = new THREE.Clock();
const camera = new THREE.PerspectiveCamera( 60, width / height, 0.01, 1000 );
const cameraControls = new CameraControls( camera, renderer.domElement );

( function anim () {

	// snip
	const delta = clock.getDelta();
	const hasControlsUpdated = cameraControls.update( delta );

	requestAnimationFrame( anim );

	// you can skip this condition to render though
	if ( hasControlsUpdated ) {

		renderer.render( scene, camera );

	}

} )();

Important!

You must install three.js before using camera-controls. Not doing so will lead to runtime errors (undefined references to THREE).

Before creating a new CameraControls instance, call:

CameraControls.install( { THREE: THREE } );

You can then proceed to use CameraControls.

Note: If you do not wish to use the entire three.js to reduce file size(tree-shaking for example), make a subset to install.

import {
	Vector2,
	Vector3,
	Vector4,
	Quaternion,
	Matrix4,
	Spherical,
	Box3,
	Sphere,
	Raycaster,
} from 'three';

const subsetOfTHREE = {
	Vector2   : Vector2,
	Vector3   : Vector3,
	Vector4   : Vector4,
	Quaternion: Quaternion,
	Matrix4   : Matrix4,
	Spherical : Spherical,
	Box3      : Box3,
	Sphere    : Sphere,
	Raycaster : Raycaster,
};

CameraControls.install( { THREE: subsetOfTHREE } );

Constructor

CameraControls( camera, domElement )

• camera is a THREE.PerspectiveCamera or THREE.OrthographicCamera to be controlled.
• domElement is a HTMLElement for draggable area. (optional. if domElement is omitted here, can be connect later with .connect())

Terms

Orbit rotations

CameraControls uses Spherical Coordinates for orbit rotations.

If your camera is Y-up, the Azimuthal angle will be the angle for y-axis rotation and the Polar angle will be the angle for vertical position.

Dolly vs Zoom

• A Zoom involves changing the lens focal length. In three.js, zooming is actually changing the camera FOV, and the camera is stationary (doesn't move).
• A Dolly involves physically moving the camera to change the composition of the image in the frame.

See the demo

Properties

1. Every 360 degrees turn is added to .azimuthAngle value, which is accumulative.
   360º = 360 * THREE.MathUtils.DEG2RAD = Math.PI * 2, 720º = Math.PI * 4.
   Tip: How to normalize accumulated azimuthAngle?
2. Be aware colliderMeshes may decrease performance. The collision test uses 4 raycasters from the camera since the near plane has 4 corners.
3. If the Dolly distance is less (or over) than the minDistance (or maxDistance), infinityDolly will keep the distance and pushes the target position instead.

Events

CameraControls instance emits the following events.
To subscribe, use cameraControl.addEventListener( 'eventname', function ).
To unsubscribe, use cameraControl.removeEventListener( 'eventname', function ).

1. mouseButtons.wheel (Mouse wheel control) does not emit 'controlstart' and 'controlend'. mouseButtons.wheel uses scroll-event internally, and scroll-event happens intermittently. That means "start" and "end" cannot be detected.
2. Due to damping, sleep will usually fire a few seconds after the camera appears to have stopped moving. If you want to do something (e.g. enable UI, perform another transition) at the point when the camera has stopped, you probably want the rest event. This can be fine tuned using the .restThreshold parameter. See the Rest and Sleep Example.

User input config

Working example: user input config

1. Mouse wheel event for scroll "up/down" on mac "up/down/left/right"
2. Mouse click on wheel event "button"

• * is the default.
• The default of mouseButtons.wheel is:
  • DOLLY for Perspective camera.
  • ZOOM for Orthographic camera, and can't set DOLLY.

• * is the default.
• The default of touches.two and touches.three is:
  • TOUCH_DOLLY_TRUCK for Perspective camera.
  • TOUCH_ZOOM_TRUCK for Orthographic camera, and can't set TOUCH_DOLLY_TRUCK and TOUCH_DOLLY.

Methods

rotate( azimuthAngle, polarAngle, enableTransition )

Rotate azimuthal angle(horizontal) and polar angle(vertical). Every value is added to the current value.

If you want to rotate only one axis, put a angle for the axis to rotate, and 0 for another.

rotate( 20 * THREE.MathUtils.DEG2RAD, 0, true );

rotateAzimuthTo( azimuthAngle, enableTransition )

Rotate azimuthal angle(horizontal) to the given angle and keep the same polar angle(vertical) target.

rotatePolarTo( polarAngle, enableTransition )

Rotate polar angle(vertical) to the given angle and keep the same azimuthal angle(horizontal) target.

rotateTo( azimuthAngle, polarAngle, enableTransition )

Rotate azimuthal angle(horizontal) and polar angle(vertical) to the given angle. Camera view will rotate over the orbit pivot absolutely:

Azimuth angle

       0º
         \
 90º -----+----- -90º
           \
           180º

0º front, 90º (Math.PI / 2) left, -90º (- Math.PI / 2) right, 180º (Math.PI) back

Polar angle

     180º
      |
      90º
      |
      0º

180º (Math.PI) top/sky, 90º (Math.PI / 2) horizontal from view, 0º bottom/floor

dolly( distance, enableTransition )

Dolly in/out camera position.

dollyTo( distance, enableTransition )

Dolly in/out camera position to given distance.

dollyInFixed( distance, enableTransition )

Dolly in, but does not change the distance between the target and the camera, and moves the target position instead. Specify a negative value for dolly out.

zoom( zoomStep, enableTransition )

Zoom in/out camera. The value is added to camera zoom.
Limits set with .minZoom and .maxZoom

You can also make zoomIn function using camera.zoom property. e.g.

const zoomIn  = () => cameraControls.zoom(   camera.zoom / 2, true );
const zoomOut = () => cameraControls.zoom( - camera.zoom / 2, true );

zoomTo( zoom, enableTransition )

Zoom in/out camera to given scale. The value overwrites camera zoom.
Limits set with .minZoom and .maxZoom

truck( x, y, enableTransition )

Truck and pedestal camera using current azimuthal angle.

lookInDirectionOf( x, y, z, enableTransition )

Look in the given point direction.

setFocalOffset( x, y, z, enableTransition )

Set focal offset using the screen parallel coordinates. z doesn't affect in Orthographic as with Dolly.

setOrbitPoint( targetX, targetY, targetZ )

Set orbit point without moving the camera.

forward( distance, enableTransition )

Move forward / backward.

moveTo( x, y, z, enableTransition )

Move target position to given point.

elevate( height, enableTransition )

Move up / down.

fitToBox( box3OrMesh, enableTransition, { paddingTop, paddingLeft, paddingBottom, paddingRight } )

Fit the viewport to the box or the bounding box of the object, using the nearest axis. paddings are in unit. set cover: true to fill enter screen.

fitToSphere( sphereOrMesh, enableTransition )

Fit the viewport to the sphere or the bounding sphere of the object.

setLookAt( positionX, positionY, positionZ, targetX, targetY, targetZ, enableTransition )

Look at the target from the position.

lerpLookAt( positionAX, positionAY, positionAZ, targetAX, targetAY, targetAZ, positionBX, positionBY, positionBZ, targetBX, targetBY, targetBZ, t, enableTransition )

Similar to setLookAt, but it interpolates between two states.

setPosition( positionX, positionY, positionZ, enableTransition )

Set angle and distance by given position. An alias of 1setLookAt()1, without target change. Thus keep gazing at the current target

setTarget( targetX, targetY, targetZ, enableTransition )

Set the target position where gaze at. An alias of setLookAt(), without position change. Thus keep the same position.

setBoundary( box3? )

Set the boundary box that encloses the target of the camera. box3 is in THREE.Box3

setViewport( vector4? )

Set (or unset) the current viewport.
Set this when you want to use renderer viewport and .dollyToCursor feature at the same time.

See: THREE.WebGLRenderer.setViewport()

setViewport( x, y, width, height )

Same as setViewport( vector4 ), but you can give it four numbers that represents a viewport instead:

getTarget( out, receiveEndValue )

Returns the orbit center position, where the camera looking at.

getPosition( out, receiveEndValue )

Returns the camera position.

getSpherical( out, receiveEndValue )

Returns the spherical coordinates of the orbit.

getFocalOffset( out, receiveEndValue )

Returns the focal offset, which is how much the camera appears to be translated in screen parallel coordinates.

saveState()

Set current camera position as the default position

normalizeRotations()

Normalize camera azimuth angle rotation between 0 and 360 degrees.

reset( enableTransition )

Reset all rotation and position to default.

update( delta ): boolean

Update camera position and directions. This should be called in your tick loop and returns true if re-rendering is needed.

updateCameraUp()

When you change camera-up vector, run .updateCameraUp() to sync.

applyCameraUp()

Apply current camera-up direction to the camera.
The orbit system will be re-initialized with the current position.

connect()

Attach all internal event handlers to enable drag control.

disconnect()

Detach all internal event handlers to disable drag control.

dispose()

Dispose the cameraControls instance itself, remove all eventListeners.

addEventListener( type: string, listener: function )

Adds the specified event listener.

removeEventListener( type: string, listener: function )

Removes the specified event listener.

removeAllEventListeners( type: string )

Removes all listeners for the specified type.

toJSON()

Get all state in JSON string

fromJSON( json, enableTransition )

Reproduce the control state with JSON. enableTransition is where anim or not in a boolean.

Tips

Normalize accumulated azimuth angle:

If you need a normalized accumulated azimuth angle (between 0 and 360 deg), compute with THREE.MathUtils.euclideanModulo e.g.:

const TAU = Math.PI * 2;

function normalizeAngle( angle ) {

	return THREE.MathUtils.euclideanModulo( angle, TAU );

}

const normalizedAzimuthAngle = normalizeAngle( cameraControls.azimuthAngle );

Find the absolute angle to shortest azimuth rotatation:

You may rotate 380deg but actually, you expect to rotate -20deg.
To get the absolute angle, use the below:

const TAU = Math.PI * 2;

function absoluteAngle( targetAngle, sourceAngle ){

  const angle = targetAngle - sourceAngle
  return THREE.MathUtils.euclideanModulo( angle + Math.PI, TAU ) - Math.PI;

}

console.log( absoluteAngle( 380 * THREE.MathUtils.DEG2RAD, 0 ) * THREE.MathUtils.RAD2DEG ); // -20deg
console.log( absoluteAngle( -1000 * THREE.MathUtils.DEG2RAD, 0 ) * THREE.MathUtils.RAD2DEG ); // 80deg

Creating Complex Transitions

All methods that take the enableTransition parameter return a Promise can be used to create complex animations, for example:

async function complexTransition() {
	await cameraControls.rotateTo( Math.PI / 2, Math.PI / 4, true );
	await cameraControls.dollyTo( 3, true );
	await cameraControls.fitToSphere( mesh, true );
}

This will rotate the camera, then dolly, and finally fit to the bounding sphere of the mesh.

The speed and timing of transitions can be tuned using .restThreshold and .smoothTime.

If enableTransition is false, the promise will resolve immediately:

// will resolve immediately
await cameraControls.dollyTo( 3, false );

V2 Migration Guide

camera-controls used to use simple damping for its smooth transition. camera-controls v2 now uses SmoothDamp. one of the benefits of using SmoothDamp is, SmoothDamp transition can be controlled with smoothTime which is approximately the time it will take to reach the end position. Also, the Maximum speed of the transition can be set with max speed.

Due to the change, the following are needed. (if you haven't changed dampingFactor and draggingDampingFactor in v1.x, nothing is needed)

deprecated

• dampingFactor (use smoothTime instead)
• draggingDampingFactor (use draggingSmoothTime instead)

added

• smoothTime
• draggingSmoothTime
• maxSpeed

...That's it!

Contributors

This project exists thanks to all the people who contribute.

Release

Pre-requisites:

1. a npm registry up and running with a NPM_TOKEN

    $ export NPM_TOKEN=npm_XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

2. a Github PAT

     $ export GITHUB_TOKEN=github_pat_XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

$ npm run release -- --dry-run