Input axis for smooth movement in Unity - Step-by-Step Execution

Concept Flow - Input axis for smooth movement

Start

↓

Read Input Axis

↓

Calculate Movement Vector

↓

Apply Movement to Object

↓

Update Frame

↩Back to Read Input Axis

The program reads the input axis value each frame, calculates movement smoothly, applies it to the object, and repeats every frame.

Execution Sample

Unity

float moveX = Input.GetAxis("Horizontal");
float moveZ = Input.GetAxis("Vertical");
Vector3 move = new Vector3(moveX, 0, moveZ);
transform.Translate(move * speed * Time.deltaTime);

This code reads horizontal and vertical input axes, creates a movement vector, and moves the object smoothly based on input.

Execution Table

Frame	Input.GetAxis("Horizontal")	Input.GetAxis("Vertical")	Movement Vector (x,y,z)	Action	Object Position Change
1	0.0	0.0	(0.0, 0, 0.0)	No movement	No change
2	0.5	0.0	(0.5, 0, 0.0)	Move right slowly	Position moves right by 0.5 * speed * Time.deltaTime
3	1.0	0.0	(1.0, 0, 0.0)	Move right faster	Position moves right by 1.0 * speed * Time.deltaTime
4	0.0	1.0	(0.0, 0, 1.0)	Move forward	Position moves forward by 1.0 * speed * Time.deltaTime
5	-0.5	0.5	(-0.5, 0, 0.5)	Move diagonally left-forward	Position moves diagonally by vector * speed * Time.deltaTime
6	0.0	0.0	(0.0, 0, 0.0)	Stop movement	No change

💡 Loop continues each frame reading input until program stops

Variable Tracker

Variable	Start	After Frame 1	After Frame 2	After Frame 3	After Frame 4	After Frame 5	After Frame 6
moveX	0.0	0.0	0.5	1.0	0.0	-0.5	0.0
moveZ	0.0	0.0	0.0	0.0	1.0	0.5	0.0
move Vector	(0,0,0)	(0,0,0)	(0.5,0,0)	(1,0,0)	(0,0,1)	(-0.5,0,0.5)	(0,0,0)

Key Moments - 3 Insights

Why does the movement feel smooth instead of jumping suddenly?

Because Input.GetAxis returns values gradually changing between -1 and 1, not just -1, 0, or 1. This gradual change is shown in the execution_table rows where moveX and moveZ change smoothly.

What happens if you use Input.GetAxisRaw instead of Input.GetAxis?

Input.GetAxisRaw returns only -1, 0, or 1 instantly, causing movement to jump suddenly without smoothing. This contrasts with the smooth gradual values seen in the execution_table.

Why multiply by Time.deltaTime when moving the object?

Multiplying by Time.deltaTime makes movement frame-rate independent, so the object moves the same speed regardless of how fast frames update. This keeps movement smooth and consistent.

Visual Quiz - 3 Questions

Look at the execution_table, what is the movement vector at Frame 3?

A (0.0, 0, 1.0)

B (0.5, 0, 0.0)

C (1.0, 0, 0.0)

D (-0.5, 0, 0.5)

💡 Hint

Check the 'Movement Vector (x,y,z)' column at Frame 3 in the execution_table.

At which frame does the object move diagonally?

A Frame 2

B Frame 5

C Frame 4

D Frame 6

💡 Hint

Look for movement vectors with both x and z non-zero in the execution_table.

If Input.GetAxis("Horizontal") returned only -1, 0, or 1 instantly, how would the movement vector change?

A It would jump suddenly between values

B It would stay at zero always

C It would change smoothly like in the table

D It would become negative only

💡 Hint

Refer to key_moments about difference between Input.GetAxis and Input.GetAxisRaw.

Concept Snapshot

Input.GetAxis reads smooth input values between -1 and 1.
Use these values to create a movement vector.
Multiply by speed and Time.deltaTime for smooth, frame-independent movement.
Apply movement vector to transform.Translate each frame.
This creates smooth player movement responding to input gradually.

Full Transcript

This example shows how Unity's Input.GetAxis method reads smooth input values for horizontal and vertical movement. Each frame, the program reads these values, creates a movement vector, and moves the object accordingly. The values change gradually, not instantly, which makes movement smooth. Multiplying by Time.deltaTime ensures movement speed is consistent regardless of frame rate. The execution table traces input values and movement vectors frame by frame, showing how the object's position changes smoothly. Key moments clarify why Input.GetAxis smooths input and why Time.deltaTime is important. The visual quiz tests understanding of these step-by-step changes.