Class NavmeshBase Extends NavGraph, INavmesh, INavmeshHolder, ITransformedGraph, IRaycastableGraph

GraphTransform CalculateTransform ()

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

Does not update the transform field.

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.

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

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

NavmeshBase ()

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.

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

int GetTileIndex (

int

index

)

Tile index from a vertex index.

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 MaxTileConnectionEdgeDistance

Maximum (vertical) distance between the sides of two nodes for them to be connected across a tile edge.

When tiles are connected to each other, the nodes sometimes do not line up perfectly so some allowance must be made to allow tiles that do not match exactly to be connected with each other.

float NavmeshCuttingCharacterRadius

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.

bool RecalculateNormals

Determines how normals are calculated.

Disable for spherical graphs or other complicated surfaces that allow the agents to e.g walk on walls or ceilings.

By default the normals of the mesh will be flipped so that they point as much as possible in the upwards direction. The normals are important when connecting adjacent nodes. Two adjacent nodes will only be connected if they are oriented the same way. This is particularly important if you have a navmesh on the walls or even on the ceiling of a room. Or if you are trying to make a spherical navmesh. If you do one of those things then you should set disable this setting and make sure the normals in your source mesh are properly set.

If you for example take a look at the image below. In the upper case then the nodes on the bottom half of the mesh haven't been connected with the nodes on the upper half because the normals on the lower half will have been modified to point inwards (as that is the direction that makes them face upwards the most) while the normals on the upper half point outwards. This causes the nodes to not connect properly along the seam. When this option is set to false instead the nodes are connected properly as in the original mesh all normals point outwards.

The default value of this field is true to reduce the risk for errors in the common case. If a mesh is supplied that has all normals pointing downwards and this option is false, then some methods like PointOnNavmesh will not work correctly as they assume that the normals point upwards. For a more complicated surface like a spherical graph those methods make no sense anyway as there is no clear definition of what it means to be "inside" a triangle when there is no clear up direction.

float TileWorldSizeX

Size of a tile in world units along the X axis.

float TileWorldSizeZ

Size of a tile in world units along the Z axis.

bool enableNavmeshCutting = true

Should navmesh cuts affect this graph.

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

Size of the bounding box.

bool isScanned

NavmeshUpdates.NavmeshUpdateSettings navmeshUpdateData

Handles navmesh cutting.

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.

const int TileIndexMask = 0x7FFFF

const int TileIndexOffset = 12

const int VertexIndexMask = 0xFFF

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.

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.

void GetNodes (

System.Func<GraphNode, bool>

action

)

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

bool IsInsideBounds (

Vector3

point

)

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

This method may be able to use a tighter (non-axis aligned) bounding box than using the one returned by bounds.

It is valid for a graph to return true for all points in the world. In particular the PointGraph will always return true, since it has no limits on its bounding box.

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.

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.

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.

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.

string name

Name of the graph.

Can be set in the unity editor

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.

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.

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

NavmeshTile[]	tiles
int	startTile
int	endTile
GraphGizmoHelper	helper

)

Creates an outline of the navmesh for use in OnDrawGizmos in the editor.

void CreateNavmeshSurfaceVisualization (

NavmeshTile[]	tiles
int	startTile
int	endTile
GraphGizmoHelper	helper

)

Creates a mesh of the surfaces of the navmesh for use in OnDrawGizmos in the editor.

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

List<MeshNode>

nodes

)

Destroy several nodes simultaneously.

This is faster than simply looping through the nodes and calling the node.Destroy method because some optimizations relating to how connections are removed can be optimized.

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.

byte[] LinecastShapeEdgeLookup

Used to optimize linecasts by precomputing some values.

NNConstraint NNConstraintNoneXZ = new NNConstraint { constrainWalkability = false, constrainArea = false, constrainTags = false, constrainDistance = false, graphMask = -1, }

Cached NNConstraint.None with distanceXZ=true to reduce allocations.

static NavmeshBase ()

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

void PrepareNodeRecycling (

int	x
int	z
UnsafeSpan<Int3>	verts
UnsafeSpan<int>	tris
TriangleMeshNode[]	recycledNodeBuffer

)

Reuse nodes that keep the exact same vertices after a tile replacement.

The reused nodes will be added to the recycledNodeBuffer array at the index corresponding to the indices in the triangle array that its vertices uses.

All connections on the reused nodes will be removed except ones that go to other graphs. The reused nodes will be removed from the tile by replacing it with a null slot in the node array.

IGraphUpdatePromise ScanInternal (

bool

async

)

Internal method to scan the graph.

Override this function to implement custom scanning logic.

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

int	tileIdx1
int	tileIdx2

)

List<MeshNode> batchNodesToDestroy = new List<MeshNode>()

List of nodes that are going to be destroyed as part of a batch update.

bool batchTileUpdate

Currently updating tiles in a batch.

List<int> batchUpdatedTiles = new List<int>()

List of tiles updating during batch.

bool exists

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

Dictionary<int, int> nodeRecyclingHashBuffer = new Dictionary<int, int>()

Temporary buffer used in PrepareNodeRecycling.

NavmeshTile[] tiles

All tiles.

GraphTransformITransformedGraph. transform

bool nearestSearchOnlyXZ

Perform nearest node searches in XZ space only.

Recomended for single-layered environments. Faster but can be inaccurate esp. in multilayered contexts. You should not use this if the graph is rotated since then the XZ plane no longer corresponds to the ground plane.

This can be important on sloped surfaces. See the image below in which the closest point for each blue point is queried for:

You can also control this using a field on an NNConstraint object.