How To Make Your Player Rotate With The Camera In Unity

13 minutes

In this tutorial, you lot're going to build a configurable camera that handles moving, zooming and rotating. This design works bang-up for games that do non want an attached 3rd or 1st person camera, but instead want liberty to motion around a scene. Instead of using the old input system, we'll exist hooking it up to the new 1 and will review primal concepts every bit we go.

Configuration features of the camera are:

1. Camera angle
2. Zoom min/max
3. Zoom default
4. Look offset (where you want the camera to focus on the y axis)
5. Rotation speed

Learning Outcomes

1. Sympathise key concepts of the new Input Organisation.
2. Have a configurable camera that can be customized for your game.

Prerequisites

This tutorial was created with Unity version 2019.2.

This tutorial assumes you accept basic knowledge of how Unity works. It does not cover the basics, such as what a GameObject is, a component, when Offset is called, etc.

Tutorials in this Series

1. Part ane: How to make a configurable camera with the new Input System
2. Part ii: Listen for the Input Arrangement Action events via CSharp
3. Part 3: How to select multiple objects based on the center of a collider
4. Part iv: Challenge Solution: Extending the choice logic

Resources

1. Input System documentation and GitHub repository.
2. Introducing the new Input Arrangement – Unite Copenhagen Video
3. This projection uses the Low Poly: Complimentary Pack by AxeyWorks.

Installing the Input Arrangement

Unity has been overhauling the Input Arrangement to be more than robust and to work better for multiple platforms and device configurations. It can also exist easily configured to process input for multiple local players (though we will not be doing that in this tutorial).

The new Input Arrangement is still actively being developed and is considered in preview.

The Input System can be installed via Package Manager or from the GitHub repository. We'll do Package Manager:

1. Get toWindow >Package Managing director.
2. Enable preview packages by going toAvant-garde >Show Preview Packages
3. In the search dialog, type "Input Organization" to search for the package
4. Select theInput System packet and clickInstall

Certain aspects of Unity, such as the Universal Return Pipeline, require the old input system to function. For at present, it'southward best to brand sure that theActive Input Handling property in yourProject Settings is set toBoth. This ways that you lot can use both input systems within your game, but for the sake of this tutorial we will but use the new one.

You can confirm this is gear up correctly past going to:

1. Edit >Project Settings >Player >Configuration

Setting up the Input Organisation

The new Input Organisation is a lot more complicated than the original one. This makes it harder to learn at first, just for a good crusade – information technology is far more robust and when setup correctly, will take less piece of work to use.

To get started, create anInput Controls asset by right clicking in yourProjection Hierarchy and become to:

1. Create >Input Actions
2. Name the new filePlayerInputMapping
3. Double click the file to open the editor window for information technology

There are four new terms that are important to know when configuring the input:

1. Control Scheme: A style to specify device requirements that must exist met for an input binding to be usable. This is optional and can be left alone (nada requirements).
2. Activeness Maps: A collection of deportment that can be enabled/disabled in bulk
3. Action: A collection of input bindings that can be grouped nether a specific activity, such as "Burn" or "Motility".
4. Input Bindings: Specific device input(s) to monitor for, such every bit a trigger on a gamepad, a mouse push or key on the keyboard.

A very common example of an Activity to a multiple Input Binding mapping is having a "Burn down" activeness, which might exist bound to a trigger for a gamepad and the right mouse button for keyboard/mouse setup.

Action Maps, Actions and Input Bindings each have their own set of properties. Nosotros'll look at these more throughout the tutorial.

Defining our controls

The input scheme is going to exist designed for a keyboard / mouse device but could exist easily extended to other inputs also, if needed. In total, we'll have one control scheme and activeness map, four actions and five input bindings. The setup will look like this:

While this may await similar a lot, creating the layout is uncomplicated. With thePlayerInputMapping asset open, create a new Activity Map:

1. Click the+ sign next toActivity Maps and proper noun itPlayer. This will automatically create an empty Action and Input Binding node.
2. Rename theAction node toCamera_Move. Fix the post-obit Properties:
   1. Action Type: Value
   2. Command Blazon: Vector 2.

You will want to use a2D Vector Composite binding node instead of the default one that was created. This tells the Input Arrangement to send a 2nd Vector each time the W, South, A, or D keys are pushed.

Don't worry if this doesn't make sense right now. You'll walk through the values that are being sent as you hook upward the Actions to the photographic camera.

1. Delete the emptyBinding node by right clicking on it and selectingDelete.
2. Right click on theCamera_Move Activeness and selectAdd 2D Vector Composite. Name itWASD.
3. Select the node labeled Up: and set the Path to W [Keyboard].
4. Repeat this for the remaining nodes (Down, Left, Right), setting them to their corresponding keys.

Exercise the same matter for the Arrow keys. Add anothersecond Vector Blended and name information technologyArrows. Set each mapping to their respective arrow key. Your map should at present look like:

Now we but demand to setup the remaining actions and bindings:

1. Add a newActiveness and name itCamera_Rotate.
2. Set up theAction Blazon toValue andControl Blazon toVector ii.
3. Click on theBinding node and prepare thePath toDelta (Mouse).

Side by side, nosotros'll setup theCamera_Rotate_Toggle action and bounden:

1. Add a newActivity and name itCamera_Rotate_Toggle.
2. Leave theAction Type asButton.
3. Click on theBinding node and ready thePath toRight Button [Mouse].

Lastly, we'll setup the Camera_Zoom activeness and binding:

1. Add together a newAction and name information technologyCamera_Zoom.
2. Fix theAction Type toValue andCommand Type toVector ii.
3. Click on theBinding node and set thePath toGyre [Mouse].

ClickSave Asset to salvage your changes. Your map should look like this:

Setting up and moving the camera

There will be two game objects that will be manipulated – aCamera Rig and thePrimary Camera:

1. Within your scene, create an empty game object and name information technologyCameraRig
2. Make theMaster Camera a kid of theCamera Rig
3. Create a new script calledCameraController and add it to the CameraRig game object

The purpose of the Photographic camera Rig is to handle moving and rotating effectually the scene. Having information technology as a separate game object will let us move on the forward/right axis without having to worry about the forwards management the bodily camera is pointing. The Main Camera will be configured on startup with the custom properties to ensure information technology's focusing on the right indicate in world infinite. It will as well handle zooming.

Since the camera will be configurable, we'll first define the variables that can be set in the inspector:

public class CameraController : MonoBehaviour {     [Header("Configurable Backdrop")]     [Tooltip("This is the Y offset of our focal indicate. 0 Ways we're looking at the ground.")]     public float LookOffset;     [Tooltip("The bending that we want the camera to be at.")]     public bladder CameraAngle;     [Tooltip("The default corporeality the player is zoomed into the game world.")]     public bladder DefaultZoom;     [Tooltip("The almost a player tin can zoom in to the game world.")]     public bladder ZoomMax;     [Tooltip("The furthest indicate a player can zoom back from the game world.")]     public float ZoomMin;     [Tooltip("How fast the camera rotates")]     public float RotationSpeed; }

This tutorial will exist setup with a 45-caste camera that is looking 1 meter above the basis. It'll also restrict zooming to be inside 2 – 10 meters. Hither is the full fix of properties to set within the inspector:

Next, configure the camera'southward starting point based on the properties set. Add the following global variables to your script forth with theKickoff() method:

//Camera specific variables individual Photographic camera _actualCamera; private Vector3 _cameraPositionTarget;  void Offset() {     //Shop a reference to the camera rig     _actualCamera = GetComponentInChildren<Camera>();      //Gear up the rotation of the camera based on the CameraAngle property     _actualCamera.transform.rotation = Quaternion.AngleAxis(CameraAngle, Vector3.right);       //Ready the position of the camera based on the await start, angle and default zoom properties.      //This will brand sure we're focusing on the right focal bespeak.     _cameraPositionTarget = (Vector3.upwards * LookOffset) + (Quaternion.AngleAxis(CameraAngle,          Vector3.correct) * Vector3.back) * DefaultZoom;     _actualCamera.transform.position = _cameraPositionTarget; }

It is better to shop reference to the main camera game object instead of callingCamera.main. CallingCamera.principal directly can have a operation bear upon as Unity is non actually storing a reference to the principal photographic camera. Instead, each call traverses your scene hierarchy and components.

Calculation movement beliefs

Calculation motility to your camera will need a few global variables, a call inLateUpdate() and a newOnMove() method:

//Movement variables private const bladder InternalMoveTargetSpeed = 8; private const float InternalMoveSpeed = 4; private Vector3 _moveTarget; private Vector3 _moveDirection;  /// <summary> /// Sets the management of movement based on the input provided past the histrion /// </summary> public void OnMove(InputAction.CallbackContext context) {     //Read the input value that is being sent by the Input System     Vector2 value = context.ReadValue<Vector2>();      //Store the value as a Vector3, making sure to motion the Y input on the Z axis.     _moveDirection = new Vector3(value.x, 0, value.y);      //Increment the new move Target position of the camera     _moveTarget += (transform.forward * _moveDirection.z + transform.right *          _moveDirection.x) * Time.fixedDeltaTime * InternalMoveTargetSpeed; }  private void LateUpdate() {     //Lerp  the photographic camera to a new movement target position     transform.position = Vector3.Lerp(transform.position, _moveTarget, Time.deltaTime * InternalMoveSpeed); }

OnMove(), stores the player input value by callingcontext.ReadValue<Vector2>(). Since we are using the Vector 2 composite binding, we will see the following x & y values depending on which input was pushed:

1. Up: 0, i
2. Down: 0, -1
3. Right: i, 0
4. Left: -1, 0

Hooking the Input Organization to code

At present that at that place'south some initial code, it'southward time to exercise a test run to see how information technology's behaving. To do this, you'll need to tell the Input Organisation where to route the actions.

This can be done by calculation the Player Input component to a game object in the scene:

1. Create a new game object and telephone call itGameManager. game object
2. ClickAdd togetherComponent and search for thePlayer Input component
3. Set up the post-obit properties:
   1. Actions: PlayerInputMapping asset that nosotros just configured
   2. Default Map: Player
   3. Behavior: Invoke Unity Events
4. Expand theEvents andActor nodes
5. Under theCamera_Move effect, reference theCameraRig game object and prepare the consequence toCameraController.OnMove()

That'south information technology! Push play on your game and motility the photographic camera around.

While nosotros will use the "Invoke Unity Events" notification behavior, it is of import to sympathise the different options and how they deport:

1. Transport Messages: This volition send input messages to all scripts located on this game object only.
2. Broadcast Letters: In add-on to sending input messages to components on the aforementioned game object, information technology will also send them down the child hierarchy.
3. Invoke Unity Events: Invokes a UnityEvent for each type of message. The UI can exist used to setup callback methods.
4. Invoke C Sharp Events: Like Invoke Unity Events, just instead are C# events that must exist registered via callbacks in your scripts.

You can read more than on the different event types likewise as how to set them upwardly hither.

Fixing the photographic camera movement

Well, that's not quite "it" – This is not the behavior that we desire. The role player should be able to hold down a key and see the camera move constantly in that management. The reason this happens because the Input Organisation is only sending an event when the key is pressed. It does not have an easy manner to monitor for a key being pressed. We'll need to handle this ourselves.

Input Bindings have the concept of Interactions, one of which is chosen "Concur". The purpose of this interaction is to trigger the action later a catamenia of time has gone past. It does not trigger the activeness continuously while the button is held downward.

You lot can read more than on interactions here.

Fortunately, fixing this is easy! We'll just demand to move the last line fromOnMove() intoFixedUpdate(). Your methods should now wait similar this:

public void OnMove(InputAction.CallbackContext context) {     //Read the input value that is beingness sent by the Input System     Vector2 value = context.ReadValue<Vector2>();      //Store the value as a Vector3, making sure to move the Y input on the Z axis.     _moveDirection = new Vector3(value.x, 0, value.y); }  individual void FixedUpdate() {     //Sets the move target position based on the move direction. Must be done hither      //as there'south no logic for the input organization to calculate holding down an input     _moveTarget += (transform.forwards * _moveDirection.z + transform.right *          _moveDirection.10) * Time.fixedDeltaTime * InternalMoveTargetSpeed; }

Press play! Our camera movement is now very smooth and handles direction changes beautifully:

Adding zoom behavior

Adding the power to zoom volition crave a small refactor to go on things clean. This is because the camera will need the ability to recompute its new Y/Z values depending on the electric current zoom value.

To get-go, Add together the following global variables and newUpdateCameraTarget() method:

//Zoom variables private float _currentZoomAmount; public float CurrentZoom {     get => _currentZoomAmount;     individual set     {         _currentZoomAmount = value;         UpdateCameraTarget();     } }  private bladder _internalZoomSpeed = 4;  /// <summary> /// Calculates a new position based on various properties /// </summary> private void UpdateCameraTarget() {     _cameraPositionTarget = (Vector3.upward * LookOffset) +          (Quaternion.AngleAxis(CameraAngle, Vector3.correct) * Vector3.dorsum) * _currentZoomAmount; }

Start() tin now be updated to setCurrentZoom to theDefaultZoom value, rather than making the calculation itself, like then:

void Showtime() {     //Store a reference to the camera rig     _actualCamera = GetComponentInChildren<Camera>();      //Ready the rotation of the photographic camera based on the CameraAngle holding     _actualCamera.transform.rotation = Quaternion.AngleAxis(CameraAngle, Vector3.correct);      //Set the position of the camera based on the look offset, angle and default zoom backdrop.      //This volition make sure we're focusing on the correct focal bespeak.     CurrentZoom = DefaultZoom;     _actualCamera.transform.position = _cameraPositionTarget; }

Side by side, add together a newOnZoom() method and update theLateUpdate() method to move the _actualCamera's local position based on the new zoom factor:

/// <summary> /// Sets the logic for zooming in and out of the level. Clamped to a min and max value. /// </summary> /// <param name="context"></param> public void OnZoom(InputAction.CallbackContext context) {     if (context.stage != InputActionPhase.Performed)     {         return;     }      // Conform the electric current zoom value based on the direction of the curlicue - this is clamped to our zoom min/max.      CurrentZoom = Mathf.Clamp(_currentZoomAmount - context.ReadValue<Vector2>().y, ZoomMax, ZoomMin); }  private void LateUpdate() {     //Lerp  the photographic camera to a new move target position     transform.position = Vector3.Lerp(transform.position, _moveTarget, Time.deltaTime * InternalMoveSpeed);      //Move the _actualCamera's local position based on the new zoom factor     _actualCamera.transform.localPosition = Vector3.Lerp(_actualCamera.transform.localPosition,          _cameraPositionTarget, Time.deltaTime * _internalZoomSpeed); }        

Multiple instances of an effect are sent with different phases, depending on the input stage. In the case ofOnZoom(), we merely want to procedure reading the value if we're in the Performed phase equally this ensures we aren't getting values that can mess upwardly our logic. Without this check, we would procedure two more calls for the Started and Canceled phases.

You can read more than about Input Action Phases here.

It'southward at present time to test! Hook up the logic to the Input System the aforementioned style as the Move event:

1. Under theCamera_Zoom outcome, reference theCameraController game object and ready the effect toCameraController.OnZoom.
2. Press play and scroll.

Notice that the zoom is jumping to the min/max zoom value that is set, rather than gracefully incrementing. This is because the input value that is existence sent when we scroll is quite big – each whorl yields a vector 2 that is either 0, 120 or 0, -120.

To increase slowly, our logic needs this normalized to 0, 1 or 0, -one. To set this:

1. Open thePlayerInputMapping asset and select theCoil [Mouse] bounden under theCamera_Zoom action.
2. On the belongings pane, click the+ button under theprocessors section and pickNormalize Vector 2.
3. Save the file.

There are several helpful processors that can be applied to the deportment, controls and bindings, including specifying dead zone values for gamepad inputs.

You can read more on the unlike upshot types likewise as how to ready them upwards hither.

That'southward it! Now yous should run into polish scrolling behavior:

Adding rotation beliefs

Rotating the photographic camera is a two-step process. Beginning, you'll need to know whether the player is telling you lot to rotate. This will be done by monitoring whether the Right Mouse push button is pushed. If it is then we'll process the mouse position to tell our game which way to rotate.

Monitoring for a push button push is very simple. You but need to read if a float value is 0 (off) or 1 (on). To practice this, add the following global variables andOnRotateToggle() method to your project:

//Rotation variables private bool _rightMouseDown = false; private const float InternalRotationSpeed = 4; private Quaternion _rotationTarget; private Vector2 _mouseDelta;  /// <summary> /// Sets whether the player has the right mouse button down /// </summary> /// <param proper noun="context"></param> public void OnRotateToggle(InputAction.CallbackContext context) {     _rightMouseDown = context.ReadValue<float>() == 1; }

Add together a newOnRotate() method to your project to rotate the camera if the right mouse button is pushed:

/// <summary> /// Sets the rotation target quaternion if the right mouse button is pushed when the player is  /// moving the mouse /// </summary> /// <param name="context"></param> public void OnRotate(InputAction.CallbackContext context) {     // If the right mouse is downwardly then we'll read the mouse delta value. If it is not, we'll clear information technology out.     // Note: Clearing the mouse delta prevents a 'death spin'      //from occurring if the player flings the mouse actually fast in a direction.     _mouseDelta = _rightMouseDown ? context.ReadValue<Vector2>() : Vector2.zero;      _rotationTarget *= Quaternion.AngleAxis(_mouseDelta.10 * Fourth dimension.deltaTime * RotationSpeed, Vector3.up); }

Lastly, add logic toLateUpdate() andStart() to tell it to rotate the camera:

void Beginning() {     //Store a reference to the camera rig     _actualCamera = GetComponentInChildren<Camera>();      //Fix the rotation of the photographic camera based on the CameraAngle holding     _actualCamera.transform.rotation = Quaternion.AngleAxis(CameraAngle, Vector3.correct);      //Set up the position of the camera based on the look start, angle and default zoom backdrop.      //This will make certain we're focusing on the right focal bespeak.     CurrentZoom = DefaultZoom;     _actualCamera.transform.position = _cameraPositionTarget;      //Set the initial rotation value     _rotationTarget = transform.rotation; }  private void LateUpdate() {     //Lerp the camera rig to a new motility target position     transform.position = Vector3.Lerp(transform.position, _moveTarget, Fourth dimension.deltaTime * InternalMoveSpeed);      //Move the _actualCamera'southward local position based on the new zoom factor     _actualCamera.transform.localPosition = Vector3.Lerp(_actualCamera.transform.localPosition,           _cameraPositionTarget, Fourth dimension.deltaTime * _internalZoomSpeed);      //Slerp the camera rig'southward rotation based on the new target     transform.rotation = Quaternion.Slerp(transform.rotation, _rotationTarget, Time.deltaTime * InternalRotationSpeed); }

Claw upwardly the logic to the Input Arrangement for the new methods:

1. Nether theCamera_Rotate event, reference theCameraController game object and set the outcome toCameraController.OnRotate.
2. Under theCamera_Rotate_Toggle event, reference theCameraController game object and set the upshot toCameraController.OnRotateToggle.
3. Press play and hold down the right mouse button while you motility the mouse effectually.

While this appears to be working correctly, nosotros're making as well many unnecessary calls for updating the rotation. To understand this more, permit's accept a expect as to how many times theOnRotate() input event gets called in a single frame. Nosotros'll add together some temporary code to illustrate this:

// Create a new global variable individual float _eventCounter;  // Add together the following to the terminate of OnRotate // This volition increment the eventCounter once per event call eventCounter += _rightMouseDown ? i : 0;  // Add the post-obit to the finish of LateUpdate // As late update runs once per frame, this volition log the full number of times the event was called per frame and and then clears out the issue for the next check Debug.Log(eventCounter); eventCounter = 0;

When we run this code and rotate the photographic camera, we tin can see that theOnRotate() event is triggered many times per frame:

Additionally, the mouse delta sent with each upshot trigger in a single frame is accumulating in value. To account for this, information technology's considered best practice to apply the terminal delta once per frame.

To prepare this, movement_rotationTarget *= Quaternion.AngleAxis(_mouseDelta.ten * Time.deltaTime * RotationSpeed, Vector3.upwardly); fromOnRotate() and put information technology inLateUpdate():

private void LateUpdate() {     //Lerp the camera rig to a new motility target position     transform.position = Vector3.Lerp(transform.position, _moveTarget, Time.deltaTime * InternalMoveSpeed);      //Move the _actualCamera's local position based on the new zoom gene     _actualCamera.transform.localPosition = Vector3.Lerp(_actualCamera.transform.localPosition,          _cameraPositionTarget, Fourth dimension.deltaTime * _internalZoomSpeed);      //Ready the target rotation based on the mouse delta position and our rotation speed     _rotationTarget *= Quaternion.AngleAxis(_mouseDelta.x * Fourth dimension.deltaTime * RotationSpeed, Vector3.up);      //Slerp the photographic camera rig's rotation based on the new target     transform.rotation = Quaternion.Slerp(transform.rotation, _rotationTarget, Time.deltaTime * InternalRotationSpeed); }

That'southward it! You should now take a fully functional camera that rotates, zooms and pans around the scene with the new Input System.

Y'all can adapt theRotationSpeed variable in the inspector to increment the speed, if needed.

Source: https://gamedev-resources.com/make-a-configurable-camera-with-the-new-unity-input-system/

Posted by: jaramilloicia1942.blogspot.com

Share this post