Color and size over lifetime in Unity - Step-by-Step Execution

Concept Flow - Color and size over lifetime

Start Particle

↓

Initialize Color & Size

↓

Update Lifetime

↓

Calculate Color & Size based on Lifetime

↓

Apply Color & Size

↓

Check if Lifetime Ended?

No→Loop Update

Yes↓

Destroy Particle

This flow shows how a particle's color and size change as its lifetime progresses until it is destroyed.

Execution Sample

Unity

void Update()
{
  float lifeRatio = elapsedTime / totalLifetime;
  color = Color.Lerp(startColor, endColor, lifeRatio);
  size = Mathf.Lerp(startSize, endSize, lifeRatio);
}

This code updates the particle's color and size smoothly over its lifetime.

Execution Table

Step	elapsedTime (s)	lifeRatio	Color (R,G,B,A)	Size	Action
1	0.0	0.0	(1,1,1,1)	1.0	Initialize particle with startColor and startSize
2	0.5	0.1	(0.9,0.9,0.9,0.9)	1.1	Update color and size slightly
3	1.0	0.2	(0.8,0.8,0.8,0.8)	1.2	Update color and size
4	2.5	0.5	(0.5,0.5,0.5,0.5)	1.5	Mid lifetime color and size
5	4.0	0.8	(0.2,0.2,0.2,0.2)	1.8	Near end color and size
6	5.0	1.0	(0,0,0,0)	2.0	Lifetime ended, final color and size
7	5.0	1.0	(0,0,0,0)	2.0	Destroy particle

💡 Particle lifetime reached 5.0 seconds, condition to destroy particle met.

Variable Tracker

Variable	Start	After 1	After 2	After 3	After 4	After 5	Final
elapsedTime	0.0	0.5	1.0	2.5	4.0	5.0	5.0
lifeRatio	0.0	0.1	0.2	0.5	0.8	1.0	1.0
color	(1,1,1,1)	(0.9,0.9,0.9,0.9)	(0.8,0.8,0.8,0.8)	(0.5,0.5,0.5,0.5)	(0.2,0.2,0.2,0.2)	(0,0,0,0)	(0,0,0,0)
size	1.0	1.1	1.2	1.5	1.8	2.0	2.0

Key Moments - 3 Insights

Why does the color and size change smoothly instead of jumping suddenly?

Because the code uses interpolation (Lerp) based on lifeRatio, which gradually changes from 0 to 1 as elapsedTime increases (see execution_table rows 2 to 6).

What happens when elapsedTime equals totalLifetime?

The particle reaches the end of its lifetime, color and size reach their final values, and the particle is destroyed (see execution_table rows 6 and 7).

Why is lifeRatio calculated as elapsedTime divided by totalLifetime?

This normalizes elapsedTime to a 0-1 range, making it easy to interpolate color and size proportionally over the particle's lifetime (see variable_tracker lifeRatio values).

Visual Quiz - 3 Questions

Look at the execution_table, what is the color at step 4?

A (0.8,0.8,0.8,0.8)

B (0.2,0.2,0.2,0.2)

C (0.5,0.5,0.5,0.5)

D (1,1,1,1)

💡 Hint

Check the Color column at step 4 in the execution_table.

At which step does the size first reach 1.5?

A Step 4

B Step 3

C Step 5

D Step 6

💡 Hint

Look at the Size column in the execution_table and find when size is 1.5.

If totalLifetime was increased to 10 seconds, how would lifeRatio at step 4 change?

A It would be 1.0

B It would be 0.25

C It would be 0.5

D It would be 0.8

💡 Hint

lifeRatio = elapsedTime / totalLifetime; step 4 elapsedTime is 2.5 seconds.

Concept Snapshot

Color and size over lifetime in Unity:
- Use elapsedTime / totalLifetime to get lifeRatio (0 to 1).
- Use Color.Lerp(startColor, endColor, lifeRatio) to change color smoothly.
- Use Mathf.Lerp(startSize, endSize, lifeRatio) to change size smoothly.
- Update these every frame until lifetime ends.
- Destroy particle when lifetime is over.

Full Transcript

This visual execution shows how a particle's color and size change smoothly over its lifetime in Unity. The key is calculating lifeRatio as elapsedTime divided by totalLifetime, which goes from 0 to 1. Using this ratio, the code interpolates color and size from start to end values using Lerp functions. Each step updates elapsedTime, recalculates lifeRatio, and applies new color and size. When elapsedTime reaches totalLifetime, the particle is destroyed. This approach ensures smooth transitions and proper lifetime management.