DEV Community: Giorgi Eliozashvili

Unity ScriptableObject

Giorgi Eliozashvili — Sun, 19 Jul 2026 09:47:25 +0000

When you first make a weapon in a shooter game, you usually give it the standard MonoBehaviour script and write everything there: damage, fire rate, ammo, shooting logic, etc. But when you start adding new weapons, lots of data duplication appears. Every prefab holds a copy of the same data. To solve this, Unity has a feature called ScriptableObjects.

According to Unity documentation, this is the official use case of ScriptableObjects:

Saving and storing data during an Editor session
Saving data as an asset in your project to use at runtime

ScriptableObject is an independent container for saving data. Its main difference from the usual MonoBehaviour is that it does not need to be attached to a GameObject in the scene.

Let’s see the example of my basic weapon ScriptableObject:

using UnityEngine;

[CreateAssetMenu(fileName = "WeaponSO", menuName = "Scriptable Objects/WeaponsSO")]
public class WeaponSO : ScriptableObject
{
    public Weapon WeaponPrefab;
    public ParticleSystem HitVFX;

    public int Damage;
    public float FireRate;
    public bool IsAutomatic;
    public bool CanZoom;
    public float ZoomAmount;
    public float ZoomRotationSpeed;
}

ScriptableObject-s are inheriting from ScriptableObject instead of MonoBehaviour.

Let’s break this example down:

[CreateAssetMenu] allows us to create a ScriptableObject file in our project's folder.
Inside the class, there are no Start() nor Update() methods. Just pure data that you can manipulate through Unity Inspector. And this is how it looks in Inspector:

So you can have separate weapon ScriptableObjects in your project and manipulate them more clearly and easily.

In summary, ScriptableObject is a perfect tool for data management, separating data (ScriptableObject) and logic (MonoBehaviour), making your project cleaner and easily manageable.

Simple Unity NavMesh

Giorgi Eliozashvili — Sun, 19 Jul 2026 09:43:42 +0000

Let’s build a simple AI follower using Unity’s built-in component NavMesh.

We will use NavMesh Agent and NavMesh Surface for this simple example.

NavMesh Surface — is a component that scans the surface and “bakes” it in a way that our Agent can walk on it.

NavMesh Agent — is a component that you give to your “follower” (any kind of follower, can be an enemy or just a cute minion that follows you around). It knows its height and radius and can go around obstacles.

With our Agent and Surface, we need to make a short script that tells our Agent to move and follow our target, in this case, the Player.

But before that, let’s dive into some NavMesh settings:

In this NavMesh Surface, we are interested in two parameters.

Agent Type — is Robot, because it knows what kind of agent will walk around on the surface
Include Layers — is where you specify which GameObject layers the NavMesh Surface will include during the baking process.

This is NavMesh Agent settings, where you can choose Agent Type and give it some basic and pretty straightforward options.

This is Navigation of the Agent. Let’s find out what those options are because I find it very interesting.

Radius — defines agent’s drum roll radius! We determine how wide our agent is. When baking the mesh, Unity will offset all walls and corners by this amount to prevent your agent from rubbing its sides against textures when walking or getting stuck in narrow passages.
Height — defines agent’s height. Allows Unity to calculate whether the agent can fit under low obstacles, bridges, or ceilings. If the clearance height is less than 1, the mesh underneath it will not be baked.
Step Height — determines the maximum height of a stair or threshold of an obstacle that the agent can climb. We want to make sure that this option is always lower than Height.
Max Slope — the maximum degree of surface slope that the agent is physically capable of walking up or down.
Drop Height — determines the maximum height from which agent can jump. In our case 9. If the actual height of an object is more than 9 then agent will not drop down.
Jump Distance — is the maximum horizontal distance that agent can jump.

Now let’s check the code out:

using UnityEngine;
using UnityEngine.AI;
using StarterAssets;

public class Robot : MonoBehaviour
{
    private FirstPersonController _player;
    private NavMeshAgent _agent;

    private void Awake()
    {
        _agent = GetComponent<NavMeshAgent>();
    }

    private void Start()
    {
        _player = FindAnyObjectByType<FirstPersonController>();
    }

    private void Update()
    {
        _agent.SetDestination(_player.transform.position);
    }
}

To use NavMesh we need to import its namespace, which is UnityEngine.AI. I also use StarterAssets for this project for a premade first-person controller from Asset’s Store.

First, we need to declare and cache our variables. We retrieve the _agent component in Awake() since this script is attached directly to the Robot game object. Then, we find the _player in Start(). In the Update(), we call the built-in SetDestination() method, which takes player's Vector3 position. Once the game starts, the agent will dynamically pursue the player wherever they go.

And that’s it. This is how to make a simple AI follower in Unity.

Mathf.Lerp() Making dynamic camera zoom in Unity using Coroutines

Giorgi Eliozashvili — Sun, 19 Jul 2026 09:37:42 +0000

The easiest way to show Player how fast his character is moving is by using camera zoom. For example, if Player is going very fast, camera is zoomed out, FOV is increased, and a feeling of swiftness appears.

We want the camera zoom to be smooth, not instantaneous. For this Mathf.Lerp(), Coroutine and while loop come in handy.

The Mathf.Lerp(A, B, t) function stands for linear interpolation. It takes a starting value - A, a final target - B, and returns a point between them based on the t parameter (a percentage of the path from 0 to 1).

If we want the FOV change to take exactly the time we specify (for example, half a second), we can’t simply pass random numbers. We need a strict timer.

To achieve this, a while loop is created inside the Coroutine, which calculates what fraction of the total animation time has elapsed each frame.

Let’s check the realisation:

using System;
using UnityEngine;
using System.Collections;
using Unity.Cinemachine;

public class CameraController : MonoBehaviour
{
    [SerializeField] private float minFOV = 40f;
    [SerializeField] private float maxFOV = 80f;
    [SerializeField] private float zoomDuration = 0.5f;
    [SerializeField] private float zoomSpeedModifier = 2f;

    private CinemachineCamera _camera;
    private Coroutine _zoomCoroutine;

    private void Awake()
    {
        _camera = GetComponent<CinemachineCamera>();
    }

    // Called externally to trigger the camera zoom effect
    // In this project, it's invoked within the level generation script
    public void ChangeCameraFOV(float speedAmount)
    {
        if (_zoomCoroutine != null)
            StopCoroutine(_zoomCoroutine);

        _zoomCoroutine = StartCoroutine(CameraFOVChange(speedAmount));
    }

    private IEnumerator CameraFOVChange(float speedAmount)
    {
        // Store the initial FOV before starting the interpolation
        var startFOV = _camera.Lens.FieldOfView;

        // // Calculate target FOV and clamp it to prevent visual artifacts or unexpected behavior
        var targetFOV = Mathf.Clamp(startFOV + speedAmount * zoomSpeedModifier, minFOV, maxFOV);

        var elapsedTime = 0f;
        while (elapsedTime < zoomDuration)
        {
            elapsedTime += Time.deltaTime;

            // Calculate the normalized time (0 to 1) 
            // by dividing elapsed time by total duration
            float t = elapsedTime / zoomDuration;

            _camera.Lens.FieldOfView = Mathf.Lerp(startFOV, targetFOV, t);
            // Pause execution and resume on the next Update cycle
            yield return null;
        }

        // Ensure the camera snaps precisely to the target FOV
        // avoiding float inaccuracies
        _camera.Lens.FieldOfView = targetFOV;
        _zoomCoroutine = null;
    }
}

The Coroutine + While Loop + Mathf.Lerp combination is a great pattern for implementing any smooth time change in Unity. Once you understand how the time step t is calculated, you can use this pattern for anything from smooth platform movement to dissolving objects upon destruction.

Unity Physics Material

Giorgi Eliozashvili — Sun, 19 Jul 2026 09:34:56 +0000

The Physics Material is a material asset that you can place on a GameObject. The material defines properties on the collider’s surface, such as friction and bounciness.

To create Physics Material, simply right-click in Project folder, hover over Create, and at the bottom, you will see Physics Material. After creating it, you need to drag and drop the material to GameObject of your choice that has a collider on it.

NOTE: If collider has no Physics Material on it (None (Physics Material)) then it has default **Physics Material** properties.

Dynamic Friction: works when an object is already in motion on a surface and determines how fast it will stop sliding. Value of 0 will make an object act like a hockey puck, and value of 1 will make an object stop sliding almost immediately.
Static Friction: is the frictional force that must be overcome to move a stationary object. Imagine a wardrobe that you must move. It is always harder to move a heavy wardrobe from its place (high static friction) than to push it further once it has already moved (dynamic friction). Value of 0 means that any smallest push will make an object move.
Bounciness: is pretty straightforward. This option determines how well an object will bounce. Value of 0 means an object has no bouncing properties, imagine you drop a block of wet cheese, while value of 1 is a perfect bouncing ball.

Friction Combine: determines the friction between two touching surfaces.

Average: arithmetic mean between two objects.
Minimum: picks the lowest value of two objects.
Maximum: pick the highest value of two objects.
Multiply: values are multiplied by each other.

Bounce Combine: works the same way as Friction Combine, but with bounciness and has the same dropdown options.

Quaternion.LookRotation & Vector subtraction

Giorgi Eliozashvili — Sun, 19 Jul 2026 09:29:51 +0000

Today, we talk about two very interesting features, vector subtraction and Quaternion.LookRotation on a missile example.

First, we need to find a direction from point A to point B, and we do this by subtracting two Vectors:

Direction = Target position — Missile position

Then, we translate the direction into rotation. In Unity we use Quaternions to handle rotations.

There is a good method that Unity offers named Quaternion.LookRotation(). It takes direction and calculates rotation around Y axis (which is sky by default).

private void AimMissile()
{
    foreach (var missile in missiles)
    {
        // Distance/Direction between missile and target
        var shootingDistance = target.position - missile.transform.position;
        // Quaternion.LookRotation takes shootingDistance Vector3
        // to rotate missile in target's direction
        var missileRotationToTarget = Quaternion.LookRotation(shootingDistance);
        // And finally update missile transform
        missile.transform.rotation = missileRotationToTarget;
    }
}

So, every frame, this method executes a loop throughout missiles array. Every missile individually calculates its own and target coordinates. LookRotation understands the angle at which to rotate each missile. As a result, even if the target shifts to the side, all missiles synchronously adjust their course in flight.

Mathf.Exp()

Giorgi Eliozashvili — Sun, 19 Jul 2026 09:27:22 +0000

I am making a rail game where you pilot a cosmic ship and shoot down enemies, and I wanted to share what I used for smooth rotation.

I want to tell how Mathf.Exp() works in Unity. To make my ship tilt left or right smoothly, there are many options, but I stopped at Mathf.Exp().

First of all, what is Mathf.Exp()?

It is a mathematical exponent, an Euler number (e), which ≈ 2.713. The Mathf.Exp() method takes a power in parentheses and raises Euler’s constant to that same power.

private void ProcessRotation()
    {
        var pitch = -controlRotationFactor * _movement.y;
        var roll = -controlRotationFactor * _movement.x;

        var targetRotation = Quaternion.Euler(pitch, 0f, roll);

        transform.localRotation = Quaternion.Lerp
        (
            transform.localRotation,
            targetRotation,
            1f - Mathf.Exp(-rotationSpeed * Time.deltaTime)
        );
    }

This is the code that calculates tilts. Let’s dive into it a little.

For example, we have a powerful PC which generates high FPS, because of that Time.deltaTime will be a very small number. Let’s use some numbers:

rotation speed = 20
Time.deltaTime = 0.02 (roughly 50 FPS)

Mathf.Exp(-20 * 0.02) = -0.4

This means Euler’s number (e) is raised to a negative exponent. Raising e to a negative power produces a small value. In this case, Mathf.Exp(-0.4) returns a small number, which is then subtracted from 1f.

Now, how does this work in Update method:

Before I tell you this, a few words about Lerp method. Since we use Quaternion.Lerp, I will talk about that one exactly. So Lerp receives 3 arguments: start unit, end unit and interpolation ratio. Imagine this interpolation ratio as a loading bar where 0 is literally 0%, and 1 is 100%

a - Start unit quaternion value, returned when t = 0
b - End unit quaternion value, returned when t = 1
t - Interpolation ratio. The value is clamped to the range [0, 1]

In a first frame, when you press button to tilt your ship, for example, to the left, Mathf.Exp returns a value (0.67 in our case) which is subtracted from 1f, and we get 0.33 as a result. This means that in one frame, the ship is tilted by 33% already, because first result is the highest. On the next frame, we take the same 33% but from the remainder, here is a breakdown:

1f
1f — 0.33 = 0.67
Now we take 33% of 0.67, which is 0.22
0.67 — 0.22 = 0.45
etc

With every new frame we receive a smaller number, and our eye sees this like this: ship is tilted on the left and slows down the tilt speed when it reaches the target angle. In math, this is an infinite process, but in Unity numbers are eventually rounded to almost 0.

Using 1f — Mathf.Exp(-speedRotation * Time.deltaTime) inside Quaternion.Lerp, we get the ideal wing pitch. The higher the player’s FPS, the smaller the steps, but the resulting smoothness and turn time will be the same whether on a low-end laptop or a powerful gaming PC.

Oscillation, Mathf.PingPong, Vector3.Lerp

Giorgi Eliozashvili — Sun, 19 Jul 2026 09:17:46 +0000

When you develop a game at the beginning of your journey, you quickly notice that the environment is very static. To change that, let’s create some oscillations and move our platforms.

We will use methods like Vector3.Lerp and Mathf.PingPong.

using UnityEngine;

public class Oscillate : MonoBehaviour
{
    [SerializeField] private Vector3 movementVector;
    [SerializeField] private float speed;

    private Vector3 _startPosition;
    private Vector3 _endPosition;
    private float _movementFactor;

    private void Start()
    {
        _startPosition = transform.position;
        _endPosition = transform.position + movementVector;
    }

    private void Update()
    {
        _movementFactor = Mathf.PingPong(Time.time * speed, 1f);
        transform.position = Vector3.Lerp(_startPosition, _endPosition, _movementFactor);
    }
}

First, we add movementVector and speed to inspector. movementVector receives the direction, and we tell it how far object must move. speed defines how fast objects move

_startPosition simply gets the starting coordinates in Start() with transform.position, and _endPosition is the sum of the _startPosition and movementVector.

Now _movementFactor is different. It defines the progress of the movement. Imagine it as a loading bar from 1% to 100%. In Update() method, we constantly calculate it every frame using Mathf.PingPong

_movementFactor = Mathf.PingPong(Time.time * speed, 1f);

So what is going on here, Mathf.PingPong does what you would imagine. Value goes back and forth. 1f is our length, so in Update() every frame _movementFactor is getting updated from 0.0, 0.1, 0.2… up to 1.0, when the value is 1.0, it goes back to 0.0 in the same way. And since it’s in Update() this is an endless cycle.

transform.position = Vector3.Lerp(_startPosition, _endPosition, _movementFactor);

Now this is where magic happens. Lerp (Linear Interpolation) takes start position, end position and a “loading” bar. Why we did exactly 1f in PingPong is perfectly described in the official documentation:

a — _startPosition

b — _endPosition

Value used to interpolate between a and b. Values greater than one are clamped to 1. Values less than zero are clamped to 0.

In short, Lerp is teleporting an object by a very short amount, and to our eyes, it looks like smooth movement.

How to add Sounds and Particles in Unity

Giorgi Eliozashvili — Sun, 19 Jul 2026 09:11:41 +0000

There is no game without sounds and particle effects, this is what gives life, along with other details, to our game.

How to add Sounds to our project:

First of all, Audio Source component has to be added to GameObject, then we create a folder where my sounds will be placed:

Afterwards, we declare [SerializeField]:

[SerializeField] private AudioClip engineThrustSfx;
[SerializeField] private AudioClip crashSfx;
[SerializeField] private AudioClip successSfx;

And we drag and drop our sounds to newly created [SerializeField] in Unity Inspector, which were declared in Movement.cs:

We write code where we do Caching, so we receive Audio Source reference:

private AudioSource _audioSource;

private void Start()
    {
        _audioSource =  GetComponent<AudioSource>();
    }

And we are good to go. From now on, we can easily implement our sound effects using logic. For example:

_audioSource.PlayOneShot(audioClip)

We call PlayOneShot (this method plays sound once) method on _audioSource and pass audioClip custom argument, which contains the sound. Or this example:

private void OnCollisionEnter(Collision collision)
    {
        switch (collision.gameObject.tag)
        {
            case "Friendly":
                break;
            case "Finish":
                StartCoroutine(HandleAfterDelay(isNext: true, reload: false, audioClip: successSfx));
                successParticle.Play();
                break;
            default:
                StartCoroutine(HandleAfterDelay(isNext: false, reload: true, audioClip: crashSfx));
                crashParticle.Play();
                break;
        }
    }

Let’s break down case “Finish”. When a collision happens, and collision.gameObject.tag is “Finish” this means in my game Player landed on the landing pad, and it’s time to load next scene, which happens with a coroutine. We pass a bunch of arguments and pass sound (which is declared above). Then we handle it in IEnumerator function below:

private IEnumerator HandleSceneAfterDelay(bool isNext, bool reload, AudioClip audioClip)
    {
        // disabling Movement.cs forces to execute OnDisable method
        _movementScript.enabled = false;
        _rb.isKinematic = true;

        if (audioClip)
            _audioSource.PlayOneShot(audioClip);

        yield return _delay;
        Helpers.HandleScene(isNext, reload);
    }

So if audioClip is not null, play the sound when the scene is handled.

This process is similar to adding Sounds. Here is a screenshot of my Player Object:

Rick’s Weird Space Rocket was provided to me from Udemy course I follow. So here we have 5 particles. Explosion executes when Player hits Obstacle, Success when we safely land on the landing pad, and the rest are thrusters. All of those particles have this Component named Particle System.

This is quite large system that allows you to create custom particles right in Unity.

Rest of the implementation is same as in Sounds. You declare variables, drag and drop them, and use them in your logic. They even share same methods like Play() or Stop().

Quaternion Rotation

Giorgi Eliozashvili — Sun, 19 Jul 2026 09:04:25 +0000

When you work with physics in Unity you will eventually stumble upon Quaternion class. Official Unity documentation states:

Quaternions are used to represent rotations.

But behind those simple words lies a complex mathematical structure based on numbers and four-dimensional space (X, Y, Z, W).

First, let me tell you how I found out about Quaternions.

Those orange objects are spinning. When spinners are hitting player (red ball), most of the time player goes through objects, which is not what I wanted. The reason was that spinners had no Rigidbody, hence no physics.

void Update()
    {
        transform.Rotate(spinX, spinY, spinZ);
    }

I had this simple transform.Rotate line. I found out that my issue is called Tunneling. Spinner was rotating too fast and since Unity is not checking collision every second, but every frame, the following bug happened:

First frame: Spinner was in front of the ball
Second frame: Spinner was behind the ball

To fix this issue, I was introduced to Quaternions.

Now back to Quaternions. Humans easily understand Euler Angles, that is, our beloved X, Y and Z. We can see them in Unity Inspector. But Euler Angles can have a bug called Gimbal Lock.

Imagine you have three rings nested inside each other like a gyroscope:

The outer ring rotates the object left and right (Y axis).

The middle ring rotates the object up and down (X axis).

The inner ring tilts the object sideways (Z axis).

They work in turns, dependent on each other. If you rotate the middle ring exactly 90 degrees, the inner ring will rotate and align itself with the outer ring.

At this point, the Z and Y axes are aligned. Now, whether you rotate the outer ring or the inner ring, the object performs exactly the same motion. However, it can no longer physically rotate in the third direction, it’s stuck. To regain the lost axis, you’ll first have to rotate the middle ring back.

For a human in real life, this isn’t a problem, but for Unity’s Euler angle math, it’s a disaster, physics breaks and loses control of one of the axes, and the object starts to jerk wildly or rotate in the wrong direction.

To resolve this issue, Quaternions were introduced. A Quaternion describes a rotation not as a sequence of three separate rotations, but as a simultaneous calculation of a direction vector and the angle of rotation around it using four components: X, Y, Z, and W.

Because of a four-dimensional structure, Quaternions have three advantages:

No Gimbal Lock — object will rotate freely and correctly in any direction.
Effective Interpolation — methods like Quaternion.Slerp allows calculating smooth transitions from one rotation to another.
Performance — Quaternions allow the physics engine to work faster and better.

To fix the issue I wrote this line of code:

Rigidbody rigidBody;

    void Awake()
    {
        rigidBody = GetComponent<Rigidbody>();
    }

    void FixedUpdate()
    {
        Quaternion deltaRotation = Quaternion.Euler(
            new Vector3(rotateX, rotateY, rotateZ) * Time.fixedDeltaTime
        );
        rigidBody.MoveRotation(rigidBody.rotation * deltaRotation);
    }

Since we work with physics, we use FixedUpdate and Time.fixedDeltaTime.

There we call Quaternion class and use its static method to pass three dimentional vector, and multiply it by Time.fixedDeltaTime. Eventually, we call MoveRotation on our Rigidbody and rotate our object.

You might ask what’s the difference between Time.deltaTime and Time.fixedDeltaTime.

Time.deltaTime — is the difference between normal frames in Update function. It always changes based on PC stats. Stronger the PC, less time there is between frames.

Time.fixedDeltaTime — its fixed time between frames in FixedUpdate function. In Unity it is always the same, 0.02 seconds.

In a nutshell, deltaTime is dependent on game lag and FPS, while fixedDeltaTime is a stable, perfectly smooth metronome for the physics engine.

So let's just not manually intervene with Quaternions and just use given static methods of Quaternion class that are basically our translators.

To sum up, Quaternions in Unity are not a replacement for Euler angles, but rather a safe internal implementation of them. We write code and configure the inspector in degrees, but the engine converts them into Quaternions behind the scenes, so that collisions, triggers, etc., are processed smoothly, quickly, and without errors.

Data transfer between script files

Giorgi Eliozashvili — Sun, 19 Jul 2026 08:54:28 +0000

I learned quite a lot today to compensate for the days that I had to drop. The most important piece of knowledge that I have gathered today is how to transfer data between script files. Let’s get to it:

So the problem was that I needed to catch the Player’s position when he set foot on a trigger that activates a small trap, which shoots hazardous balls at the Player’s coordinates.

I have two script files. One for a trigger object and the other for flying projectiles.

So at first, in a script file (file name: ProjectileTowardsPlayer.cs) for flying projectiles, I made a public function that receives the Player's position when the trigger is activated (which happens in TriggerProjectiles.cs) and assigns its value to an already declared variable playerPosition.

public void PlayerPosAtTrigger(Vector3 playerPos)
    {
        playerPosition = playerPos;
    }

Now, how does this function’s parameter catches players position, you may ask? And I shall grant you an answer! :D

Here is my piece of code:

void OnTriggerEnter(Collider other)
    {
        if (other.gameObject.CompareTag("Player"))
        {
            for (int i = 0; i < projectiles.Length; i++)
            {
                if (projectiles[i] != null)
                {
                    var projectileScript = projectiles[i]
                        .GetComponent<ProjectileTowardsPlayer>();
projectileScript.PlayerPosAtTrigger(other.transform.position);

                    projectiles[i].SetActive(true);
                }
            }
        }
    }

Now, don’t think much about the logic of this. In short, it loops through projectiles, checks if the array value is null or not, and sets them active (because at the start, they are inactive). Now, projectileScript variable is where magic happens. When Player triggers the trap, we iterate through projectiles and set them active, and catch Player’s coordinates for TriggerProjectiles.cs using:

var projectileScript = projectiles[i].GetComponent<ProjectileTowardsPlayer>();

and then calling a PlayerPosAtTrigger() function and passing an argument to it

projectileScript.PlayerPosAtTrigger(other.transform.position);

so TriggerProjectiles.cs will know Player’s coordinates, and trap will shoot at the correct location.

Unity Time.deltaTime

Giorgi Eliozashvili — Sun, 19 Jul 2026 08:47:08 +0000

The interval in seconds from the last frame to the current one

Let's break it down a little:

You and your friend want to play a racing game, your PC is powerful and has 100 FPS in that said racing game, meanwhile, your friend has a slow PC, and it can only generate 10 FPS. What does this mean? This means that if a car is moving 1 meter per frame, your car will end up being way further, covering 100 meters per second because you have 100 FPS, while your friend's car will only cover 10 meters in a second because his PC is slower and generates only 10 FPS. !!! UNFAIR !!! You say, and you will be right. To make cars travel the same distance on both machines, you need Time.deltaTime. Now, how does it work? Time.deltaTime measures exactly how much time passed since the very last frame. On your PC, the time between frames is very short, 0.01 seconds, on your friend's PC, the time between frames is longer, 0.1 seconds. When you multiply your speed by Time.deltaTime Unity adjusts the movement to that time gap. So speaking easily, your computer does 100 tiny steps while your friend's computer does 10 bigger steps, but eventually you both move with the same speed.

How Time.deltaTime is calculated:

Time.deltaTime = Timestamp of Current Frame - Timestamp of Last Frame.

Explanation:

Frame 1 finished: Unity records time (e.g. 10.00 sec)
Frame 2 finished: Unity records time again (e.g. 10.03 sec)
Calculation: Unity subtracts 10.00 from 10.03 and gets 0.03, and assigns that value to Time.deltaTime (Time.deltaTime = 10.03 - 10.00)
The Update: **Unity **opens your Update() method and passes that 0.03 value into your movement calculation

Here is a small piece of code as an example of how to use Time.deltaTime:

void Update()
    {
        float x = Input.GetAxis("Horizontal") * Time.deltaTime * moveSpeed;

        transform.Translate(x, 0, 0);
    }

What we do here is we declare a floating variable, and we assign X coordinates. To make our character move, we need to multiply X by moveSpeed and Time.deltaTime. So now our character moves on the X coordinate with the same speed on every machine.