NavMesh baking in Unity - Deep Dive

Overview - NavMesh baking

What is it?

NavMesh baking is the process of creating a navigation mesh in a 3D game environment using Unity. This mesh represents walkable surfaces where characters or agents can move. Baking analyzes the scene's geometry and generates data that AI agents use to find paths and avoid obstacles. It turns complex level shapes into simple, navigable areas.

Why it matters

Without NavMesh baking, AI characters would not know where they can walk or how to avoid obstacles, making movement unrealistic or impossible. It solves the problem of pathfinding in complex 3D spaces, allowing games to have intelligent, smooth navigation. Without it, developers would have to manually code paths or use inefficient methods, increasing workload and reducing game quality.

Where it fits

Before learning NavMesh baking, you should understand basic Unity scene setup and 3D geometry concepts. After mastering baking, you can learn about AI pathfinding, agent movement scripts, and dynamic obstacle avoidance to create responsive game characters.

Mental Model

Core Idea

NavMesh baking converts a game scene's walkable surfaces into a simplified map that AI agents use to navigate smoothly and avoid obstacles.

Think of it like...

It's like drawing a map of all the sidewalks and paths in a city so a delivery driver knows exactly where they can drive without hitting buildings or fences.

┌─────────────────────────────┐
│       Game Scene Geometry    │
│  (floors, walls, obstacles)  │
└──────────────┬──────────────┘
               │ Bake NavMesh
               ▼
┌─────────────────────────────┐
│      NavMesh Data (Mesh)     │
│  (walkable areas simplified) │
└──────────────┬──────────────┘
               │ Used by AI Agents
               ▼
┌─────────────────────────────┐
│     Agent Pathfinding &      │
│       Movement Logic         │
└─────────────────────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding Walkable Surfaces

Concept: Learn what surfaces in a game scene can be walked on and how they are identified.

In Unity, walkable surfaces are usually flat or gently sloped areas where characters can move. These include floors, ramps, and platforms. Surfaces that are too steep or marked as obstacles are not walkable. Identifying these surfaces is the first step before baking a NavMesh.

Result

You can visually recognize which parts of your scene agents should be able to walk on.

Knowing what counts as walkable helps you prepare your scene correctly for NavMesh baking and avoid navigation errors.

2

Foundation

Setting Up Navigation Static Objects

Concept: Marking objects in the scene as static for navigation to include them in NavMesh baking.

In Unity, objects must be marked as 'Navigation Static' to be considered during NavMesh baking. This tells the system these objects won't move and should be part of the navigation data. You do this by selecting objects and enabling the Navigation Static checkbox in the Inspector.

Result

Only marked objects are included in the NavMesh calculation, improving performance and accuracy.

Understanding static marking prevents unnecessary objects from bloating the NavMesh and causing navigation issues.

3

Intermediate

Configuring NavMesh Bake Settings

🤔Before reading on: do you think increasing agent radius makes paths narrower or wider? Commit to your answer.

Concept: Adjusting parameters like agent size, slope, and step height to control how the NavMesh is generated.

Unity's NavMesh baking settings let you define the agent's radius (how wide it is), height, max slope it can climb, and max step height it can overcome. These settings affect which surfaces are considered walkable and how close agents can get to obstacles. For example, a larger radius means wider paths are needed.

Result

The baked NavMesh matches the physical capabilities of your agents, ensuring realistic navigation.

Knowing how these settings affect the NavMesh helps you tailor navigation to different agent types and avoid unreachable areas.

4

Intermediate

Using NavMesh Areas and Costs

🤔Before reading on: do you think NavMesh areas can affect pathfinding speed or just path shape? Commit to your answer.

Concept: Assigning different areas in the NavMesh with costs to influence agent path choices.

NavMesh areas let you mark parts of the NavMesh with different types like 'Walkable', 'Not Walkable', or custom areas like 'Water' or 'Road'. Each area can have a cost value that makes agents prefer or avoid it. For example, agents might avoid high-cost areas even if they are shorter paths.

Result

Agents choose paths based on area costs, allowing more natural and strategic movement.

Understanding area costs lets you guide agent behavior without hardcoding paths, making AI smarter and more flexible.

5

Intermediate

Baking the NavMesh in Unity Editor

Concept: The actual process of generating the NavMesh using Unity's Navigation window.

Open the Navigation window in Unity, go to the Bake tab, and click 'Bake'. Unity analyzes all Navigation Static objects and applies your settings to create the NavMesh. The result is visible as a blue overlay showing walkable areas. You can rebake anytime after scene changes.

Result

A visual NavMesh appears in the editor, ready for AI agents to use.

Seeing the NavMesh overlay helps you verify navigation areas and catch issues early.

6

Advanced

Handling Dynamic Obstacles with NavMesh Obstacle

🤔Before reading on: do you think baked NavMesh updates automatically when obstacles move? Commit to your answer.

Concept: Using NavMesh Obstacle components to block or carve out areas dynamically at runtime.

NavMesh baking creates static navigation data, but games often have moving obstacles. Unity's NavMesh Obstacle component can carve holes in the NavMesh at runtime where obstacles move, so agents avoid those areas. This allows dynamic changes without rebaking the whole NavMesh.

Result

Agents dynamically avoid moving obstacles, improving realism.

Knowing how to combine static baking with dynamic carving enables flexible navigation in changing environments.

7

Expert

Optimizing NavMesh for Large Complex Scenes

🤔Before reading on: do you think baking one huge NavMesh or multiple smaller NavMeshes is better for performance? Commit to your answer.

Concept: Techniques to improve baking time and runtime performance by splitting NavMeshes and using NavMesh surfaces.

For large scenes, baking one NavMesh can be slow and memory-heavy. Unity allows splitting the scene into multiple NavMesh Surfaces, each baked separately. This reduces bake time and lets agents query smaller areas, improving runtime efficiency. Also, adjusting voxel size and tile size balances detail and performance.

Result

Faster baking and smoother agent navigation in big, complex levels.

Understanding NavMesh segmentation and parameter tuning is key to scaling navigation in professional games.

Under the Hood

NavMesh baking works by scanning the 3D scene geometry marked as navigation static. It voxelizes the space into small cubes, then analyzes which voxels are walkable based on agent parameters like height and radius. It connects these voxels into polygons forming the NavMesh. At runtime, agents use this mesh to calculate shortest paths using algorithms like A*.

Why designed this way?

This approach balances accuracy and performance. Voxelization simplifies complex geometry into manageable data. Baking ahead of time avoids costly calculations during gameplay. Dynamic obstacles are handled separately to keep the baked mesh static and efficient. Alternatives like real-time navigation meshes were too slow for most games when Unity designed this.

┌───────────────┐
│ Scene Geometry│
│ (Static Mesh) │
└──────┬────────┘
       │ Voxelize space
       ▼
┌───────────────┐
│ Voxel Grid    │
│ (Walkable or  │
│  blocked voxels)
└──────┬────────┘
       │ Connect voxels
       ▼
┌───────────────┐
│ NavMesh Polys │
│ (Simplified   │
│  navigation)  │
└──────┬────────┘
       │ Used by AI
       ▼
┌───────────────┐
│ Pathfinding   │
│ (A* algorithm)│
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does NavMesh baking automatically update when you move objects at runtime? Commit yes or no.

Common Belief: NavMesh baking updates automatically whenever objects move in the game.

Reality: NavMesh baking is a static process done in the editor; it does not update at runtime when objects move unless you use special components like NavMesh Obstacle for dynamic carving.

Why it matters: Assuming automatic updates leads to agents walking through moved obstacles, causing unrealistic or broken navigation.

Quick: Do you think all objects in the scene are included in the NavMesh by default? Commit yes or no.

Common Belief: All objects in the scene are included in the NavMesh baking by default.

Reality: Only objects marked as Navigation Static are included in the NavMesh baking process.

Why it matters: Not marking objects correctly can cause missing walkable areas or unexpected navigation holes.

Quick: Does increasing agent radius make paths narrower or wider? Commit your answer.

Common Belief: Increasing the agent radius makes paths narrower because the agent takes up more space.

Reality: Increasing agent radius actually makes paths narrower because the NavMesh excludes areas too close to obstacles to fit the larger agent.

Why it matters: Misunderstanding this can cause agents to get stuck or paths to be blocked unexpectedly.

Quick: Can NavMesh areas only mark walkable vs non-walkable? Commit yes or no.

Common Belief: NavMesh areas only mark whether a surface is walkable or not.

Reality: NavMesh areas can have different costs, influencing pathfinding preferences, not just walkability.

Why it matters: Ignoring area costs limits AI behavior customization and can make navigation less natural.

Expert Zone

1

NavMesh baking voxel size affects both detail and performance; smaller voxels increase accuracy but slow baking and runtime queries.

2

NavMesh surfaces can be layered and combined to support multi-level navigation, like bridges or stairs, which requires careful setup to avoid navigation errors.

3

Dynamic carving with NavMesh Obstacle can cause performance hits if overused; balancing static baking and dynamic updates is critical for smooth gameplay.

When NOT to use

NavMesh baking is not suitable for highly dynamic or destructible environments where geometry changes constantly; in such cases, runtime pathfinding or grid-based navigation systems like A* grids or waypoint graphs are better alternatives.

Production Patterns

In production, developers split large scenes into multiple NavMesh Surfaces for modular baking, use area costs to guide AI behavior (e.g., prefer roads over grass), and combine NavMesh baking with runtime obstacle carving for dynamic gameplay elements like moving platforms or doors.

Connections

Graph Theory

NavMesh polygons form a graph where nodes are polygons and edges connect walkable neighbors.

Understanding graph traversal algorithms like A* helps grasp how agents find paths on the NavMesh.

Voxelization in 3D Graphics

NavMesh baking uses voxelization to simplify complex geometry into manageable blocks.

Knowing voxelization principles clarifies how NavMesh converts detailed scenes into navigation data efficiently.

Urban Planning

Designing walkable paths in a city is similar to creating a NavMesh for AI navigation.

Recognizing this connection helps appreciate how navigation meshes model real-world movement constraints.

Common Pitfalls

#1 Forgetting to mark objects as Navigation Static causes them to be excluded from NavMesh baking.

Wrong approach:

GameObject floorObject; // Not marked as Navigation Static
// Bake NavMesh
// Result: floor not included in NavMesh

Correct approach:

GameObject floorObject; // Marked as Navigation Static in Inspector
// Bake NavMesh
// Result: floor included in NavMesh

Root cause:

Misunderstanding that only static objects are considered during baking leads to missing navigation areas.

#2 Setting agent radius too small causes agents to walk unrealistically close to obstacles and get stuck.

Wrong approach:

NavMeshAgent.radius = 0.1f; // Too small for agent size
// Agents clip through walls or get stuck

Correct approach:

NavMeshAgent.radius = 0.5f; // Matches physical agent size
// Agents navigate smoothly avoiding obstacles

Root cause:

Ignoring physical size of agents when configuring NavMesh parameters causes navigation errors.

#3 Expecting NavMesh to update automatically when moving obstacles without using NavMesh Obstacle component.

Wrong approach:

// Move obstacle at runtime
obstacle.transform.position = newPosition;
// NavMesh does not update
// Agents walk through obstacle

Correct approach:

// Add NavMeshObstacle component to obstacle
// Move obstacle at runtime
obstacle.transform.position = newPosition;
// NavMesh carves hole dynamically
// Agents avoid obstacle

Root cause:

Not using dynamic carving features leads to static navigation data that doesn't reflect runtime changes.

Key Takeaways

NavMesh baking creates a simplified map of walkable areas in a game scene for AI navigation.

Only objects marked as Navigation Static are included in the baking process, ensuring efficient and accurate navigation data.

Agent parameters like radius and height directly influence the shape and size of the NavMesh paths.

NavMesh areas with costs allow nuanced AI path choices beyond simple walkability.

Dynamic obstacles require special components to update navigation at runtime without rebaking.