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 SnapForceBoundsToScene ()

Changes the bounds of the graph to precisely encapsulate all objects in the scene that can be included in the scanning process based on the settings.

Which objects are used depends on the settings. If an object would have affected the graph with the current settings if it would have been inside the bounds of the graph, it will be detected and the bounds will be expanded to contain that object.

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

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. See #CellHeight.

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.

float colliderRasterizeDetail = 1

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.

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

LayerMask mask = -1

Layer mask which filters which objects to include.

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<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 square world units (square meters in most games).

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.

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 = true

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 = true

Use terrains to calculate the navmesh.

In 2D mode, this setting has no effect.

bool rasterizeTrees = true

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.

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

List<string> tagMask = new List<string>()

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 = 3

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.

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

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

)

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

)

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 Linecast (

Vector3	origin	Point to linecast from.
Vector3	end	Point to linecast to.
GraphNode	hint	You may pass the node closest to the start point if you already know it for a minor performance boost. If null, a search for the closest node will be done. This parameter is mostly deprecated and should be avoided. Pass null instead.
outGraphHitInfo	hit	Contains info on what was hit, see GraphHitInfo.

)

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 intersection.

bool Linecast (

Vector3	origin	Point to linecast from.
Vector3	end	Point to linecast to.
GraphNode	hint	You may pass the node closest to the start point if you already know it for a minor performance boost. If null, a search for the closest node will be done. This parameter is mostly deprecated and should be avoided. Pass null instead.

)

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 intersection.

bool Linecast (

Vector3	origin	Point to linecast from.
Vector3	end	Point to linecast to.
GraphNode	hint	You may pass the node closest to the start point if you already know it for a minor performance boost. If null, a search for the closest node will be done. This parameter is mostly deprecated and should be avoided. Pass null instead.
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 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 intersection.

bool Linecast (

Vector3	origin	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 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 intersection.

bool Linecast (

NavmeshBase	graph	The graph to perform the search on.
Vector3	origin	Point to start from.
Vector3	end	Point to linecast to.
GraphNode	hint	You may pass the node closest to the start point if you already know it for a minor performance boost. If null, a search for the closest node will be done. This parameter is mostly deprecated and should be avoided. Pass null instead.
outGraphHitInfo	hit	Contains info on what was hit, see GraphHitInfo.

)

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 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.

bool Linecast (

Vector3	origin
Vector3	end

)

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 intersection.

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.projectionAxis 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
int	z
Int3[]	verts
int[]	tris

)

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).

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).

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.

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.

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 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 AllocateTilesArray (

TileLayout

info

)

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.

GraphUpdateThreadingIUpdatableGraph. CanUpdateAsync (

GraphUpdateObject

o

)

int CharacterRadiusInVoxels

Convert character radius to a number of voxels.

void ClearTile (

int	x
int	z

)

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

)

Create connections between all nodes.

void CreateNodes (

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

)

void DeserializeExtraInfo (

GraphSerializationContext

ctx

)

Deserializes graph type specific node data.

void DestroyAllNodes ()

Destroys all nodes in the graph.

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

IEnumerable<Progress> ScanAllTiles (

bool

async

)

IEnumerable<Progress> ScanInternal (

bool

async

)

Internal method to scan the graph.

Called from AstarPath.ScanAsync. Override this function to implement custom scanning logic. Progress objects can be yielded to show progress info in the editor and to split up processing over several frames when using async scanning.

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.

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

void IUpdatableGraph. UpdateArea (

GraphUpdateObject

o

)

Updates an area using the specified GraphUpdateObject.

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).

GraphUpdatePromiseIUpdatableGraph. UpdateAreaInit (

GraphUpdateObject

o

)

May be called on the Unity thread before starting the update.

May return a GraphUpdatePromise or null. If a GraphUpdatePromise is returned it will be polled on the main thread until it returns done. Only then will it progress to the next stage. The `Complete` method may be called if the graph update needs to be completed immediately.

void IUpdatableGraph. UpdateAreaPost (

GraphUpdateObject

guo

)

Called on the Unity thread to complete a graph update.

bool exists

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

DisposeArena pendingGraphUpdateArena = new DisposeArena()

Promise<TileBuilder.TileBuilderOutput> pendingGraphUpdatePromise

Promise<JobBuildNodes.BuildNodeTilesOutput> pendingGraphUpdatePromise2

NavmeshTile[] tiles

All tiles.