Particle collision in Unity - Deep Dive

Overview - Particle collision

What is it?

Particle collision in Unity is a feature that lets tiny visual elements called particles interact with other objects or surfaces in a scene. When particles hit something, they can bounce, stop, or trigger effects like sparks or smoke. This makes particle systems look more real and dynamic in games or simulations. It helps create effects like explosions, rain hitting the ground, or dust clouds.

Why it matters

Without particle collision, particles would just float through objects unrealistically, breaking the illusion of a real world. This would make games and simulations feel less immersive and believable. Particle collision solves the problem of making tiny visual effects respond naturally to their environment, adding depth and excitement to visual storytelling.

Where it fits

Before learning particle collision, you should understand basic Unity particle systems and how to create and control particles. After mastering collision, you can explore advanced particle behaviors like triggers, custom collision responses, and integrating physics for complex effects.

Mental Model

Core Idea

Particle collision is how tiny visual dots in Unity detect and react when they hit other objects, making effects feel real and interactive.

Think of it like...

Imagine throwing hundreds of tiny balls in a room; when they hit walls or furniture, they bounce or stop, creating a lively scene instead of just floating through everything.

Particle System
  │
  ├─ Emit Particles
  │
  ├─ Move Particles
  │
  ├─ Detect Collision ──> Collider Object
  │                      │
  │                      ├─ Bounce
  │                      ├─ Die
  │                      └─ Trigger Effect
  └─ Render Particles

Build-Up - 6 Steps

1

Foundation

Understanding Unity Particle Systems

Concept: Learn what a particle system is and how it creates many small visual elements.

A particle system in Unity emits many small images or shapes called particles. These particles can move, change color, size, and fade over time. You create effects like fire, smoke, or rain by controlling these particles. The system controls how particles appear and behave but by default, particles do not interact with objects.

Result

You can create simple visual effects that look like many tiny dots moving or changing but they do not react to the environment yet.

Understanding the basics of particle systems is essential because collision builds on how particles move and behave visually.

2

Foundation

What is Particle Collision Module

Concept: Unity has a built-in module to detect when particles hit other objects and respond.

The Particle Collision module is a setting inside the particle system that lets particles detect collisions with other objects that have colliders. You enable it and set options like what happens on collision (bounce, die, or send messages). This module uses Unity's physics system to check collisions each frame.

Result

Particles can now detect when they hit objects and react based on your settings.

Knowing that collision is a module inside the particle system helps you see it as an add-on that changes particle behavior.

3

Intermediate

Configuring Collision Properties

🤔Before reading on: Do you think particles can pass through objects if collision is enabled but no bounce is set? Commit to your answer.

Concept: Learn how to control particle collision behavior with settings like bounce, lifetime loss, and collision quality.

In the Collision module, you can set how particles react: they can bounce off surfaces, lose lifetime (fade out), or die immediately. You also choose collision quality (how precise detection is) and which layers to collide with. For example, setting bounce to 1 makes particles fully bounce, 0 means no bounce. You can also control if particles collide with 3D or 2D objects.

Result

Particles behave differently on collision depending on these settings, allowing for varied effects like bouncing raindrops or sparks that vanish on impact.

Understanding these properties lets you fine-tune how realistic or stylized your particle collisions appear.

4

Intermediate

Using Collision Events for Interaction

🤔Before reading on: Can particle collisions trigger custom game logic like scoring or sound effects? Commit to your answer.

Concept: Particles can send collision events to scripts to trigger custom responses beyond visual effects.

Unity allows you to receive collision events from particles in your scripts. By enabling 'Send Collision Messages' in the Collision module, your script can listen for OnParticleCollision events. This lets you run code when particles hit objects, such as playing sounds, spawning new effects, or updating game scores.

Result

Particle collisions can now influence gameplay or trigger complex reactions, not just visual changes.

Knowing how to connect particle collisions to scripts opens up creative possibilities for interactive effects.

5

Advanced

Optimizing Particle Collision Performance

🤔Before reading on: Do you think enabling high-quality collision for thousands of particles always improves game performance? Commit to your answer.

Concept: Collision detection can be expensive; learn how to balance quality and performance.

High-quality collision checks use more CPU and can slow down your game if many particles collide. Unity offers collision quality settings like 'High', 'Medium', and 'Low' to balance accuracy and speed. You can also limit collision layers and reduce max collision events per frame. Using simple colliders and fewer particles improves performance.

Result

Your particle effects run smoothly without unnecessary slowdowns, even with collisions enabled.

Understanding performance trade-offs helps you create effects that look good and run well on all devices.

6

Expert

Custom Collision Responses with Scripts

🤔Before reading on: Can you override Unity's default particle collision reactions entirely with your own code? Commit to your answer.

Concept: Advanced users can fully control particle collision behavior by combining collision events with custom scripts.

While Unity provides built-in collision responses, you can disable automatic reactions and handle collisions manually. By listening to OnParticleCollision events, you can calculate custom physics, spawn new particle systems, or modify particle properties dynamically. This allows effects like particles sticking to surfaces, changing color on impact, or triggering chain reactions.

Result

You gain full creative control over how particles behave on collision, enabling unique and complex effects.

Knowing how to override default behaviors empowers you to push particle systems beyond standard visual effects.

Under the Hood

Unity's particle collision uses the physics engine to check each particle's position against colliders in the scene every frame. When a particle intersects a collider, the system calculates the collision point and applies the configured response like bounce or death. Collision detection can use simple shapes or mesh colliders depending on settings. Events are queued and sent to scripts if enabled. The system balances accuracy and performance by adjusting collision quality and limiting checks.

Why designed this way?

Particle collision was designed to integrate smoothly with Unity's existing physics system to reuse collision detection logic and provide consistent behavior. This avoids reinventing collision checks and leverages optimized engine code. The modular design lets developers enable or disable collision per particle system, balancing flexibility and performance. Alternatives like fully custom collision would be slower or more complex to implement.

┌─────────────────────────────┐
│ Particle System             │
│ ┌─────────────────────────┐ │
│ │ Emit Particles          │ │
│ │ Move Particles          │ │
│ │ Collision Module        │ │
│ │ ┌─────────────────────┐ │ │
│ │ │ Check Collisions     │─┼─┼─> Collider Objects
│ │ │ (Physics Engine)     │ │ │
│ │ └─────────────────────┘ │ │
│ │ Apply Collision Result  │ │
│ └─────────────────────────┘ │
└─────────────────────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Do particles automatically collide with all objects in the scene by default? Commit yes or no.

Common Belief: Particles always collide with any object in the scene once collision is enabled.

Reality: Particles only collide with objects on layers specified in the collision module settings.

Why it matters: If you forget to set collision layers, particles may pass through important objects, breaking the effect.

Quick: Does enabling particle collision guarantee perfect physical realism? Commit yes or no.

Common Belief: Particle collision makes particle behavior physically perfect and realistic automatically.

Reality: Particle collision is an approximation optimized for visuals, not full physics simulation; some behaviors are simplified.

Why it matters: Expecting perfect physics can lead to confusion when particles behave differently than real objects, requiring custom scripting.

Quick: Can particle collision events be used to trigger gameplay logic? Commit yes or no.

Common Belief: Particle collisions are only visual and cannot trigger game code or events.

Reality: Particle collisions can send events to scripts, enabling gameplay interactions like scoring or sound effects.

Why it matters: Missing this limits creative use of particles in interactive games.

Quick: Does increasing collision quality always improve performance? Commit yes or no.

Common Belief: Higher collision quality settings always make particle collisions better without downsides.

Reality: Higher quality increases CPU load and can reduce game performance if overused.

Why it matters: Ignoring performance costs can cause frame drops and poor user experience.

Expert Zone

1

Collision detection accuracy depends heavily on the collider types used; mesh colliders are more precise but costlier than primitive colliders.

2

Particles can be set to collide in 3D or 2D modes, but mixing modes in one system can cause unexpected results.

3

The order of collision events is not guaranteed, so relying on event sequence for logic can cause bugs.

When NOT to use

Particle collision is not suitable for simulating complex physics interactions like rigid body dynamics or fluid simulations. For those, use Unity's physics engine directly with rigidbodies or specialized fluid simulation tools.

Production Patterns

In production, particle collision is often combined with layers and tags to limit collisions only to relevant objects, improving performance. Developers use collision events to trigger sound effects or spawn secondary particle systems for impact effects. Optimizing collision quality and max collision events per frame is common to balance visuals and performance on different devices.

Connections

Physics Engine

Particle collision builds on the physics engine's collision detection system.

Understanding how the physics engine detects collisions helps grasp how particle collisions are checked and why performance matters.

Event-driven Programming

Particle collision events use event-driven patterns to notify scripts of collisions.

Knowing event-driven programming clarifies how collision messages trigger custom game logic asynchronously.

Molecular Collisions in Chemistry

Both involve many small particles interacting and bouncing off each other or surfaces.

Studying molecular collisions helps understand how many small objects can collide and react, similar to particle systems in games.

Common Pitfalls

#1 Particles do not collide because collision layers are not set correctly.

Wrong approach:

Collision module enabled but default layer mask left empty or incorrect.
// No collisions happen

Correct approach:

Set collision module's 'Collides With' layer mask to include layers of objects to collide with.
// Particles collide as expected

Root cause:

Misunderstanding that collision requires explicit layer settings to detect objects.

#2 Enabling high collision quality with thousands of particles causes frame rate drops.

Wrong approach:

Collision quality set to 'High' with 10,000 particles active.
// Game lags severely

Correct approach:

Use 'Medium' or 'Low' collision quality and reduce max collision events per frame.
// Smooth performance maintained

Root cause:

Not realizing collision checks are expensive and scale with particle count.

#3 Expecting particles to physically push rigidbodies on collision by default.

Wrong approach:

Assuming particle collision moves rigidbodies without extra scripting.
// No physical push occurs

Correct approach:

Use collision events to apply forces to rigidbodies manually in scripts.
// Rigidbody reacts to particle impact

Root cause:

Confusing visual collision with physics interaction; particle collision does not apply forces automatically.

Key Takeaways

Particle collision in Unity makes visual effects interact realistically with the environment by detecting when particles hit objects.

Collision behavior is controlled by settings like bounce, lifetime loss, and collision layers to customize how particles react.

Collision events can trigger scripts, enabling particles to influence gameplay beyond visuals.

Balancing collision quality and performance is crucial for smooth game experience with many particles.

Advanced users can override default collision responses with custom scripts for unique and complex effects.