Classes
- 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Index of an RVO agent in the local avoidance simulation.
 - 
                
            
            
Agent data for the local avoidance system.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
An agent's shape represented as a cylinder.
 - 
                
            
            
Holds an agent's movement plane.
 - 
                
            
            
The movement plane source for an agent.
 - 
                
            
            
Holds unmanaged information about an off-mesh link that the agent is currently traversing.
 - 
                
            
            
Context with helpers for traversing an off-mesh link.
 - 
                
            
            
Thrown when the off-mesh link traversal should be aborted.
 - 
                
            
            
 - 
                
            
            
Rate manager which runs a system group multiple times if the delta time is higher than desired, but always executes the group at least once per frame.
 - 
                
            
            
 - 
                
            
            
Policy for how often to recalculate an agent's path.
 - 
                
            
            
Wrapper for a pointer.
 - 
                
            
            
Holds an agent's destination point.
 - 
                
            
            
 - 
                
            
            
Utility for efficient random access to entity component data from the main thread.
 - 
                
            
            
Helper for EntityAccess.
 - 
                
            
            
Utility for efficient random access to entity storage data from the main thread.
 - 
                
            
            
Copies MovementControl to ResolvedMovement when no local avoidance is used.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Agent state related to gravity.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Repairs the path of agents.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Holds managed information about an off-mesh link that the agent is currently traversing.
 - 
                
            
            
Utility for efficient random access to managed entity component data from the main thread.
 - 
                
            
            
Stores a delegate that can be used to override movement control and movement settings for a specific entity.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Helper for adding and removing hooks to the FollowerEntity component.
 - 
                
            
            
Settings for agent movement that cannot be put anywhere else.
 - 
                
            
            
Desired movement for an agent.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Tag component to indicate that the agent's forward direction is along the Y axis.
 - 
                
            
            
Checks if paths have been calculated, and updates the agent's paths if they have.
 - 
                
            
            
Enabled if the agnet is ready to start traversing an off-mesh link.
 - 
                
            
            
Holds the final movement data for an entity.
 - 
                
            
            
 - 
                
            
            
Tag component to enable movement for an entity.
 - 
                
            
            
Tag component to allow the agent to calculate how it wants to move.
 - 
                
            
            
Tag component to allow the agent to move according to its desired movement parameters.
 - 
                
            
            
Tag component to allow the agent to repair its path and recalculate various statistics.
 - 
                
            
            
 - 
                
            
            
Tag component to enable syncing between an agent's Transform and the agent entity's position.
 - 
                
            
            
Tag component to enable syncing between an agent's Transform and the agent entity's rotation.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Allocates and deallocates nodes in a grid graph.
 - 
                
            
            
Calculates the grid connections for all nodes.
 - 
                
            
            
Checks if nodes are obstructed by obstacles or not.
 - 
                
            
            
Fills the output with true or false depending on if the collider hit was a hit.
 - 
                
            
            
Copies 3D arrays with grid data from one shape to another.
 - 
                
            
            
Calculates erosion.
 - 
                
            
            
Filters out diagonal connections that are not allowed in layered grid graphs.
 - 
                
            
            
Calculates if either of the two input hits actually hit something.
 - 
                
            
            
Calculates the default node positions for a grid graph.
 - 
                
            
            
Calculates for each grid node if it should be walkable or not.
 - 
                
            
            
Prepares a set of capsule commands for collision checking in a grid graph.
 - 
                
            
            
Prepares a set of raycast commands for a grid graph.
 - 
                
            
            
Prepares a set of raycast commands for a grid graph.
 - 
                
            
            
Prepares a set of sphere commands for collision checking in a grid graph.
 - 
                
            
            
Reads node data from managed GridNodeBase objects into unmanaged arrays.
 - 
                
            
            
 - 
                
            
            
Writes node data from unmanaged arrays into managed GridNodeBase objects.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Custom rule for a grid graph.
 - 
                
            
            
Container for all rules in a grid graph.
 - 
                
            
            
Context for when scanning or updating a graph.
 - 
                
            
            
Common interface for all grid graph rule editors.
 - 
                
            
            
Applies penalty based on the slope of the surface below the node.
 - 
                
            
            
 - 
                
            
            
Applies penalty based on the elevation of the node.
 - 
                
            
            
 - 
                
            
            
Modifies nodes based on the layer of the surface under the node.
 - 
                
            
            
 - 
                
            
            
Modifies nodes based on the contents of a texture.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Handles collision checking for graphs.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Helpers for iterating over grid graph data.
 - 
                
            
            
Callback struct for ForEachCellIn3DArray.
 - 
                
            
            
Helper interface for modifying node connections.
 - 
                
            
            
Helper interface for modifying nodes.
 - 
                
            
            
Callback struct for ForEachCellIn3DSlice.
 - 
                
            
            
Callback struct for ForEachCellIn3DSlice.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Builds nodes and tiles and prepares them for pathfinding.
 - 
                
            
            
 - 
                
            
            
Builds tiles from raw mesh vertices and indices.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Builds tiles from a polygon soup using voxelization.
 - 
                
            
            
Calculates node connections between triangles within each tile.
 - 
                
            
            
 - 
                
            
            
Connects adjacent tiles together.
 - 
                
            
            
Connects two adjacent tiles together.
 - 
                
            
            
Convert recast region IDs to the tags that should be applied to the nodes.
 - 
                
            
            
Builds tiles optimized for pathfinding, from a list of TileMesh.TileMeshUnsafe.
 - 
                
            
            
Transforms vertices from voxel coordinates to tile coordinates.
 - 
                
            
            
Writes connections to each node in each tile.
 - 
                
            
            
Scratch space for building navmesh tiles using voxelization.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
CompactVoxelCell used for recast graphs.
 - 
                
            
            
Stores a compact voxel field.
 - 
                
            
            
CompactVoxelSpan used for recast graphs.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Builds a polygon mesh from a contour set.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
VoxelContour used for recast graphs.
 - 
                
            
            
VoxelMesh used for recast graphs.
 - 
                
            
            
 - 
                
            
            
Utility for clipping polygons.
 - 
                
            
            
Utility for clipping polygons.
 - 
                
            
            
Axis Aligned Bounding Box Tree.
 - 
                
            
            
 - 
                
            
            
A key to a leaf node in the tree.
 - 
                
            
            
 - 
                
            
            
Axis Aligned Bounding Box Tree.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
A single tile in a recast or navmesh graph.
 - 
                
            
            
Helper for navmesh cut objects.
 - 
                
            
            
Stores navmesh cutting related data for a single graph.
 - 
                
            
            
Helper methods for scanning a recast graph.
 - 
                
            
            
 - 
                
            
            
Holds info about a mesh to be rasterized.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Pruning of recast navmesh regions.
 - 
                
            
            
Settings for building tile meshes in a recast graph.
 - 
                
            
            
A mapping from tiles to the meshes that each tile touches.
 - 
                
            
            
 - 
                
            
            
Utility class for updating tiles of navmesh/recast graphs.
 - 
                
            
            
Internal class describing a single NavmeshCut.
 - 
                
            
            
Internal class representing a mesh which is the result of the CutPoly method.
 - 
                
            
            
A template for a single tile in a navmesh/recast graph.
 - 
                
            
            
Represents the position and size of a tile grid for a recast/navmesh graph.
 - 
                
            
            
A tile in a navmesh graph.
 - 
                
            
            
Unsafe version of TileMesh.
 - 
                
            
            
Represents a rectangular group of tiles of a recast graph.
 - 
                
            
            
Unsafe representation of a TileMeshes struct.
 - 
                
            
            
 - 
                
            
            
Implements heuristic optimizations.
 - 
                
            
            
 - 
                
            
            
Holds a lookup datastructure to quickly find objects inside rectangles.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Disable the check that prevents jobs from including uninitialized native arrays open for reading.
 - 
                
            
            
Convenient collection of items that can be disposed together.
 - 
                
            
            
 - 
                
            
            
Extension methods for IJob and related interfaces.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
result[i] &= data[i]
 - 
                
            
            
to[i] = from[i]
 - 
                
            
            
Copies hit points and normals.
 - 
                
            
            
Treats input as a 3-dimensional array and copies it into the output at the specified position.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Automatic dependency tracking for the Unity Job System.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
result[i] = value
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Helpers for scheduling simple NativeArray jobs.
 - 
                
            
            
A simple read/write lock for use with the Unity Job System.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Slice of a 3D array.
 - 
                
            
            
 - 
                
            
            
Spin lock which can be used in Burst.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Implements a PID controller for the angular velocity of an agent following a curve.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Core control loop for the FollowerEntity movement script.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Local avoidance related classes.
 - 
                
            
            
 - 
                
            
            
Exposes properties of an Agent class.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Calculates if the agent has reached the end of its path and if its blocked from further progress towards it.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Inspired by StarCraft 2's avoidance of locked units.
 - 
                
            
            
Inspired by StarCraft 2's avoidance of locked units.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
A half-plane defined as the line splitting plane.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
RVO Character Controller.
 - 
                
            
            
 - 
                
            
            
Controls if the agent slows down to a stop if the area around the destination is crowded.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Adds a navmesh as RVO obstacles.
 - 
                
            
            
Base class for simple RVO colliders.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Quadtree for quick nearest neighbour search of rvo agents.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Unity front end for an RVO simulator.
 - 
                
            
            
Square Obstacle for RVO Simulation.
 - 
                
            
            
Local Avoidance Simulator.
 - 
                
            
            
 - 
                
            
            
Holds internal agent data for the local avoidance simulation.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Holds internal obstacle data for the local avoidance simulation.
 - 
                
            
            
 - 
                
            
            
Represents a set of obstacles.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Handles low level serialization and deserialization of graph settings and data.
 - 
                
            
            
Metadata for all graphs included in serialization.
 - 
                
            
            
Holds information passed to custom graph serializers.
 - 
                
            
            
 - 
                
            
            
Indicates that the full type of the instance will always be serialized.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Helper struct for handling serialization backwards compatibility.
 - 
                
            
            
 - 
                
            
            
Holds settings for how graphs should be serialized.
 - 
                
            
            
A very tiny json deserializer.
 - 
                
            
            
A very tiny json serializer.
 - 
                
            
            
 - 
                
            
            
Lightweight Array Pool.
 - 
                
            
            
Helper for batching updates to many objects efficiently.
 - 
                
            
            
 - 
                
            
            
Calculates checksums of byte arrays.
 - 
                
            
            
Implements an efficient circular buffer that can be appended to in both directions.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Some editor gui helper methods.
 - 
                
            
            
 - 
                
            
            
A snapshot of parts of graphs.
 - 
                
            
            
Defines a transformation from graph space to world space.
 - 
                
            
            
Simple implementation of a GUID.
 - 
                
            
            
Thread-safe hierarchical bitset.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Used by Pathfinding.Util.BatchedEvents.
 - 
                
            
            
 - 
                
            
            
Transforms to and from world space to a 2D movement plane.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Generic 3D coordinate transformation.
 - 
                
            
            
Extension methods for List<T>
 - 
                
            
            
Lightweight List Pool.
 - 
                
            
            
Various utilities for handling arrays and memory.
 - 
                
            
            
Helper class for working with meshes efficiently.
 - 
                
            
            
Removes duplicate vertices from the array and updates the triangle array.
 - 
                
            
            
 - 
                
            
            
Like Pathfinding.Util.GraphTransform, but mutable.
 - 
                
            
            
Implements an efficient circular buffer that can be appended to in both directions.
 - 
                
            
            
A variant of SimpleMovementPlane that can be passed to burst functions.
 - 
                
            
            
Combines hashes into a single hash value.
 - 
                
            
            
Lightweight object Pool for IAstarPooledObject.
 - 
                
            
            
Lightweight object Pool.
 - 
                
            
            
Interpolates along a sequence of points.
 - 
                
            
            
Represents a single point on the polyline represented by the PathInterpolator.
 - 
                
            
            
Represents a part of a path, with optional link information.
 - 
                
            
            
Prevents code stripping.
 - 
                
            
            
A promise that T is being calculated asynchronously.
 - 
                
            
            
Represents the orientation of a plane.
 - 
                
            
            
A tiny slab allocator.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Lightweight Stack Pool.
 - 
                
            
            
A matrix wrapper which can be used to project points from world space to a movement plane.
 - 
                
            
            
A matrix wrapper which can be used to project points from a movement plane to world space.
 - 
                
            
            
Compatibility class for Unity APIs that are not available in all Unity versions.
 - 
                
            
            
Replacement for System.Span which is compatible with earlier versions of C#.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Basic path, finds the shortest path from A to B.
 - 
                
            
            
Ending condition which emulates the default one for the ABPath.
 - 
                
            
            
Smoothing by dividing path into turns and straight segments.
 - 
                
            
            
Constant turning speed.
 - 
                
            
            
Type of turn.
 - 
                
            
            
Represents a turn in a path.
 - 
                
            
            
Abstract turn constructor.
 - 
                
            
            
Sets the destination of an AI to the position of a specified object.
 - 
                
            
            
 - 
                
            
            
Linearly interpolating movement script.
 - 
                
            
            
 - 
                
            
            
AI for following paths.
 - 
                
            
            
Movement script for curved worlds.
 - 
                
            
            
Applies penalty to the paths it processes telling other units to avoid choosing the same path.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Stores editor colors.
 - 
                
            
            
Stores the navigation graphs for the A* Pathfinding System.
 - 
                
            
            
Debugger for the A* Pathfinding Project.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Utility functions for working with numbers and strings.
 - 
                
            
            
 - 
                
            
            
Contains various spline functions.
 - 
                
            
            
Handles update checking for the A* Pathfinding Project.
 - 
                
            
            
 - 
                
            
            
An item of work that can be executed when graphs are safe to update.
 - 
                
            
            
Policy for how often to recalculate an agent's path.
 - 
                
            
            
 - 
                
            
            
Binary heap implementation.
 - 
                
            
            
Item in the heap.
 - 
                
            
            
Multi-producer-multi-consumer (MPMC) channel.
 - 
                
            
            
Allows receiving items from a channel.
 - 
                
            
            
Manager for blocker scripts such as SingleNodeBlocker.
 - 
                
            
            
Blocks nodes according to a BlockManager.
 - 
                
            
            
Represents a connection to another node.
 - 
                
            
            
Finds all nodes within a specified distance from the start.
 - 
                
            
            
Added to editors of custom graph types.
 - 
                
            
            
Convenience class to access the default implementation of the ITraversalProvider.
 - 
                
            
            
Determines how to measure distances to the navmesh.
 - 
                
            
            
Attach this script to any obstacle with a collider to enable dynamic updates of the graphs around it.
 - 
                
            
            
Helper for creating editors.
 - 
                
            
            
Handles fading effects and also some custom GUI functions such as LayerMaskField.
 - 
                
            
            
Internal utility class for looking up editor resources.
 - 
                
            
            
Target is found when the path is longer than a specified value.
 - 
                
            
            
Ending condition which stops a fixed distance from the target point.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Editor helper for hiding and showing a group of GUI elements.
 - 
                
            
            
 - 
                
            
            
Returns a path heading away from a specified point to avoid.
 - 
                
            
            
Calculates paths from everywhere to a single point.
 - 
                
            
            
Restrict suitable nodes by if they have been searched by a FloodPath.
 - 
                
            
            
Traces a path created with the Pathfinding.FloodPath.
 - 
                
            
            
Movement script that uses ECS.
 - 
                
            
            
 - 
                
            
            
Implements the funnel algorithm as well as various related methods.
 - 
                
            
            
Funnel in which the path to the target will be.
 - 
                
            
            
 - 
                
            
            
Part of a path.
 - 
                
            
            
Simplifies paths on navmesh graphs using the funnel algorithm.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Base class for all graph editors.
 - 
                
            
            
Info about what a ray- or linecasts hit.
 - 
                
            
            
Holds a bitmask of graphs.
 - 
                
            
            
 - 
                
            
            
GraphModifier is used for modifying graphs or processing graph data based on events.
 - 
                
            
            
Base class for all nodes.
 - 
                
            
            
Represents a collection of settings used to update nodes in a specific region of a graph.
 - 
                
            
            
Provides burst-readable data to a graph update job.
 - 
                
            
            
Job for applying a graph update object.
 - 
                
            
            
 - 
                
            
            
Helper class for easily updating graphs.
 - 
                
            
            
Editor for GraphUpdateScene.
 - 
                
            
            
Defines a shape for a Pathfinding.GraphUpdateObject.
 - 
                
            
            
Shape optimized for burst.
 - 
                
            
            
Contains useful functions for updating graphs.
 - 
                
            
            
Contains utility methods for getting useful information out of graph.
 - 
                
            
            
Generates a grid of nodes.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Reference to a nodes array to allow multiple serial updates to have a common reference to the nodes.
 - 
                
            
            
Used for using a texture as a source for a grid graph.
 - 
                
            
            
 - 
                
            
            
Information about a linecast hit on a grid graph.
 - 
                
            
            
Node used for the GridGraph.
 - 
                
            
            
Base class for GridNode and LevelGridNode.
 - 
                
            
            
Simplifies a path on a grid graph using a string pulling algorithm.
 - 
                
            
            
 - 
                
            
            
Simple GUI utility functions.
 - 
                
            
            
Calculates an estimated cost from the specified point to the target.
 - 
                
            
            
Holds a hierarchical graph to speed up certain pathfinding queries.
 - 
                
            
            
Burst-accessible data about the hierarhical nodes.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Common interface for all movement scripts in the A* Pathfinding Project.
 - 
                
            
            
Exposes internal methods for graphs.
 - 
                
            
            
Helper functions for graph updates.
 - 
                
            
            
Promise representing a graph update.
 - 
                
            
            
Interface for something that holds a triangle based navmesh.
 - 
                
            
            
Two Dimensional Integer Coordinate Pair.
 - 
                
            
            
Holds a coordinate in integers.
 - 
                
            
            
Integer bounding box.
 - 
                
            
            
Integer Rectangle.
 - 
                
            
            
Interface for handling off-mesh links.
 - 
                
            
            
 - 
                
            
            
Used for hiding internal methods of the Path class.
 - 
                
            
            
Base for all path modifiers.
 - 
                
            
            
Graph which supports the Linecast method.
 - 
                
            
            
Graph which has a well defined transformation from graph space to world space.
 - 
                
            
            
Provides additional traversal information to a path request.
 - 
                
            
            
Graphs which can be updated during runtime.
 - 
                
            
            
Exposes internal methods from Pathfinding.VersionedMonoBehaviour.
 - 
                
            
            
Interface to expose a subset of the WorkItemProcessor functionality.
 - 
                
            
            
Grid Graph, supports layered worlds.
 - 
                
            
            
 - 
                
            
            
Describes a single node for the LayerGridGraph.
 - 
                
            
            
Graph for off-mesh links.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Helper for Pathfinding.Examples.LocalSpaceRichAI.
 - 
                
            
            
 - 
                
            
            
Base class for path modifiers which can be attached to GameObjects.
 - 
                
            
            
Moves an agent in a circle around a point.
 - 
                
            
            
A path which searches from one point to a number of different targets in one search or from a number of different start points to a single target.
 - 
                
            
            
Base class for all graphs.
 - 
                
            
            
Adds new geometry to a recast graph.
 - 
                
            
            
 - 
                
            
            
Base class for RecastGraph and NavMeshGraph.
 - 
                
            
            
Attach to any GameObject and the object will be clamped to the navmesh.
 - 
                
            
            
Base class for the NavmeshCut and NavmeshAdd components.
 - 
                
            
            
Navmesh cutting is used for fast recast/navmesh graph updates.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Burst-accessible data about borders in the navmesh.
 - 
                
            
            
Generates graphs based on navmeshes.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Stores a set of navmesh tiles which can be placed on a recast graph.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Editor for the NavmeshPrefab component.
 - 
                
            
            
Nearest node constraint.
 - 
                
            
            
 - 
                
            
            
Result of a nearest node query.
 - 
                
            
            
Connects two nodes with a direct connection.
 - 
                
            
            
Connects two nodes using an off-mesh link.
 - 
                
            
            
 - 
                
            
            
Connects two TriangleMeshNodes (recast/navmesh graphs) as if they had shared an edge.
 - 
                
            
            
 - 
                
            
            
Manager for off-mesh links.
 - 
                
            
            
The start or end point of an off-mesh link.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Information about an off-mesh link.
 - 
                
            
            
Helper for enabling or disabling compiler directives.
 - 
                
            
            
 - 
                
            
            
Base class for all path types.
 - 
                
            
            
Parameters to OpenCandidateConnectionBurst.
 - 
                
            
            
Customized ending condition for a path.
 - 
                
            
            
 - 
                
            
            
Represents a single pathfinding tag.
 - 
                
            
            
 - 
                
            
            
Handles thread specific path data.
 - 
                
            
            
Base class for path modifiers which are not attached to GameObjects.
 - 
                
            
            
A special NNConstraint which can use different logic for the start node and end node in a path.
 - 
                
            
            
Stores temporary node data for a single pathfinding request.
 - 
                
            
            
Pools path objects to reduce load on the garbage collector.
 - 
                
            
            
 - 
                
            
            
Prevents pathfinding from running while held.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Helper for following a path.
 - 
                
            
            
 - 
                
            
            
Contains useful functions for working with paths and nodes.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Simple patrol behavior.
 - 
                
            
            
Basic point graph.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Represents a collection of GraphNodes.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Node used for the PointGraph.
 - 
                
            
            
Utility functions for working with polygons, lines, and other vector math.
 - 
                
            
            
Moves a grid or recast graph to follow a target.
 - 
                
            
            
This class has been renamed to ProceduralGraphMover.
 - 
                
            
            
 - 
                
            
            
Progress info for e.g a progressbar.
 - 
                
            
            
Radius path modifier for offsetting paths.
 - 
                
            
            
Finds a path in a random direction from the start node.
 - 
                
            
            
Simplifies a path using raycasting.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Automatically generates navmesh graphs based on world geometry.
 - 
                
            
            
Settings for which meshes/colliders and other objects to include in the graph.
 - 
                
            
            
Per layer modification settings.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Editor for the RecastGraph.
 - 
                
            
            
Explicit mesh object for recast graphs.
 - 
                
            
            
 - 
                
            
            
Updates the recast tile(s) it is in at start, needs RecastTileUpdateHandler.
 - 
                
            
            
Helper for easier fast updates to recast graphs.
 - 
                
            
            
Advanced AI for navmesh based graphs.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Editor for the RuleAnglePenalty rule.
 - 
                
            
            
Editor for the RuleElevationPenalty rule.
 - 
                
            
            
Editor for the RulePerLayerModifications rule.
 - 
                
            
            
Editor for the RuleTexture rule.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Handles path calls for a single unit.
 - 
                
            
            
 - 
                
            
            
Modifier which smooths the path.
 - 
                
            
            
Blocks single nodes in a graph.
 - 
                
            
            
 - 
                
            
            
Adjusts start and end points of a path.
 - 
                
            
            
Moves the target in example scenes.
 - 
                
            
            
 - 
                
            
            
Node represented by a triangle.
 - 
                
            
            
 - 
                
            
            
Helper class to keep track of references to GameObjects.
 - 
                
            
            
Various vector math utility functions.
 - 
                
            
            
Base class for all components in the package.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Similar to Queue<T> but allows random access.
 - 
                
            
            
Extended Path.
 - 
                
            
            
Core component for the A* Pathfinding System.
 -