Class RecastGraph Extends NavmeshBase, IUpdatableGraph

GraphTransform CalculateTransform ()

Returns a new transform which transforms graph space to world space.

Does not update the transform field.

void EnsureInitialized ()

Initialize the graph with empty tiles if it is not currently scanned.

bool IsInsideBounds (

Vector3

point

)

True if the point is inside the bounding box of this graph.

In 2D mode, the point is considered inside if it is contained along the graph's X and Z axes (Y is ignored). Note that the graph's X and Z axes are typically aligned with the world's X and Y axes when using 2D mode.

void ReplaceTiles (

TileMeshes	tileMeshes	The tiles to load. They will be loaded into the graph at the TileMeshes.tileRect tile coordinates.
float	yOffset=0	All vertices in the loaded tiles will be moved upwards (or downwards if negative) by this amount.

)

Load tiles from a TileMeshes object into this graph.

This can be used for many things, for example world streaming or placing large prefabs that have been pre-scanned.

The loaded tiles must have the same world-space size as this graph's tiles. The world-space size for a recast graph is given by the cellSize multiplied by tileSizeX (or tileSizeZ).

If the graph is not scanned when this method is called, the graph will be initialized and consist of just the tiles loaded by this call.

// Scans the first 6x6 chunk of tiles of the recast graph (the IntRect uses inclusive coordinates)
var graph = AstarPath.active.data.recastGraph;
var buildSettings = RecastBuilder.BuildTileMeshes(graph, new TileLayout(graph), new IntRect(0, 0, 5, 5));
var disposeArena = new Pathfinding.Jobs.DisposeArena();
var promise = buildSettings.Schedule(disposeArena);

AstarPath.active.AddWorkItem(() => {
// Block until the asynchronous job completes
var result = promise.Complete();
TileMeshes tiles = result.tileMeshes.ToManaged();
// Take the scanned tiles and place them in the graph,
// but not at their original location, but 2 tiles away, rotated 90 degrees.
tiles.tileRect = tiles.tileRect.Offset(new Int2(2, 0));
tiles.Rotate(1);
graph.ReplaceTiles(tiles);

// Dispose unmanaged data
disposeArena.DisposeAll();
result.Dispose();
});


void Resize (

IntRect

newTileBounds

Rectangle of tiles that the graph should contain. Relative to the old bounds.

)

Resize the number of tiles that this graph contains.

This can be used both to make a graph larger, smaller or move the bounds of the graph around. The new bounds are relative to the existing bounds which are IntRect(0, 0, tileCountX-1, tileCountZ-1).

Any current tiles that fall outside the new bounds will be removed. Any new tiles that did not exist inside the previous bounds will be created as empty tiles. All other tiles will be preserved. They will stay at their current world space positions.

AstarPath.active.AddWorkItem(() => {
var graph = AstarPath.active.data.recastGraph;
var currentBounds = new IntRect(0, 0, graph.tileXCount-1, graph.tileZCount-1);

// Make the graph twice as large, but discard the first 3 columns.
// All other tiles will be kept and stay at the same position in the world.
// The new tiles will be empty.
graph.Resize(new IntRect(3, 0, currentBounds.xmax*2, currentBounds.ymax*2));
});


void SnapBoundsToScene ()

Changes the bounds of the graph to precisely encapsulate all objects in the scene.

The bounds will be expanded to fit all objects in the scene which match the current scanning settings.

This method corresponds to the 'Snap bounds to scene' button in the inspector.

void SnapForceBoundsToScene ()

IGraphUpdatePromise TranslateInDirection (

int	dx	Number of tiles along the graph's X axis to move by.
int	dz	Number of tiles along the graph's Z axis to move by.

)

Moves the recast graph by a number of tiles, discarding old tiles and scanning new ones.

This is used by the ProceduralGraphMover component to efficiently move the graph.

All tiles that can stay in the same position will stay. The ones that would have fallen off the edge of the graph will be discarded, and new tiles will be created and scanned at the other side of the graph.

GraphTransform CalculateTransform (

Bounds	bounds
Quaternion	rotation

)

float MaxTileConnectionEdgeDistance

float NavmeshCuttingCharacterRadius

bool RecalculateNormals

float TileWorldSizeX

float TileWorldSizeZ

BackgroundTraversability backgroundTraversability = BackgroundTraversability.Walkable

Whether the base of the graph should default to being walkable or unwalkable.

This is only used in 2D mode. In 3D mode, this setting has no effect.

For 2D games, it can be very useful to set the background to be walkable by default, and then constrain walkability using colliders.

If you don't want to use a walkable background, you can instead create colliders and attach a RecastMeshObj with Surface Type set to Walkable Surface. These will then create walkable regions.

Bounds bounds

World bounding box for the graph.

This always contains the whole graph.

float cellSize = 0.5F

Voxel sample size (x,z).

When generating a recast graph what happens is that the world is voxelized. You can think of this as constructing an approximation of the world out of lots of boxes. If you have played Minecraft it looks very similar (but with smaller boxes). The cell size is the width and depth of those boxes. The height of the boxes is usually much smaller and automatically calculated, however.

Lower values will yield higher quality navmeshes, however the graph will be slower to scan.

float characterRadius = 1.5F

Radius of the agent which will traverse the navmesh.

The navmesh will be eroded with this radius.

CollectionSettings collectionSettings = new CollectionSettings()

Determines which objects are used to build the graph, when it is scanned.

Also contains some settings for how to convert objects into meshes. Spherical colliders, for example, need to be converted into a triangular mesh before they can be used in the graph.

float contourMaxError = 2F

Max distance from simplified edge to real edge.

This value is measured in voxels. So with the default value of 2 it means that the final navmesh contour may be at most 2 voxels (i.e 2 times cellSize) away from the border that was calculated when voxelizing the world. A higher value will yield a more simplified and cleaner navmesh while a lower value may capture more details. However a too low value will cause the individual voxels to be visible (see image below).

DimensionMode dimensionMode = DimensionMode.Dimension3D

Whether to use 3D or 2D mode.

int editorTileSize = 128

Size in voxels of a single tile.

This is the width of the tile.

A large tile size can be faster to initially scan (but beware of out of memory issues if you try with a too large tile size in a large world) smaller tile sizes are (much) faster to update.

Different tile sizes can affect the quality of paths. It is often good to split up huge open areas into several tiles for better quality paths, but too small tiles can also lead to effects looking like invisible obstacles. For more information about this take a look at Notes about navmesh graphs. Usually it is best to experiment and see what works best for your game.

When scanning a recast graphs individual tiles can be calculated in parallel which can make it much faster to scan large worlds. When you want to recalculate a part of a recast graph, this can only be done on a tile-by-tile basis which means that if you often try to update a region of the recast graph much smaller than the tile size, then you will be doing a lot of unnecessary calculations. However if you on the other hand update regions of the recast graph that are much larger than the tile size then it may be slower than necessary as there is some overhead in having lots of tiles instead of a few larger ones (not that much though).

Recommended values are between 64 and 256, but these are very soft limits. It is possible to use both larger and smaller values.

Vector3 forcedBoundsCenter

Center of the bounding box.

Scanning will only be done inside the bounding box

float maxEdgeLength = 20

Longer edges will be subdivided.

Reducing this value can sometimes improve path quality since similarly sized triangles yield better paths than really large and really triangles small next to each other. However it will also add a lot more nodes which will make pathfinding slower. For more information about this take a look at Notes about navmesh graphs.

float maxSlope = 30

Max slope in degrees the character can traverse.

List<(UnityEngine.Object, Mesh)> meshesUnreadableAtRuntime

Internal field used to warn users when the mesh includes meshes that are not readable at runtime.

float minRegionSize = 3

Minumum region size.

Small regions will be removed from the navmesh. Measured in voxels.

If a region is adjacent to a tile border, it will not be removed even though it is small since the adjacent tile might join it to form a larger region.

List<PerLayerModification> perLayerModifications = new List<PerLayerModification>()

List of rules that modify the graph based on the layer of the rasterized object.

By default, all layers are treated as walkable surfaces. But by adding rules to this list, one can for example make all surfaces with a specific layer get a specific pathfinding tag.

Each layer should be modified at most once in this list.

If an object has a RecastMeshObj component attached, the settings on that component will override the settings in this list.

RelevantGraphSurfaceMode relevantGraphSurfaceMode = RelevantGraphSurfaceMode.DoNotRequire

Require every region to have a RelevantGraphSurface component inside it.

A RelevantGraphSurface component placed in the scene specifies that the navmesh region it is inside should be included in the navmesh.

If this is set to OnlyForCompletelyInsideTile a navmesh region is included in the navmesh if it has a RelevantGraphSurface inside it, or if it is adjacent to a tile border. This can leave some small regions which you didn't want to have included because they are adjacent to tile borders, but it removes the need to place a component in every single tile, which can be tedious (see below).

If this is set to RequireForAll a navmesh region is included only if it has a RelevantGraphSurface inside it. Note that even though the navmesh looks continous between tiles, the tiles are computed individually and therefore you need a RelevantGraphSurface component for each region and for each tile.

In the above image, the mode OnlyForCompletelyInsideTile was used. Tile borders are highlighted in black. Note that since all regions are adjacent to a tile border, this mode didn't remove anything in this case and would give the same result as DoNotRequire. The RelevantGraphSurface component is shown using the green gizmo in the top-right of the blue plane.

In the above image, the mode RequireForAll was used. No tiles were used. Note that the small region at the top of the orange cube is now gone, since it was not the in the same region as the relevant graph surface component. The result would have been identical with OnlyForCompletelyInsideTile since there are no tiles (or a single tile, depending on how you look at it).

The mode RequireForAll was used here. Since there is only a single RelevantGraphSurface component, only the region it was in, in the tile it is placed in, will be enabled. If there would have been several RelevantGraphSurface in other tiles, those regions could have been enabled as well.

Here another tile size was used along with the OnlyForCompletelyInsideTile. Note that the region on top of the orange cube is gone now since the region borders do not intersect that region (and there is no RelevantGraphSurface component inside it).

Vector3 rotation

Rotation of the graph in degrees.

bool scanEmptyGraph

If true, scanning the graph will yield a completely empty graph.

Useful if you want to replace the graph with a custom navmesh for example

int tileSizeX = 128

Size of a tile along the X axis in voxels.

This is the width of the tile.

A large tile size can be faster to initially scan (but beware of out of memory issues if you try with a too large tile size in a large world) smaller tile sizes are (much) faster to update.

Different tile sizes can affect the quality of paths. It is often good to split up huge open areas into several tiles for better quality paths, but too small tiles can also lead to effects looking like invisible obstacles. For more information about this take a look at Notes about navmesh graphs. Usually it is best to experiment and see what works best for your game.

When scanning a recast graphs individual tiles can be calculated in parallel which can make it much faster to scan large worlds. When you want to recalculate a part of a recast graph, this can only be done on a tile-by-tile basis which means that if you often try to update a region of the recast graph much smaller than the tile size, then you will be doing a lot of unnecessary calculations. However if you on the other hand update regions of the recast graph that are much larger than the tile size then it may be slower than necessary as there is some overhead in having lots of tiles instead of a few larger ones (not that much though).

Recommended values are between 64 and 256, but these are very soft limits. It is possible to use both larger and smaller values.

int tileSizeZ = 128

Size of a tile along the Z axis in voxels.

This is the width of the tile.

A large tile size can be faster to initially scan (but beware of out of memory issues if you try with a too large tile size in a large world) smaller tile sizes are (much) faster to update.

Different tile sizes can affect the quality of paths. It is often good to split up huge open areas into several tiles for better quality paths, but too small tiles can also lead to effects looking like invisible obstacles. For more information about this take a look at Notes about navmesh graphs. Usually it is best to experiment and see what works best for your game.

When scanning a recast graphs individual tiles can be calculated in parallel which can make it much faster to scan large worlds. When you want to recalculate a part of a recast graph, this can only be done on a tile-by-tile basis which means that if you often try to update a region of the recast graph much smaller than the tile size, then you will be doing a lot of unnecessary calculations. However if you on the other hand update regions of the recast graph that are much larger than the tile size then it may be slower than necessary as there is some overhead in having lots of tiles instead of a few larger ones (not that much though).

Recommended values are between 64 and 256, but these are very soft limits. It is possible to use both larger and smaller values.

bool useTiles = true

If true, divide the graph into tiles, otherwise use a single tile covering the whole graph.

Using tiles is useful for a number of things. But it also has some drawbacks.

• Using tiles allows you to update only a part of the graph at a time. When doing graph updates on a recast graph, it will always recalculate whole tiles (or the whole graph if there are no tiles). NavmeshCut components also work on a tile-by-tile basis.

• Using tiles allows you to use NavmeshPrefabs.

• Using tiles can break up very large triangles, which can improve path quality in some cases, and make the navmesh more closely follow the y-coordinates of the ground.

• Using tiles can make it much faster to generate the navmesh, because each tile can be calculated in parallel. But if the tiles are made too small, then the overhead of having many tiles can make it slower than having fewer tiles.

• Using small tiles can make the path quality worse in some cases, but setting the FunnelModifiers quality setting to high (or using RichAI.funnelSimplification) will mostly mitigate this.

float walkableClimb = 0.5F

Height the character can climb.

float walkableHeight = 2F

Character height.

BackgroundTraversability

Whether the base of the graph should default to being walkable or unwalkable.

DimensionMode

Whether to use 3D or 2D mode.

RelevantGraphSurfaceMode

void ClearTiles (

IntRect

tileRect

The rectangle in tile coordinates to clear. The coordinates are in tile coordinates, not world coordinates.

)

Clears the tiles in the specified rectangle.

int CountNodes ()

Number of nodes in the graph.

Note that this is, unless the graph type has overriden it, an O(n) operation.

This is an O(1) operation for grid graphs and point graphs. For layered grid graphs it is an O(n) operation.

void EndBatchTileUpdate ()

End batch updating of tiles.

During batch updating, tiles will not be connected if they are updated with ReplaceTile. When ending batching, all affected tiles will be connected. This is faster than not using batching.

NNInfo GetNearest (

Vector3	position	The position to try to find the closest node to.
NNConstraint	constraint=null	Used to limit which nodes are considered acceptable. You may, for example, only want to consider walkable nodes. If null, all nodes will be considered acceptable.

)

Returns the nearest node to a position using the specified NNConstraint.

The returned NNInfo will contain both the closest node, and the closest point on the surface of that node. The distance is measured to the closest point on the surface of the node.

NNInfo GetNearest (

Vector3	position	The position to try to find the closest node to.
NNConstraint	constraint	Used to limit which nodes are considered acceptable. You may, for example, only want to consider walkable nodes. If null, all nodes will be considered acceptable.
float	maxDistanceSqr	The maximum squared distance from the position to the node. If the node is further away than this, the function will return an empty NNInfo. You may pass infinity if you do not want to limit the distance.

)

Nearest node to a position using the specified NNConstraint.

The returned NNInfo will contain both the closest node, and the closest point on the surface of that node. The distance is measured to the closest point on the surface of the node.

void GetNodes (

System.Func<GraphNode, bool>

action

)

Calls a delegate with all nodes in the graph until the delegate returns false.

void GetNodes (

System.Action<GraphNode>

action

)

Calls a delegate with all nodes in the graph.

This is the primary way of iterating through all nodes in a graph.

Do not change the graph structure inside the delegate.

var gg = AstarPath.active.data.gridGraph;

gg.GetNodes(node => {
// Here is a node
Debug.Log("I found a node at position " + (Vector3)node.position);
});
If you want to store all nodes in a list you can do this

var gg = AstarPath.active.data.gridGraph;

List<GraphNode> nodes = new List<GraphNode>();

gg.GetNodes((System.Action<GraphNode>)nodes.Add);


NavmeshTile GetTile (

int	x
int	z

)

Tile at the specified x, z coordinate pair.

The first tile is at (0,0), the last tile at (tileXCount-1, tileZCount-1).

var graph = AstarPath.active.data.recastGraph;
int tileX = 5;
int tileZ = 8;
NavmeshTile tile = graph.GetTile(tileX, tileZ);

for (int i = 0; i < tile.nodes.Length; i++) {
// ...
}
// or you can access the nodes like this:
tile.GetNodes(node => {
// ...
});


Bounds GetTileBounds (

IntRect

rect

Tiles to get the bounding box of. The rectangle is in tile coordinates where 1 unit = 1 tile.

)

Returns a bounds object with the bounding box of a group of tiles.

The bounding box is defined in world space.

Bounds GetTileBounds (

int	x
int	z
int	width=1
int	depth=1

)

Returns a bounds object with the bounding box of a group of tiles.

The bounding box is defined in world space.

Bounds GetTileBoundsInGraphSpace (

IntRect

rect

Tiles to get the bounding box of. The rectangle is in tile coordinates where 1 unit = 1 tile.

)

Returns an XZ bounds object with the bounds of a group of tiles in graph space.

Bounds GetTileBoundsInGraphSpace (

int	x
int	z
int	width=1
int	depth=1

)

Returns an XZ bounds object with the bounds of a group of tiles in graph space.

void GetTileCoordinates (

int	tileIndex
out int	x
out int	z

)

Tile coordinates from a tile index.

Int2 GetTileCoordinates (

Vector3

position

)

Returns the tile coordinate which contains the specified position.

It is not necessarily a valid tile (i.e it could be out of bounds).

int GetTileIndex (

int

index

)

Tile index from a vertex index.

NavmeshTile[] GetTiles ()

All tiles.

IntRect GetTouchingTiles (

Bounds	bounds
float	margin=0

)

Returns a rect containing the indices of all tiles touching the specified bounds.

If a margin is passed, the bounding box in graph space is expanded by that amount in every direction.

IntRect GetTouchingTilesInGraphSpace (

Rect

rect

Graph space rectangle (in graph space all tiles are on the XZ plane regardless of graph rotation and other transformations, the first tile has a corner at the origin)

)

Returns a rect containing the indices of all tiles touching the specified bounds.

IntRect GetTouchingTilesRound (

Bounds

bounds

)

Returns a rect containing the indices of all tiles by rounding the specified bounds to tile borders.

This is different from GetTouchingTiles in that the tiles inside the rectangle returned from this method may not contain the whole bounds, while that is guaranteed for GetTouchingTiles.

Int3 GetVertex (

int

index

)

Vertex coordinate for the specified vertex index.

int GetVertexArrayIndex (

int

index

)

Int3 GetVertexInGraphSpace (

int

index

)

Vertex coordinate in graph space for the specified vertex index.

bool IsPointOnNavmesh (

Vector3

position

The point to check

)

True if the point is on a walkable part of the navmesh, as seen from above.

A point is considered on the navmesh if it is above or below a walkable navmesh surface, at any distance, and if it is not above/below a closer unwalkable node.

This uses the graph's natural up direction to determine which way is up. Therefore, it will also work on rotated graphs, as well as graphs in 2D mode.

This method works for all graph types. However, for PointGraphs, this will never return true unless you pass in the exact coordinate of a node, since point nodes do not have a surface.

bool Linecast (

Vector3	start
Vector3	end

)

Returns if there is an obstacle between start and end on the graph.

This is not the same as Physics.Linecast, this function traverses the graph and looks for collisions instead of checking for collider intersection.

bool Linecast (

Vector3	start	Point to linecast from.
Vector3	end	Point to linecast to.
GraphNode	hint	If you know which node the start point is on, you can pass it here to save a GetNearest call, resulting in a minor performance boost. Otherwise, pass null. The start point will be clamped to the surface of this node.
outGraphHitInfo	hit	Contains info on what was hit, see GraphHitInfo.

)

Returns if there is an obstacle between start and end on the graph.

This is not the same as Physics.Linecast, this function traverses the graph and looks for collisions instead of checking for collider intersection.

bool Linecast (

Vector3	start	Point to linecast from.
Vector3	end	Point to linecast to.
GraphNode	hint	If you know which node the start point is on, you can pass it here to save a GetNearest call, resulting in a minor performance boost. Otherwise, pass null. The start point will be clamped to the surface of this node.

)

Returns if there is an obstacle between start and end on the graph.

This is not the same as Physics.Linecast, this function traverses the graph and looks for collisions instead of checking for collider intersection.

bool Linecast (

Vector3	start	Point to linecast from.
Vector3	end	Point to linecast to.
GraphNode	hint	If you know which node the start point is on, you can pass it here to save a GetNearest call, resulting in a minor performance boost. Otherwise, pass null. The start point will be clamped to the surface of this node.
outGraphHitInfo	hit	Contains info on what was hit, see GraphHitInfo.
List<GraphNode>	trace	If a list is passed, then it will be filled with all nodes the linecast traverses.

)

Returns if there is an obstacle between start and end on the graph.

This is not the same as Physics.Linecast, this function traverses the graph and looks for collisions instead of checking for collider intersection.

bool Linecast (

Vector3	start	Point to linecast from.
Vector3	end	Point to linecast to.
outGraphHitInfo	hit	Contains info on what was hit, see GraphHitInfo.
List<GraphNode>	trace	If a list is passed, then it will be filled with all nodes the linecast traverses.
System.Func<GraphNode, bool>	filter	If not null then the delegate will be called for each node and if it returns false the node will be treated as unwalkable and a hit will be returned. Note that unwalkable nodes are always treated as unwalkable regardless of what this filter returns.

)

Returns if there is an obstacle between start and end on the graph.

This is not the same as Physics.Linecast, this function traverses the graph and looks for collisions instead of checking for collider intersection.

bool Linecast (

Vector3	start	Point to linecast from.
Vector3	end	Point to linecast to.
GraphNode	hint	If you know which node the start point is on, you can pass it here to save a GetNearest call, resulting in a minor performance boost. Otherwise, pass null. The start point will be clamped to the surface of this node.
outGraphHitInfo	hit	Contains info on what was hit, see GraphHitInfo.
List<GraphNode>	trace	If a list is passed, then it will be filled with all nodes the linecast traverses.
System.Func<GraphNode, bool>	filter	If not null then the delegate will be called for each node and if it returns false the node will be treated as unwalkable and a hit will be returned. Note that unwalkable nodes are always treated as unwalkable regardless of what this filter returns.

)

Returns if there is an obstacle between start and end on the graph.

This is not the same as Physics.Linecast, this function traverses the graph and looks for collisions instead of checking for collider intersection.

bool Linecast (

NavmeshBase	graph	The graph to perform the search on.
Vector3	start	Point to start from.
Vector3	end	Point to linecast to.
GraphNode	hint	If you know which node the start point is on, you can pass it here to save a GetNearest call, resulting in a minor performance boost. Otherwise, pass null. The start point will be clamped to the surface of this node.
outGraphHitInfo	hit	Contains info on what was hit, see GraphHitInfo.

)

Returns if there is an obstacle between start and end on the graph.

This is not the same as Physics.Linecast, this function traverses the graph and looks for collisions instead of checking for collider intersection.

bool Linecast (

NavmeshBase	graph	The graph to perform the search on
Vector3	origin	Point to start from. This point should be on the navmesh. It will be snapped to the closest point on the navmesh otherwise.
Vector3	end	Point to linecast to
GraphNode	hint	If you already know the node which contains the origin point, you may pass it here for slighly improved performance. If null, a search for the closest node will be done.
outGraphHitInfo	hit	Contains info on what was hit, see GraphHitInfo
List<GraphNode>	trace	If a list is passed, then it will be filled with all nodes along the line up until it hits an obstacle or reaches the end.
System.Func<GraphNode, bool>	filter=null	If not null then the delegate will be called for each node and if it returns false the node will be treated as unwalkable and a hit will be returned. Note that unwalkable nodes are always treated as unwalkable regardless of what this filter returns.

)

Returns if there is an obstacle between origin and end on the graph.

This is not the same as Physics.Linecast, this function traverses the graph and looks for collisions instead of checking for collider intersections.

float NearestNodeDistanceSqrLowerBound (

Vector3	position	The position to check from
NNConstraint	constraint	A constraint on which nodes are valid. This may or may not be used by the function. You may pass null if you consider all nodes valid.

)

Lower bound on the squared distance from the given point to the closest node in this graph.

This is used to speed up searching for the closest node when there is more than one graph in the scene, by checking the graphs in order of increasing estimated distance to the point.

Implementors may return 0 at all times if it is hard to come up with a good lower bound. It is more important that this function is fast than that it is accurate.

void OnDrawGizmos (

DrawingData	gizmos
bool	drawNodes
RedrawScope	redrawScope

)

Draw gizmos for the graph.

System.Action<NavmeshTile[]> OnRecalculatedTiles

Called when tiles have been completely recalculated.

This is called after scanning the graph and after performing graph updates that completely recalculate tiles (not ones that simply modify e.g penalties). It is not called after NavmeshCut updates.

GraphNode PointOnNavmesh (

Vector3	position
NNConstraint	constraint

)

Finds the first node which contains position.

"Contains" is defined as position is inside the triangle node when seen from above. In case of a multilayered environment, the closest node which contains the point is returned.

Returns null if there was no node containing the point. This serves as a quick check for "is this point on the navmesh or not".

Note that the behaviour of this method is distinct from the GetNearest method. The GetNearest method will return the closest node to a point, which is not necessarily the one which contains it when seen from above.

Uses NNConstraint.distanceMetric to define the "up" direction. The up direction of the graph will be used if it is not set. The up direction defines what "inside" a node means. A point is inside a node if it is inside the triangle when seen from above.

void RelocateNodes (

Matrix4x4

deltaMatrix

)

Moves the nodes in this graph.

Multiplies all node positions by deltaMatrix.

For example if you want to move all your nodes in e.g a point graph 10 units along the X axis from the initial position var graph = AstarPath.data.pointGraph;
var m = Matrix4x4.TRS (new Vector3(10,0,0), Quaternion.identity, Vector3.one);
graph.RelocateNodes (m);


void RelocateNodes (

GraphTransform

newTransform

)

Moves the nodes in this graph.

Moves all the nodes in such a way that the specified transform is the new graph space to world space transformation for the graph. You usually use this together with the CalculateTransform method.

So for example if you want to move and rotate all your nodes in e.g a recast graph you can do // Move the graph to the point (20, 10, 10), rotated 45 degrees around the X axis
var graph = AstarPath.active.data.recastGraph;
graph.forcedBoundsCenter = new Vector3(20, 10, 10);
graph.rotation = new Vector3(45, 0, 0);
graph.RelocateNodes(graph.CalculateTransform());
For a navmesh graph it will look like: * // Move the graph to the point (20, 10, 10), rotated 45 degrees around the X axis
var graph = AstarPath.active.data.navmesh;
graph.offset = new Vector3(20, 10, 10);
graph.rotation = new Vector3(45, 0, 0);
graph.RelocateNodes(graph.CalculateTransform());
This will move all the nodes to new positions as if the new graph settings had been there from the start.

void ReplaceTile (

int	x	X coordinate of the tile to replace.
int	z	Z coordinate of the tile to replace.
Int3[]	verts	Vertices of the new tile. The vertices are assumed to be in 'tile space', that is being in a rectangle with one corner at the origin and one at (TileWorldSizeX, 0, TileWorldSizeZ).
int[]	tris	Triangles of the new tile. If RecalculateNormals is enabled, the triangles will be converted to clockwise order (when seen from above), if they are not already.
uint[]	tags=null	Tags for the nodes. The array must have the same length as the tris array divided by 3. If null, the tag will be set to 0 for all nodes.
bool	tryPreserveExistingTagsAndPenalties=true	If true, existing tags and penalties will be preserved for nodes that stay in exactly the same position after the tile replacement.

)

Replace tile at index with nodes created from specified navmesh.

This will create new nodes and link them to the adjacent tile (unless batching has been started in which case that will be done when batching ends).

void Scan ()

Scan the graph.

Consider using AstarPath.Scan() instead since this function only scans this graph, and if you are using multiple graphs with connections between them, then it is better to scan all graphs at once.

IGraphSnapshot Snapshot (

Bounds

bounds

)

Captures a snapshot of a part of the graph, to allow restoring it later.

If this graph type does not support taking snapshots, or if the bounding box does not intersect with the graph, this method returns null.

void StartBatchTileUpdate ()

Start batch updating of tiles.

During batch updating, tiles will not be connected if they are updating with ReplaceTile. When ending batching, all affected tiles will be connected. This is faster than not using batching.

const int TileIndexMask = 0x7FFFF

const int TileIndexOffset = 12

const int VertexIndexMask = 0xFFF

AstarPath active

Reference to the AstarPath object in the scene.

Bounds bounds

World bounding box for the graph.

This always contains the whole graph.

It is ok for a graph type to return an infinitely large bounding box, but this may make some operations less efficient. The point graph will always return an infinitely large bounding box.

bool drawGizmos = true

Enable to draw gizmos in the Unity scene view.

In the inspector this value corresponds to the state of the 'eye' icon in the top left corner of every graph inspector.

bool enableNavmeshCutting = true

Should navmesh cuts affect this graph.

Vector3 forcedBoundsSize = new Vector3(100, 40, 100)

Size of the bounding box.

uint graphIndex

Index of the graph, used for identification purposes.

Guid guid

Used as an ID of the graph, considered to be unique.

bool infoScreenOpen

Used in the editor to check if the info screen is open.

Should be inside UNITY_EDITOR only #ifs but just in case anyone tries to serialize a NavGraph instance using Unity, I have left it like this as it would otherwise cause a crash when building. Version 3.0.8.1 was released because of this bug only

uint initialPenalty

Default penalty to apply to all nodes.

bool isScanned

string name

Name of the graph.

Can be set in the unity editor

NavmeshUpdates.NavmeshUpdateSettings navmeshUpdateData

Handles navmesh cutting.

bool open

Is the graph open in the editor.

bool persistent

True if the graph will be included when serializing graph data.

If false, the graph will be ignored when saving graph data.

Most graphs are persistent, but the LinkGraph is not persistent because links are always re-created from components at runtime.

bool showInInspector

True if the graph should be visible in the editor.

False is used for some internal graph types that users don't have to worry about.

bool showMeshOutline = true

Show an outline of the polygons in the Unity Editor.

bool showMeshSurface = true

Show the surface of the navmesh.

bool showNodeConnections

Show the connections between the polygons in the Unity Editor.

int tileXCount

Number of tiles along the X-axis.

int tileZCount

Number of tiles along the Z-axis.

GraphTransform transform = GraphTransform.identityTransform

Determines how the graph transforms graph space to world space.

void AssertSafeToUpdateGraph ()

Throws an exception if it is not safe to update internal graph data right now.

It is safe to update graphs when graphs are being scanned, or inside a work item. In other cases pathfinding could be running at the same time, which would not appreciate graph data changing under its feet.

int CharacterRadiusInVoxels

Convert character radius to a number of voxels.

void ClearTile (

int	x
int	z
NavmeshTile	replacement

)

Clear the tile at the specified coordinate.

Must be called during a batch update, see StartBatchTileUpdate.

void ConnectTileWithNeighbours (

NavmeshTile	tile
bool	onlyUnflagged=false

)

void ConnectTiles (

NavmeshTile	tile1
NavmeshTile	tile2
float	tileWorldSizeX
float	tileWorldSizeZ
float	maxTileConnectionEdgeDistance

)

Generate connections between the two tiles.

The tiles must be adjacent.

void CreateNodeConnections (

TriangleMeshNode[]	nodes
bool	keepExistingConnections

)

Create connections between all nodes.

void CreateNodes (

NavmeshTile	tile
UnsafeSpan<int>	tris
int	tileIndex
uint	graphIndex
UnsafeSpan<uint>	tags
bool	initializeNodes
AstarPath	astar
uint	initialPenalty
bool	tryPreserveExistingTagsAndPenalties

)

void DeserializeExtraInfo (

GraphSerializationContext

ctx

)

Deserializes graph type specific node data.

void DestroyAllNodes ()

Destroys all nodes in the graph.

void DirtyBounds (

Bounds

bounds

)

Notifies the system that changes have been made inside these bounds.

This should be called by graphs whenever they are changed. It will cause off-mesh links to be updated, and it will also ensure GraphModifier events are callled.

The bounding box should cover the surface of all nodes that have been updated. It is fine to use a larger bounding box than necessary (even an infinite one), though this may be slower, since more off-mesh links need to be recalculated. You can even use an infinitely large bounding box if you don't want to bother calculating a more accurate one. You can also call this multiple times to dirty multiple bounding boxes.

When scanning the graph, this is called automatically - with the value from the bounds property - for all graphs after the scanning has finished.

void DisposeUnmanagedData ()

Cleans up any unmanaged data that the graph has.

void DrawUnwalkableNodes (

DrawingData	gizmos
float	size
RedrawScope	redrawScope

)

void FillWithEmptyTiles ()

Fills graph with tiles created by NewEmptyTile.

NavmeshTile NewEmptyTile (

int	x
int	z

)

Creates a single new empty tile.

void OnDestroy ()

Function for cleaning up references.

This will be called on the same time as OnDisable on the gameObject which the AstarPath script is attached to (remember, not in the editor). Use for any cleanup code such as cleaning up static variables which otherwise might prevent resources from being collected. Use by creating a function overriding this one in a graph class, but always call base.OnDestroy () in that function. All nodes should be destroyed in this function otherwise a memory leak will arise.

void PostDeserialization (

GraphSerializationContext

ctx

)

Called after all deserialization has been done for all graphs.

Can be used to set up more graph data which is not serialized

IGraphUpdatePromise ScanInternal (

bool

async

)

Internal method to scan the graph.

Override this function to implement custom scanning logic.

IGraphUpdatePromiseIUpdatableGraph. ScheduleGraphUpdates (

List<GraphUpdateObject>

graphUpdates

)

Schedules a number of graph updates.

This method should return a promise. It should not execute the graph updates immediately. The Apply method on the promise will be called when the graph updates should be applied. In the meantime, the graph may perform calculations using e.g. the unity job system.

Notes to implementators. This function should (in order):

1. Call o.WillUpdateNode on the GUO for every node it will update, it is important that this is called BEFORE any changes are made to the nodes.

2. Update walkabilty using special settings such as the usePhysics flag used with the GridGraph.

3. Call Apply on the GUO for every node which should be updated with the GUO.

4. Update connectivity info if appropriate (GridGraphs updates connectivity, but most other graphs don't since then the connectivity cannot be recovered later).

It is guaranteed that the Apply function will be called on the returned promise before this function is called again.

Null may be returned if no updates need to be done to the graph.

void SerializeExtraInfo (

GraphSerializationContext

ctx

)

Serializes Node Info.

Should serialize:

• Base

  • Node Flags

  • Node Penalties

  • Node

• Node Positions (if applicable)

• Any other information necessary to load the graph in-game All settings marked with json attributes (e.g JsonMember) have already been saved as graph settings and do not need to be handled here.

It is not necessary for this implementation to be forward or backwards compatible.

void SetLayout (

TileLayout

info

)

int TileBorderSizeInVoxels

Number of extra voxels on each side of a tile to ensure accurate navmeshes near the tile border.

The width of a tile is expanded by 2 times this value (1x to the left and 1x to the right)

float TileBorderSizeInWorldUnits

bool exists

True if the graph exists, false if it has been destroyed.

bool hasExtendedInX = false

bool hasExtendedInZ = false

DisposeArena pendingGraphUpdateArena = new DisposeArena()

NavmeshTile[] tiles

All tiles.

float colliderRasterizeDetail

Controls detail on rasterization of sphere and capsule colliders.

The colliders will be approximated with polygons so that the max distance to the theoretical surface is less than 1/(this number of voxels).

A higher value does not necessarily increase quality of the mesh, but a lower value will often speed it up.

You should try to keep this value as low as possible without affecting the mesh quality since that will yield the fastest scan times.

The default value is 1, which corresponds to a maximum error of 1 voxel. In most cases, increasing this to a value higher than 2 (corresponding to a maximum error of 0.5 voxels) is not useful.

LayerMask mask

Layer mask which filters which objects to include.

bool rasterizeColliders

Use colliders to calculate the navmesh.

Depending on the dimensionMode, either 3D or 2D colliders will be rasterized.

Sphere/Capsule/Circle colliders will be approximated using polygons, with the precision specified in colliderRasterizeDetail.

bool rasterizeMeshes

Use scene meshes to calculate the navmesh.

This can get you higher precision than colliders, since colliders are typically very simplified versions of the mesh. However, it is often slower to scan, and graph updates can be particularly slow.

The reason that graph updates are slower is that there's no efficient way to find all meshes that intersect a given tile, so the graph has to iterate over all meshes in the scene just to find the ones relevant for the tiles that you want to update. Colliders, on the other hand, can be efficiently queried using the physics system.

You can disable this and attach a RecastMeshObj component (with dynamic=false) to all meshes that you want to be included in the navmesh instead. That way they will be able to be efficiently queried for, without having to iterate through all meshes in the scene.

In 2D mode, this setting has no effect.

bool rasterizeTerrain

Use terrains to calculate the navmesh.

In 2D mode, this setting has no effect.

bool rasterizeTrees

Rasterize tree colliders on terrains.

If the tree prefab has a collider, that collider will be rasterized. Otherwise a simple box collider will be used and the script will try to adjust it to the tree's scale, it might not do a very good job though so an attached collider is preferable.

In 2D mode, this setting has no effect.

List<string> tagMask

Objects tagged with any of these tags will be rasterized.

Note that this extends the layer mask, so if you only want to use tags, set mask to 'Nothing'.

int terrainSampleSize

Controls how large the sample size for the terrain is.

A higher value is faster to scan but less accurate.

The heightmap resolution is effectively divided by this value, before the terrain is rasterized.