Class PointGraph Extends NavGraph, IUpdatableGraph

PointNode AddNode (

Int3

position

)

Add a node to the graph at the specified position.

AstarPath.active.AddWorkItem(new AstarWorkItem(ctx => {
var graph = AstarPath.active.data.pointGraph;
// Add 2 nodes and connect them
var node1 = graph.AddNode((Int3)transform.position);
var node2 = graph.AddNode((Int3)(transform.position + Vector3.right));
var cost = (uint)(node2.position - node1.position).costMagnitude;
GraphNode.Connect(node1, node2, cost);
}));


T AddNode<T> (

T	node	This must be a node created using T(AstarPath.active) right before the call to this method. The node parameter is only there because there is no new(AstarPath) constraint on generic type parameters.
Int3	position	The node will be set to this position.

)

Add a node with the specified type to the graph at the specified position.

void ConnectNodes ()

Recalculates connections for all nodes in the graph.

This is useful if you have created nodes manually using AddNode and then want to connect them in the same way as the point graph normally connects nodes.

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


bool IsValidConnection (

GraphNode	a
GraphNode	b
out float	dist

)

Returns if the connection between a and b is valid.

Checks for obstructions using raycasts (if enabled) and checks for height differences.
As a bonus, it outputs the distance between the nodes too if the connection is valid.

void OnDrawGizmos (

DrawingData	gizmos
bool	drawNodes
RedrawScope	redrawScope

)

Draw gizmos for the graph.

void RebuildConnectionDistanceLookup ()

Rebuilds a cache used when nearestNodeDistanceMode = NodeDistanceMode.ToConnection.

void RebuildNodeLookup ()

Rebuilds the lookup structure for nodes.

This is used when optimizeForSparseGraph is enabled.

You should call this method every time you move a node in the graph manually and you are using optimizeForSparseGraph, otherwise pathfinding might not work correctly.

You may also call this after you have added many nodes using the AddNode method. When adding nodes using the AddNode method they will be added to the lookup structure. The lookup structure will rebalance itself when it gets too unbalanced however if you are sure you won't be adding any more nodes in the short term, you can make sure it is perfectly balanced and thus squeeze out the last bit of performance by calling this method. This can improve the performance of the GetNearest method slightly. The improvements are on the order of 10-20%.

void RegisterConnectionLength (

long

sqrLength

The length of the connection in squared Int3 units. This can be calculated using (node1.position - node2.position).sqrMagnitudeLong.

)

Ensures the graph knows that there is a connection with this length.

This is used when the nearest node distance mode is set to ToConnection. If you are modifying node connections yourself (i.e. manipulating the PointNode.connections array) then you must call this function when you add any connections.

When using GraphNode.Connect this is done automatically. It is also done for all nodes when RebuildNodeLookup is called.

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


bool isScanned

Vector3 limits

Max distance along the axis for a connection to be valid.

0 = infinity

LayerMask mask

Layer mask to use for raycast.

float maxDistance

Max distance for a connection to be valid.

The value 0 (zero) will be read as infinity and thus all nodes not restricted by other constraints will be added as connections.

A negative value will disable any neighbours to be added. It will completely stop the connection processing to be done, so it can save you processing power if you don't these connections.

NodeDistanceMode nearestNodeDistanceMode

Distance query mode.

In the image above there are a few red nodes. Assume the agent is the orange circle. Using the Node mode the closest point on the graph that would be found would be the node at the bottom center which may not be what you want. Using the Connection mode it will find the closest point on the connection between the two nodes in the top half of the image.

When using the Connection option you may also want to use the Connection option for the Seeker's Start End Modifier snapping options. This is not strictly necessary, but it most cases it is what you want.

If you enable this during runtime, you will need to call RebuildConnectionDistanceLookup to make sure some cache data is properly recalculated. If the graph doesn't have any nodes yet or if you are going to scan the graph afterwards then you do not need to do this.

int nodeCount

Number of nodes in this graph.

PointNode[] nodes

All nodes in this graph.

Note that only the first nodeCount will be non-null.

You can also use the GetNodes method to get all nodes.

bool optimizeForSparseGraph

Optimizes the graph for sparse graphs.

This can reduce calculation times for both scanning and for normal path requests by huge amounts. It reduces the number of node-node checks that need to be done during scan, and can also optimize getting the nearest node from the graph (such as when querying for a path).

Try enabling and disabling this option, check the scan times logged when you scan the graph to see if your graph is suited for this optimization or if it makes it slower.

The gain of using this optimization increases with larger graphs, the default scan algorithm is brute force and requires O(n^2) checks, this optimization along with a graph suited for it, requires only O(n) checks during scan (assuming the connection distance limits are reasonable).

If you enable this during runtime, you will need to call RebuildNodeLookup to make sure any existing nodes are added to the lookup structure. If the graph doesn't have any nodes yet or if you are going to scan the graph afterwards then you do not need to do this.

bool raycast = true

Use raycasts to check connections.

bool recursive = true

Recursively search for child nodes to the root.

Transform root

Childs of this transform are treated as nodes.

string searchTag

If no root is set, all nodes with the tag is used as nodes.

bool thickRaycast

Use thick raycast.

float thickRaycastRadius = 1

Thick raycast radius.

bool use2DPhysics

Use the 2D Physics API.

NodeDistanceMode

Distance query mode.

In the image above there are a few red nodes. Assume the agent is the orange circle. Using the Node mode the closest point on the graph that would be found would be the node at the bottom center which may not be what you want. Using the Connection mode it will find the closest point on the connection between the two nodes in the top half of the image.

When using the Connection option you may also want to use the Connection option for the Seeker's Start End Modifier snapping options. This is not strictly necessary, but it most cases it is what you want.

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.

float NearestNodeDistanceSqrLowerBound (

Vector3	position	The position to check from
NNConstraint	constraint=null	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 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 AddChildren (

PointNode[]	nodes
ref int	c
Transform	tr

)

Recursively adds childrens of a transform as nodes.

void AddToLookup (

PointNode

node

)

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.

PointKDTree BuildNodeLookup (

PointNode[]	nodes
int	nodeCount
bool	optimizeForSparseGraph

)

IEnumerable<float> ConnectNodesAsync (

PointNode[]	nodes
int	nodeCount
PointKDTree	lookupTree
float	maxDistance
Vector3	limits
PointGraph	graph

)

Calculates connections for all nodes in the graph.

This is an IEnumerable, you can iterate through it using e.g foreach to get progress information.

int CountChildren (

Transform

tr

)

Recursively counds children of a transform.

PointNode[] CreateNodes (

int

count

)

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

CommandBuilder	draw
PointGraph	graph
Transform	tr

)

void DrawUnwalkableNodes (

DrawingData	gizmos
float	size
RedrawScope	redrawScope

)

NNInfo FindClosestConnectionPoint (

PointNode	node
Vector3	position
float	maxDistanceSqr

)

long LongestConnectionLength (

PointNode[]	nodes
int	nodeCount

)

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

)

Updates an area in the list graph.

Recalculates possibly affected connections, i.e all connectionlines passing trough the bounds of the guo will be recalculated

void SerializeExtraInfo (

GraphSerializationContext

ctx

)

Serializes graph type specific node data.

This function can be overriden to serialize extra node information (or graph information for that matter) which cannot be serialized using the standard serialization. Serialize the data in any way you want and return a byte array. When loading, the exact same byte array will be passed to the DeserializeExtraInfo function.
These functions will only be called if node serialization is enabled.

bool exists

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

PointKDTree lookupTree = new PointKDTree()

long maximumConnectionLength = 0

Longest known connection.

In squared Int3 units.

IGraphUpdatePromise ScanInternal ()

Internal method to scan the graph.