Classes
- 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Use this attribute on a class, method, or property to inform the IL2CPP code conversion utility to override the global setting for one of a few different runtime checks.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Implements a simple behavior tree.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Example of how to handle off-mesh link traversal.
 - 
                
            
            
Helper script in the example scene 'Turn Based'.
 - 
                
            
            
Smooth Camera Following.
 - 
                
            
            
Moves an object along a spline.
 - 
                
            
            
Example script used in the example scenes.
 - 
                
            
            
 - 
                
            
            
RVO Example Scene Unit Controller.
 - 
                
            
            
Helper script in the example scene 'Turn Based'.
 - 
                
            
            
Lightweight RVO Circle Example.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
RichAI for local space (pathfinding on moving graphs).
 - 
                
            
            
Player controlled character which RVO agents will avoid.
 - 
                
            
            
Example of how to use Mecanim with the included movement scripts.
 - 
                
            
            
AI controller specifically made for the spider robot.
 - 
                
            
            
Animation helper specifically made for the spider robot in the example scenes.
 - 
                
            
            
Small sample script for placing obstacles.
 - 
                
            
            
Demos different path types.
 - 
                
            
            
Example script for generating an infinite procedural world.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Places ROV agents in circles.
 - 
                
            
            
Example movement script for using RVO.
 - 
                
            
            
Helper script in the example scene 'Turn Based'.
 - 
                
            
            
Helper script in the example scene 'Turn Based'.
 - 
                
            
            
Helper script in the example scene 'Turn Based'.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Calculates the grid connections for a set of nodes.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Calculates the grid connections for a single node.
 - 
                
            
            
 - 
                
            
            
result[i] = neither hit1[i] nor hit2[i] hit anything
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Disable the check that prevents jobs from including uninitialized native arrays open for reading.
 - 
                
            
            
Extension methods for IJob and related interfaces.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
result[i] &= data[i]
 - 
                
            
            
to[i] = from[i]
 - 
                
            
            
Copies hit points and normals.
 - 
                
            
            
Treats input as a rectangle and copies it into the output at the specified position.
 - 
                
            
            
Treats input as a rectangle 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.
 - 
                
            
            
Very simple list based on NativeList.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
AI for following paths.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Advanced AI for navmesh based graphs.
 - 
                
            
            
 - 
                
            
            
RVO Character Controller.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Local avoidance related classes.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Inspired by StarCraft 2's avoidance of locked units.
 - 
                
            
            
Inspired by StarCraft 2's avoidance of locked units.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Velocity Obstacle.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Exposes properties of an Agent class.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
ORCA Line.
 - 
                
            
            
One vertex in an obstacle.
 - 
                
            
            
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.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Square Obstacle for RVO Simulation.
 - 
                
            
            
Local Avoidance Simulator.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
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.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Holds settings for how graphs should be serialized.
 - 
                
            
            
A very tiny json deserializer.
 - 
                
            
            
A very tiny json serializer.
 - 
                
            
            
 - 
                
            
            
Lightweight Array Pool.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Calculates checksums of byte arrays.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Some editor gui helper methods.
 - 
                
            
            
 - 
                
            
            
Defines a transformation from graph space to world space.
 - 
                
            
            
Holds a lookup datastructure to quickly find objects inside rectangles.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Simple implementation of a GUID.
 - 
                
            
            
 - 
                
            
            
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.
 - 
                
            
            
 - 
                
            
            
Like Pathfinding.Util.GraphTransform, but mutable.
 - 
                
            
            
Combines hashes into a single hash value.
 - 
                
            
            
Lightweight object Pool for IAstarPooledObject.
 - 
                
            
            
Lightweight object Pool.
 - 
                
            
            
Helper for parallelizing tasks.
 - 
                
            
            
Interpolates along a sequence of points.
 - 
                
            
            
Prevents code stripping.
 - 
                
            
            
 - 
                
            
            
Lightweight Stack Pool.
 - 
                
            
            
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.
 - 
                
            
            
 - 
                
            
            
CompactVoxelCell used for recast graphs.
 - 
                
            
            
CompactVoxelSpan used for recast graphs.
 - 
                
            
            
Utility for clipping polygons.
 - 
                
            
            
 - 
                
            
            
Represents a mesh which will be rasterized.
 - 
                
            
            
Various utilities for voxel rasterization.
 - 
                
            
            
Stores a voxel field.
 - 
                
            
            
VoxelCell used for recast graphs.
 - 
                
            
            
VoxelContour used for recast graphs.
 - 
                
            
            
VoxelContourSet used for recast graphs.
 - 
                
            
            
Voxelizer for recast graphs.
 - 
                
            
            
VoxelMesh used for recast graphs.
 - 
                
            
            
Utility for clipping polygons.
 - 
                
            
            
VoxelSpan used for recast graphs.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
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.
 - 
                
            
            
 - 
                
            
            
Axis Aligned Bounding Box Tree.
 - 
                
            
            
 - 
                
            
            
Binary heap implementation.
 - 
                
            
            
Item in the heap.
 - 
                
            
            
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.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Helper for drawing debug information for the recast graph.
 - 
                
            
            
Convenience class to access the default implementation of the ITraversalProvider.
 - 
                
            
            
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.
 - 
                
            
            
Target is found when the path is longer than a specified value.
 - 
                
            
            
Ending condition which stops a fixed distance from the target point.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Implements heuristic optimizations.
 - 
                
            
            
Editor helper for hiding and showing a group of GUI elements.
 - 
                
            
            
Returns a path heading away from a specified point to avoid.
 - 
                
            
            
Floods the area completely for easy computation of any path to a single point.
 - 
                
            
            
Restrict suitable nodes by if they have been searched by a FloodPath.
 - 
                
            
            
Traces a path created with the Pathfinding.FloodPath.
 - 
                
            
            
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.
 - 
                
            
            
Handles collision checking for graphs.
 - 
                
            
            
 - 
                
            
            
Defined here only so non-editor classes can use the target field.
 - 
                
            
            
Returned by graph ray- or linecasts containing info about the 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.
 - 
                
            
            
Helper for iterating through the nodes that should be updated.
 - 
                
            
            
Job for applying a graph update object.
 - 
                
            
            
 - 
                
            
            
Holds a single update that needs to be performed on a graph.
 - 
                
            
            
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.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Used for using a texture as a source for a grid graph.
 - 
                
            
            
 - 
                
            
            
Custom rule for a grid graph.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Container for all rules in a grid graph.
 - 
                
            
            
Context for when scanning or updating a graph.
 - 
                
            
            
Node used for the GridGraph.
 - 
                
            
            
Base class for GridNode and LevelGridNode.
 - 
                
            
            
Simple GUI utility functions.
 - 
                
            
            
Holds a hierarchical graph to speed up certain pathfinding queries.
 - 
                
            
            
Common interface for all movement scripts in the A* Pathfinding Project.
 - 
                
            
            
Exposes internal methods for graphs.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Interface for something that holds a triangle based navmesh.
 - 
                
            
            
Two Dimensional Integer Coordinate Pair.
 - 
                
            
            
Holds a coordinate in integers.
 - 
                
            
            
Integer bounding box.
 - 
                
            
            
Integer Rectangle.
 - 
                
            
            
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.
 - 
                
            
            
Struct returned by SampleHeights.
 - 
                
            
            
Sorts RaycastHits by distance.
 - 
                
            
            
 - 
                
            
            
GraphUpdateObject with more settings for the LayerGridGraph.
 - 
                
            
            
Describes a single node for the LayerGridGraph.
 - 
                
            
            
Helper for Pathfinding.Examples.LocalSpaceRichAI.
 - 
                
            
            
 - 
                
            
            
Base class for path modifiers which can be attached to GameObjects.
 - 
                
            
            
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.
 - 
                
            
            
 - 
                
            
            
Generates graphs based on navmeshes.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Helper for navmesh cut objects.
 - 
                
            
            
Stores navmesh cutting related data for a single graph.
 - 
                
            
            
Nearest node constraint.
 - 
                
            
            
Result of a nearest node query.
 - 
                
            
            
Internal result of a nearest node query.
 - 
                
            
            
Connects two nodes with a direct connection.
 - 
                
            
            
Connects two nodes via two intermediate point nodes.
 - 
                
            
            
Connects two TriangleMeshNodes (recast/navmesh graphs) as if they had shared an edge.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Helper for enabling or disabling compiler directives.
 - 
                
            
            
 - 
                
            
            
Base class for all path types.
 - 
                
            
            
Customized ending condition for a path.
 - 
                
            
            
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.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
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 graph to follow a target.
 - 
                
            
            
 - 
                
            
            
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.
 - 
                
            
            
 - 
                
            
            
Axis Aligned Bounding Box Tree.
 - 
                
            
            
 - 
                
            
            
Automatically generates navmesh graphs based on world geometry.
 - 
                
            
            
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.
 - 
                
            
            
Pruning of recast navmesh regions.
 - 
                
            
            
Advanced AI for navmesh based graphs.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Applies penalty based on the slope of the surface below the node.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Applies penalty based on the elevation of the node.
 - 
                
            
            
 - 
                
            
            
Editor for Pathfinding.RuleElevationPenalty.
 - 
                
            
            
Modifies nodes based on the layer of the surface under the node.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Modifies nodes based on the contents of a texture.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
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.
 - 
                
            
            
Queue of paths to be processed by the system.
 - 
                
            
            
 - 
                
            
            
Helper for navmesh cut objects.
 - 
                
            
            
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.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Simple bezier curve editor.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Builder for drawing commands.
 - 
                
            
            
Holds rendering data for a box.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Holds rendering data for a circle.
 - 
                
            
            
Holds rendering data for a circle.
 - 
                
            
            
Holds rendering data for a line.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Helper for drawing Gizmos in a performant way.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Combines hashes into a single hash value.
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
 - 
                
            
            
Global script which draws debug items and gizmos.
 - 
                
            
            
 - 
                
            
            
Various high-level utilities that are useful when drawing things.
 - 
                
            
            
Info about the current selection in the editor.
 - 
                
            
            
Every object that wants to draw gizmos should implement this interface.
 - 
                
            
            
Inherit from this class to draw gizmos.
 - 
                
            
            
 - 
                
            
            
Compatibility code for handling different versions of the Unity.Collections package.
 - 
                
            
            
Core component for the A* Pathfinding System.
 -