How to move objects in Unity (3 methods with examples) (2024)

Moving an object in Unity can be very straightforward.

It typically involves modifying the properties of an object’s Transform component, which is used to manage a game object’s scale, rotation and position in the world.

However, there are many different ways that you can do that, such as by modifying the values directly, using built-in movement functions, or by using physics, which avoids using the transform component at all.

The exact method you use will depend entirely on the type of movement it is that you want to create.

In this article, you’ll learn how and when to use each of the different methods for moving an object in Unity, so that you can choose the one that’s right for your project.

Let’s get started.

How to move an object in Unity

The most straightforward method of changing an object’s position in Unity is to set it directly, which will instantly move it to a new vector 3 position in the world.

This works by setting the Position property of an object’s Transform component to a new position.

Like this:

// Moves an object to the set positiontransform.position = new Vector3(10, 0, 5);

Or you can add a vector to an object’s position, to move it by a set amount in a specific direction.

Like this:

// Moves an object up 2 unitstransform.position += new Vector3(0, 2, 0);

Which looks like this:

All this really does is change the object’s position in the game world using the transform component which, typically, all game objects have.

But, apart from when moving an object using physics, all movement in Unity involves modifying the object’s position value in some way, since movement is just a change in position that’s made frame by frame.

Meaning that you’ll normally always be working with the transform component to move an object.

As a result, you’re going to be working the transform component a lot. Luckily, it’s easy to get a reference to an object’s own transform, without having to set it up yourself.

This works by accessing the Transform Property for an object, which is the word transform, with a lowercase T.

Like this:

Transform myTransform = transform;

The Transform Property allows you to reference the transform component of an object from a script that’s attached to it, without needing to get a reference to it first.

Which is useful, as it means that any script can easily get, or change, an object’s position through the transform shortcut.

Like this:

Vector3 myPosition = transform.position;

Movement can then be created by changing the position of an object gradually, little by little every frame.

This works by adding a Vector 3 value, which is the distance and direction you want to move that frame, to the existing position of the object.

Like this:

void Update(){ // Moves the object forward one unit every frame. transform.position += new Vector3(0, 0, 1);}

By default, this moves the object forward in world space.

It’s also possible to move an object relative to its local position, by changing the Local Position value instead.

Like this:

void Update(){ // Moves the object forward one unit every frame realtive to its parent. transform.localPosition += new Vector3(0, 0, 1);}

But what is an object’s local position?

Local position vs world position

Local position refers to an object’s position and orientation relative to its parent.

Meaning that an object’s local position value is the offset between a child object and the parent it’s attached to.

By default, if both objects are in the same place, the local position will be (0, 0, 0) and the child will adopt the position of its parent.

Changing the local position changes the offset, and moves the object relative to its parent’s position plus whatever offset is applied, which can be useful for moving an object when it’s attached to something else.

But only if it’s attached to something else.

If the object doesn’t have a parent, its local position is the same as its world position.

This can sometimes be confusing, as it’s easy to assume that local position refers to the movement of an object relative to itself, where adding a forward vector would move it along its own Z-Axis.

Instead, in order to move an object relative to its own orientation, such as to move it in the direction it’s facing, you’ll either need to use a relative direction vector (more on those later) or the Translate function.

How to use Transform Translate in Unity

The Translate function in Unity moves an object by a set amount, relative to its current position and orientation.

Like this:

void Start(){ // Moves the object forward two units in the direction it's facing. transform.Translate(0,0,2);}

This is different to simply adding a vector to the object’s position, which would move it relative to world space, or its local position, which would move it relative to its parent if it has one.

Instead, Translate will, by default, move an object relative to its own local space.

This means that, when using Translate, passing in a forward vector will move the object in the direction of its blue Z-Axis.

When it’s called once, Translate moves an object by a set amount one time.

However, just like when changing an object’s position manually, it’s possible to create continuous movement by calling the function every frame.

Like this:

void Update(){ // Moves the object forward two units every frame. transform.Translate(0,0,2);}

However, there’s a problem with this method.

Framerates vary between devices and, because each frame often takes a different amount of time to process than the last one did, the speed of an object’s movement will change depending on the framerate.

This is because, right now, the object is always being moved two units every frame, even though every frame is different.

To avoid this, you’ll need to scale the object’s movement by Delta Time.

Delta Time explained

Delta time is a constantly updated value that measures how long the previous frame took to process.

Typically, when doing anything over time, such as movement, you’ll need to use delta time to scale the rate of change so that it’s consistent.

This works by multiplying the speed of the change, such as an object’s movement amount, by the delta time value.

Like this:

void Update() { // Moves the object forward at two units per second. transform.position = new Vector3(0,0,2) * Time.deltaTime; }

What this does is change the movement amount that’s applied from a units per frame value, to a units per second value.

• How to use Delta Time in Unity (and when not to)

This means that you can change the framerate, or it can dip up and down, as it’s likely to do, and the rate of movement will always be the same.

Which looks like this:

This works fine, however, it can sometimes be more convenient to manage movement direction and speed separately, by using a Unit Vector to determine the direction that an object will move, and a separate float value to control the speed.

Like this:

public float speed = 2;void Update(){ // Moves the object forward at two units per second. transform.Translate(Vector3.forward * speed * Time.deltaTime);}

This has the same effect as manually typing out the vector, except that the speed is now separate and can easily be changed.

In this example, Vector3.forward is shorthand for (0,0,1) which is the forward direction in world space.

Multiplying Vector3.forward by the speed value, in this case 2, creates the vector (0,0,2) which, when multiplied by Delta Time, creates a forward movement of two units per second.

The result is the same as when manually typing out the vector, except that the speed is now separate and can be controlled much more easily.

Vector3.forward // (0, 0, 1)Vector3.back // (0, 0, -1)Vector3.up // (0, 1, 0)Vector3.down // (0, -1, 0)Vector3.right // (1, 0, 0)Vector3.left // (-1, 0, 0)

transform.forward // object forward-transform.forward // object backtransform.up // object up-transform.up // object downtransform.right // object right-transform.right // object left

public float speed = 2;void Update(){ // Moves an object forward, relative to its own rotation. transform.position += transform.forward * speed * Time.deltaTime;}

Creating object-relative movement in this way can be useful for adding player controls, where the player can move an object forward, backwards or sideways using input axes, such as from the keyboard.

You’d usually use object-relative movement like this when allowing the player to control an object.

But how can you turn player input into object movement?

How to move an object with the keyboard in Unity

To move an object with the keyboard, or with any other input device, simply multiply the direction of movement you want to apply, such as forward, for example, by the Input Axis you want to use to control it.

In Unity, when using the default Input Manager, you’ll find an Input Axis for Horizontal and Vertical movement already set up and mapped to the WASD keys and arrow keys on the keyboard.

• Input in Unity made easy (a complete guide to the new system)

Each axis returns a value between -1 and 1, which means that you can use the value that’s returned to create a movement vector.

Like this:

public float speed = 2;void Update(){ float x = Input.GetAxis("Horizontal"); float z = Input.GetAxis("Vertical"); Vector3 movement = new Vector3(x, 0, z); transform.Translate(movement * speed * Time.deltaTime);}

This allows you to create object-relative movement controls using the keyboard or any other input device.

Which looks like this:

Vector3 movement = new Vector3(x, 0, z).normalized;

public float speed = 2;void Update(){ float x = Input.GetAxis("Horizontal"); float z = Input.GetAxis("Vertical"); Vector3 movement = new Vector3(x, 0, z); movement = Vector3.ClampMagnitude(movement, 1); transform.Translate(movement * speed * Time.deltaTime);}

The Translate function creates movement that’s relative to the Transform component that it’s called from.

However, you may not always want to create player-relative movement.

So how can you move an object in a direction that’s relative to a different object, such as the camera, for example?

How to move an object, relative to the camera

It’s possible to move an object relative to the position of the camera in Unity by using the camera’s forward vector in place of the object’s forward vector.

Like this:

public float speed = 2;void Update(){ Transform camTransform = Camera.main.transform; Vector3 forwardMovement = camTransform.forward * Input.GetAxis("Vertical"); Vector3 horizontalMovement = camTransform.right * Input.GetAxis("Horizontal"); Vector3 movement = Vector3.ClampMagnitude(forwardMovement + horizontalMovement,1); transform.Translate(movement * speed * Time.deltaTime, Space.World);}

Because the movement is relative to the camera’s position, the Relative To parameter in the Translate function needs to be set to World Space for this to work.

However, there’s a problem…

The forward vector of the camera may, in some cases, be facing at an angle, down towards the player, meaning that any movement that’s applied will also push downwards, instead of along a flat plane, as you might expect.

To fix this, you’ll need to manually calculate the direction between the camera and the object, while leaving out any rotation that you want to ignore.

To calculate a direction, all you need to do is subtract the position of the origin from the position of the target and then, normalise the result.

Like this:

Vector3 direction = (transform.position - Camera.main.transform.position).normalized;

To ignore the difference in height between the camera and the object it’s looking at, simply create a new Vector 3 that replaces the camera’s height with the object’s instead.

Like this:

Transform camTransform = Camera.main.transform;Vector3 camPosition = new Vector3( camTransform.position.x, transform.position.y, camTransform.position.z);Vector3 direction = (transform.position - camPosition).normalized;

This will return a direction that is looking towards the object, but isn’t looking up or down.

You can then use the corrected direction that’s created to calculate movement that’s relative to the camera on a flat plane.

Like this:

public float speed = 2;void Update(){ Transform camTransform = Camera.main.transform; Vector3 camPosition = new Vector3(camTransform.position.x, transform.position.y, camTransform.position.z); Vector3 direction = (transform.position - camPosition).normalized; Vector3 forwardMovement = direction * Input.GetAxis("Vertical"); Vector3 horizontalMovement = camTransform.right * Input.GetAxis("Horizontal"); Vector3 movement = Vector3.ClampMagnitude(forwardMovement + horizontalMovement, 1); transform.Translate(movement * speed * Time.deltaTime, Space.World);}

Which looks like this:

By understanding the relative direction of an object, it’s possible to create any kind of movement control that you want.

However, a lot of the time, you may want to move an object in a different way, that’s not directly controlled by the player.

For example, moving an object to a set position or towards another object.

How to move an object to a position in Unity

Generally speaking, there are two different ways to move an object into a specific position.

1. By Speed, where the object moves towards a target at a specific speed,
2. By Time, where the movement between the two points takes a specific amount of time to complete.

The method you use to move the object will depend on how you want to control its movement, by time or by speed.

So how does it work?

How to move an object to a position at a set speed (using Move Towards)

It’s possible to move an object towards another object or a specific position in the scene using the Move Towards function.

Move Towards is a function of the Vector 3 Class that will modify a Vector 3 value to move towards a target at a set speed without overshooting.

Which works great for moving an object towards a position in the world at a speed you can control.

Like this:

public Vector3 targetPosition;public float speed=10;void Update(){ transform.position = Vector3.MoveTowards(transform.position, targetPosition, speed * Time.deltaTime);}

The movement can also be smoothed, by using the Smooth Damp function, which eases the movement as it starts and ends.

Like this:

public Vector3 targetPosition;public float smoothTime = 0.5f; public float speed = 10;Vector3 velocity;void Update(){ transform.position = Vector3.SmoothDamp(transform.position, targetPosition, ref velocity, smoothTime, speed);}

This works by setting the position of the object to the Vector 3 result of the Smooth Damp function, passing in a target, the current position and a reference Vector 3 value, which the function uses to process the velocity of the object between frames.

This can be useful for smoothed continuous movement, where the target position may change from one moment to the next such as when following the player with a camera.

Such as in this example of a smooth camera follow script using Smooth Damp:

public Transform player;public float cameraDistance = 5;public float cameraHeight = 3;public float smoothTime = 0.5f;public float speed = 10;Vector3 velocity;void Update(){ transform.LookAt(player.transform); Vector3 offset = (Camera.main.transform.position - player.position).normalized * cameraDistance; Vector3 targetPosition = player.position + offset; targetPosition.y = cameraHeight; transform.position = Vector3.SmoothDamp(transform.position, targetPosition, ref velocity, smoothTime, speed);}

In this example, the camera will smoothly move towards the player and turn to face them, while keeping at a height of 3 units and trying to stay at a distance of 5 units away.

• How to make a Follow Camera in Unity

Move Towards works great as a way to move an object towards a position dynamically.

This is because the movement is speed-based, and can be easily controlled even if the target position moves while the object is moving towards it.

However, there may be times when you want to control the movement of an object using time, not speed.

Such as when moving a platform, or opening a door.

So how can you create time based movement in Unity?

How to move an object to a position in a set amount of time (using Lerp)

Lerp, or Linear Interpolation, is used to find a value between a minimum and maximum based on a position value, ‘t’, which is a float between zero and one.

The value that’s returned depends on the value of t where, if t is 0 the minimum value is returned, while 1 returns the maximum value.

Any other value in between 0 and 1 will return a representative value between the minimum and maximum ends of the scale.

float lerpedValue = Mathf.Lerp(float minValue, float maxValue, float t);

Lerp is, actually, very simple, and all it really does is return a weighted value between two others.

• The right way to use Lerp in Unity (with examples)

However, in practice, Lerp is often used to change a value over a known period of time, by incrementing t every frame to return a new value on the scale that’s closer to a target.

This can be used to change a colour, fade an audio source or move an object between two points.

It works by passing in the amount of time that has elapsed during the Lerp, divided by the total duration. This returns a 0-1 float that can be used for the t value, and allows you to control the length of the Lerp movement by simply choosing how long you’d like it to take.

Like this:

float timeElapsed;float lerpDuration = 3;float lerpedValue;void Update(){ if (timeElapsed < lerpDuration) { lerpedValue = Mathf.Lerp(0, 100, timeElapsed / lerpDuration); timeElapsed += Time.deltaTime; }}

Vector3.Lerp works in the same way except that, instead of returning a float, it returns a point in the world between two others, based on the t value.

This can be useful for moving an object between two different positions, such as a door with an open and closed state.

Like this:

public float openHeight = 4.5f;public float duration = 1;bool doorOpen;Vector3 closePosition;void Start(){ // Sets the first position of the door as it's closed position. closePosition = transform.position;}void OperateDoor(){ StopAllCoroutines(); if (!doorOpen) { Vector3 openPosition = closePosition + Vector3.up * openHeight; StartCoroutine(MoveDoor(openPosition)); } else { StartCoroutine(MoveDoor(closePosition)); } doorOpen = !doorOpen;}IEnumerator MoveDoor(Vector3 targetPosition){ float timeElapsed = 0; Vector3 startPosition = transform.position; while (timeElapsed < duration) { transform.position = Vector3.Lerp(startPosition, targetPosition, timeElapsed / duration); timeElapsed += Time.deltaTime; yield return null; } transform.position = targetPosition;}

In this example, I’ve used a coroutine to move the door object up by a set distance from the door’s starting position, whenever the Operate Door function is called.

Which looks like this:

This creates a linear movement from one position to another, however, it’s also possible to smooth the Lerp’s movement using the Smooth Step function.

This works by modifying the t value with the Smooth Step function before passing it into Lerp.

Like this:

float t = Mathf.SmoothStep(0, 1, timeElapsed / moveDuration);

This will ease the movement of the object at the beginning and end of the Lerp.

These methods work well for creating controlled precise movements in Unity.

But, what if you don’t want to control an object’s movement precisely?

What if you’d rather push, pull or throw an object, to create movement using physical forces instead?

How to move an object using physics

Most rendered objects in Unity have a Collider component attached to them, which gives them a physical presence in the world.

However, an object with just a collider is considered, by Unity, to be Static, meaning that it’s not supposed to move.

To move an object under physics simulation, you’ll also need to add a Rigidbody component to it, which allows it to move, and be moved, by physical forces, such as gravity.

You can also move a physics object by applying force to its Rigidbody using the Add Force function.

Like this:

Rigidbody.AddForce(Vector3 force);

This works in a similar way to the Translate function except that the vector you pass in is a physical force, not a movement amount.

How much the object moves as a result will depend on physical properties such as mass, drag and gravity.

There are two main ways to apply physical force on an object.

You can either apply force continuously, building momentum and speed over time, or all at once in an impulse, like hitting an object to move it.

By default, the Add Force function applies a continuous force, like a thruster gradually lifting a rocket.

Like this:

public Rigidbody rb;public float forceAmount = 10;void FixedUpdate(){ rb.AddForce(Vector3.up * forceAmount);}

Notice that I’ve used Fixed Update, and not Update, to apply the force to the object.

This is because Fixed Update is called in sync with the physics system, which runs at a different frequency to Update, which is often faster and can vary from frame to frame.

Doing it this way means that the application of force is in sync with the physics system that it affects.

Alternatively, you can also apply force in a single burst, using the Impulse Force Mode.

Like this:

public Rigidbody rb;public float forceAmount = 10;void Start(){ rb.AddForce(Vector3.up * forceAmount, ForceMode.Impulse);}

This will apply an amount of force to an object all at once:

Which can be useful for faster, more explosive movements, such as making an object jump.

• How to jump in Unity (with or without physics)

How to move a Rigidbody (without using force)

Normally, when you’re moving an object using physics, you might typically apply force to move it around in a realistic way.

But, what if you want to use the physics system but you want to move the object directly, in the same way as moving it using its transform component?

It’s possible to do this by using the Move Position function, which is a rigidbody method that will move an object to a precise position in a similar way to setting its transform position.

Like this:

public class MovePositionExample : MonoBehaviour{ public Rigidbody rb; public float speed = 1; Vector3 moveAxis; void Update() { moveAxis = new Vector3(Input.GetAxis("Horizontal"), 0, Input.GetAxis("Vertical")); moveAxis = Vector3.ClampMagnitude(moveAxis, 1); } private void FixedUpdate() { rb.MovePosition(rb.position + (moveAxis * speed * Time.fixedDeltaTime)); }}

This is slightly different to setting the rigidbody’s position value directly, which effectively teleports an object to a new position using its rigidbody.

The Move Position function, however, while it basically does the same thing, is assumed to be moving the object from one position to the next.

What this means is that, if you’ve enabled interpolation on the rigidbody, its visual position will still be smoothed between the, typically slower, fixed update calls, even though the object is being moved manually and not with forces.

As a result, if you want to change the position of a physics object immediately, to teleport it somewhere else, set its Rigidbody Position value, but if you want to move it, gradually, use the Move Position function instead.