Class GridGraph Extends NavGraph, IUpdatableGraph, ITransformedGraph, IRaycastableGraph

void CalculateConnections (

GridNodeBase

node

)

Calculates the grid connections for a single node.

Convenience function, it's slightly faster to use CalculateConnections(int,int) but that will only show when calculating for a large number of nodes. This function will also work for both grid graphs and layered grid graphs.

void CalculateConnections (

int	x
int	z

)

Calculates the grid connections for a single node.

Note that to ensure that connections are completely up to date after updating a node you have to calculate the connections for both the changed node and its neighbours.

In a layered grid graph, this will recalculate the connections for all nodes in the (x,z) cell (it may have multiple layers of nodes).

void CalculateConnections (

int	x
int	z
GridNode	node

)

Calculates the grid connections for a single node.

void CalculateConnectionsForCellAndNeighbours (

int	x
int	z

)

Calculates the grid connections for a cell as well as its neighbours.

This is a useful utility function if you want to modify the walkability of a single node in the graph.

AstarPath.active.AddWorkItem(ctx => {
var grid = AstarPath.active.data.gridGraph;
int x = 5;
int z = 7;

// Mark a single node as unwalkable
grid.GetNode(x, z).Walkable = false;

// Recalculate the connections for that node as well as its neighbours
grid.CalculateConnectionsForCellAndNeighbours(x, z);
});


GraphTransform CalculateTransform ()

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

Does not update the transform field.

bool CheckConnection (

GridNode	node
int	dir

)

Returns if node is connected to it's neighbour in the specified direction.

This will also return true if neighbours = NumNeighbours.Four, the direction is diagonal and one can move through one of the adjacent nodes to the targeted node.

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

Erodes the walkable area.

void ErodeWalkableArea (

int	xmin
int	zmin
int	xmax
int	zmax

)

Erodes the walkable area.

xmin, zmin (inclusive)
xmax, zmax (exclusive)

void GenerateMatrix ()

Generates the matrix used for translating nodes from grid coordinates to world coordinates.

uint GetConnectionCost (

int

dir

)

NNInfoInternal GetNearest (

Vector3	position	The position to try to find a close node to
NNConstraint	constraint	Can for example tell the function to try to return a walkable node. If you do not get a good node back, consider calling GetNearestForce.
GraphNode	hint	Can be passed to enable some graph generators to find the nearest node faster.

)

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

NNInfoInternal GetNearestForce (

Vector3	position
NNConstraint	constraint

)

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

GridNodeBase GetNode (

int	x
int	z

)

Node in the specified cell.

Returns null if the coordinate is outside the grid.

var gg = AstarPath.active.data.gridGraph;
int x = 5;
int z = 8;
GridNodeBase node = gg.GetNode(x, z);
If you know the coordinate is inside the grid and you are looking to maximize performance then you can look up the node in the internal array directly which is slightly faster.

GridNode GetNodeConnection (

GridNode	node
int	dir

)

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


List<GraphNode> GetNodesInArea (

Bounds

bounds

)

List<GraphNode> GetNodesInArea (

GraphUpdateShape

shape

)

List<GraphNode> GetNodesInArea (

Bounds	bounds
GraphUpdateShape	shape

)

List<GraphNode> GetNodesInRegion (

IntRect

rect

Region in which to return nodes. It will be clamped to the grid.

)

Get all nodes in a rectangle.

List<GraphNode> GetNodesInRegion (

GraphUpdateShape

shape

)

All nodes inside the shape.

List<GraphNode> GetNodesInRegion (

Bounds

bounds

)

All nodes inside the bounding box.

int GetNodesInRegion (

IntRect	rect	Region in which to return nodes. It will be clamped to the grid.
GridNodeBase[]	buffer	Buffer in which the nodes will be stored. Should be at least as large as the number of nodes that can exist in that region.

)

Get all nodes in a rectangle.

IntRect GetRectFromBounds (

Bounds

bounds

)

A rect that contains all nodes that the bounds could touch.

This correctly handles rotated graphs and other transformations. The returned rect is guaranteed to not extend outside the graph bounds.

Int3 GraphPointToWorld (

int	x
int	z
float	height

)

Transform a point in graph space to world space.

This will give you the node position for the node at the given x and z coordinate if it is at the specified height above the base of the graph.

GridGraph ()

bool HasNodeConnection (

GridNode	node
int	dir

)

bool HasNodeConnection (

int	index
int	x
int	z
int	dir

)

bool IsValidConnection (

GridNodeBase	node1
GridNodeBase	node2

)

Returns true if a connection between the adjacent nodes n1 and n2 is valid.

Also takes into account if the nodes are walkable.

This method may be overriden if you want to customize what connections are valid. It must however hold that IsValidConnection(a,b) == IsValidConnection(b,a).

This is used for calculating the connections when the graph is scanned or updated.

bool Linecast (

Vector3	from
Vector3	to

)

Returns if there is an obstacle between from and to on the graph.

This is not the same as Physics.Linecast, this function traverses the graph and looks for collisions.

var gg = AstarPath.active.data.gridGraph;
bool anyObstaclesInTheWay = gg.Linecast(transform.position, enemy.position);


bool Linecast (

Vector3	from	Point to linecast from
Vector3	to	Point to linecast to
GraphNode	hint	This parameter is deprecated. It will be ignored.

)

Returns if there is an obstacle between from and to on the graph.

This is not the same as Physics.Linecast, this function traverses the graph and looks for collisions.

var gg = AstarPath.active.data.gridGraph;
bool anyObstaclesInTheWay = gg.Linecast(transform.position, enemy.position);


bool Linecast (

GridNodeBase	fromNode	Node to start from.
GridNodeBase	toNode	Node to try to reach using a straight line.
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 the two nodes on the graph.

This method is very similar to the other Linecast methods however it is much faster due to being able to use only integer math and not having to look up which node is closest to a particular input point.

var gg = AstarPath.active.data.gridGraph;
var node1 = gg.GetNode(2, 3);
var node2 = gg.GetNode(5, 7);
bool anyObstaclesInTheWay = gg.Linecast(node1, node2);


bool Linecast (

Vector3	from	Point to linecast from
Vector3	to	Point to linecast to
GraphNode	hint	This parameter is deprecated. It will be ignored.
outGraphHitInfo	hit	Contains info on what was hit, see GraphHitInfo

)

Returns if there is an obstacle between from and to on the graph.

This is not the same as Physics.Linecast, this function traverses the graph and looks for collisions.

var gg = AstarPath.active.data.gridGraph;
bool anyObstaclesInTheWay = gg.Linecast(transform.position, enemy.position);


bool Linecast (

Vector3	from	Point to linecast from
Vector3	to	Point to linecast to
GraphNode	hint	This parameter is deprecated. It will be ignored.
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 from and to on the graph.

This is not the same as Physics.Linecast, this function traverses the graph and looks for collisions.

var gg = AstarPath.active.data.gridGraph;
bool anyObstaclesInTheWay = gg.Linecast(transform.position, enemy.position);


bool Linecast (

Vector3	from	Point to linecast from
Vector3	to	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 from and to on the graph.

This is not the same as Physics.Linecast, this function traverses the graph and looks for collisions.

var gg = AstarPath.active.data.gridGraph;
bool anyObstaclesInTheWay = gg.Linecast(transform.position, enemy.position);


void OnDrawGizmos (

DrawingData	gizmos
bool	drawNodes
RedrawScope	redrawScope

)

Draw gizmos for the graph.

void RecalculateCell (

int	x	X coordinate of the cell
int	z	Z coordinate of the cell
bool	resetPenalties=true	If true, the penalty of the nodes will be reset to the initial value as if the graph had just been scanned (this excludes texture data however which is only done when scanning the graph).
bool	resetTags=true	If true, the tag will be reset to zero (the default tag).

)

Recalculates single node in the graph.

For a layered grid graph this will recalculate all nodes at a specific (x,z) cell in the grid. For grid graphs this will simply recalculate the single node at those coordinates.

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 (

Vector3	center
Quaternion	rotation
float	nodeSize
float	aspectRatio=1
float	isometricAngle=0

)

Relocate the grid graph using new settings.

This will move all nodes in the graph to new positions which matches the new settings.

void SetDimensions (

int	width
int	depth
float	nodeSize

)

Updates unclampedSize from width, depth and nodeSize values.

Also generates a new matrix .

You should use this method instead of setting the width and depth fields as the grid dimensions are not defined by the width and depth variables but by the unclampedSize and center variables.

var gg = AstarPath.active.data.gridGraph;
var width = 80;
var depth = 60;
var nodeSize = 1.0f;

gg.SetDimensions(width, depth, nodeSize);

// Recalculate the graph
AstarPath.active.Scan();


void SetGridShape (

InspectorGridMode

shape

)

Changes the grid shape.

This is equivalent to changing the 'shape' dropdown in the grid graph inspector.

Calling this method will set isometricAngle, aspectRatio, uniformEdgeCosts and neighbours to appropriate values for that shape.

void SetNodeConnection (

GridNode	node
int	dir
bool	value

)

void SetNodeConnection (

int	index	Index of the node
int	x	X coordinate of the node
int	z	Z coordinate of the node
int	dir	Direction from 0 up to but excluding 8.
bool	value	Enable or disable the connection

)

Set if connection in the specified direction should be enabled.

Note that bounds checking will still be done when getting the connection value again, so it is not necessarily true that HasNodeConnection will return true just because you used SetNodeConnection on a node to set a connection to true.

void SetUpOffsetsAndCosts ()

Sets up neighbourOffsets with the current settings.

neighbourOffsets, neighbourCosts, neighbourXOffsets and neighbourZOffsets are set up.
The cost for a non-diagonal movement between two adjacent nodes is RoundToInt (nodeSize * Int3.Precision)
The cost for a diagonal movement between two adjacent nodes is RoundToInt (nodeSize * Sqrt (2) * Int3.Precision)

bool SnappedLinecast (

Vector3	from	Point to linecast from.
Vector3	to	Point to linecast to.
GraphNode	hint	This parameter is deprecated. It will be ignored.
outGraphHitInfo	hit	Contains info on what was hit, see GraphHitInfo.

)

Returns if there is an obstacle between from and to on the graph.

This function is different from the other Linecast functions since it snaps the start and end positions to the centers of the closest nodes on the graph. This is not the same as Physics.Linecast, this function traverses the graph and looks for collisions.

void UpdateNodePositionCollision (

GridNode	node
int	x
int	z
bool	resetPenalty=true

)

Updates position, walkability and penalty for the node.

Assumes that collision.Initialize (...) has been called before this function

void UpdateSizeFromWidthDepth ()

Updates unclampedSize from width, depth and nodeSize values.

void UpdateTransform ()

Updates the transform field which transforms graph space to world space.

In graph space all nodes are laid out in the XZ plane with the first node having a corner in the origin. One unit in graph space is one node so the first node in the graph is at (0.5,0) the second one at (1.5,0) etc.

This takes the current values of the parameters such as position and rotation into account. The transform that was used the last time the graph was scanned is stored in the transform field.

The transform field is calculated using this method when the graph is scanned. The width, depth variables are also updated based on the unclampedSize field.

void CalculateConnections (

GridNode

node

)

Calculates the grid connections for a single node.

float ConvertHexagonSizeToNodeSize (

InspectorGridHexagonNodeSize	mode
float	value

)

float ConvertNodeSizeToHexagonSize (

InspectorGridHexagonNodeSize	mode
float	value

)

float aspectRatio = 1F

Scaling of the graph along the X axis.

This should be used if you want different scales on the X and Y axis of the grid

Vector3 center

Center point of the grid.

GraphCollision collision

Settings on how to check for walkability and height.

bool cutCorners = true

If disabled, will not cut corners on obstacles.

If connections is Eight, obstacle corners might be cut by a connection, setting this to false disables that.

int Depth

int depth

Depth (height) of the grid in nodes.

int erodeIterations

Erosion of the graph.

The graph can be eroded after calculation. This means a margin is put around unwalkable nodes or other unwalkable connections. It is really good if your graph contains ledges where the nodes without erosion are walkable too close to the edge.

Below is an image showing a graph with erode iterations 0, 1 and 2

int erosionFirstTag = 1

Tag to start from when using tags for erosion.

bool erosionUseTags

Use tags instead of walkability for erosion.

Tags will be used for erosion instead of marking nodes as unwalkable. The nodes will be marked with tags in an increasing order starting with the tag erosionFirstTag. Debug with the Tags mode to see the effect. With this enabled you can in effect set how close different AIs are allowed to get to walls using the Valid Tags field on the Seeker component.

InspectorGridMode inspectorGridMode = InspectorGridMode.Grid

Determines the layout of the grid graph inspector in the Unity Editor.

This field is only used in the editor, it has no effect on the rest of the game whatsoever.

If you want to change the grid shape like in the inspector you can use the SetGridShape method.

InspectorGridHexagonNodeSize inspectorHexagonSizeMode = InspectorGridHexagonNodeSize.Width

Determines how the size of each hexagon is set in the inspector.

For hexagons the normal nodeSize field doesn't really correspond to anything specific on the hexagon's geometry, so this enum is used to give the user the opportunity to adjust more concrete dimensions of the hexagons without having to pull out a calculator to calculate all the square roots and complicated conversion factors.

This field is only used in the graph inspector, the nodeSize field will always use the same internal units. If you want to set the node size through code then you can use ConvertHexagonSizeToNodeSize.

bool? is2D

Get or set if the graph should be in 2D mode.

float isometricAngle

Angle to use for the isometric projection.

If you are making a 2D isometric game, you may want to use this parameter to adjust the layout of the graph to match your game. This will essentially scale the graph along one of its diagonals to produce something like this:

A perspective view of an isometric graph.

A top down view of an isometric graph. Note that the graph is entirely 2D, there is no perspective in this image.

For commonly used values see StandardIsometricAngle and StandardDimetricAngle.

Usually the angle that you want to use is either 30 degrees (alternatively 90-30 = 60 degrees) or atan(1/sqrt(2)) which is approximately 35.264 degrees (alternatively 90 - 35.264 = 54.736 degrees). You might also want to rotate the graph plus or minus 45 degrees around the Y axis to get the oritientation required for your game.

You can read more about it on the wikipedia page linked below.

int LayerCount

Number of layers in the graph.

For grid graphs this is always 1, for layered grid graphs it can be higher. The nodes array has the size width*depth*layerCount.

float maxClimb

The max y coordinate difference between two nodes to enable a connection.

int MaxLayers

float maxSlope = 90

The max slope in degrees for a node to be walkable.

float maxStepHeight = 0.4F

The max y coordinate difference between two nodes to enable a connection.

Set to 0 to ignore the value.

This affects for example how the graph is generated around ledges and stairs.

bool maxStepUsesSlope = true

Take the slope into account for maxClimb.

When this is enabled the normals of the terrain will be used to make more accurate estimates of how large the steps are between adjacent nodes.

When this is disabled then calculated step between two nodes is their y coordinate difference. This may be inaccurate, especially at the start of steep slopes.

In the image below you can see an example of what happens near a ramp. In the topmost image the ramp is not connected with the rest of the graph which is obviously not what we want. In the middle image an attempt has been made to raise the max step height while keeping maxStepUsesSlope disabled. However this causes too many connections to be added. The agent should not be able to go up the ramp from the side. Finally in the bottommost image the maxStepHeight has been restored to the original value but maxStepUsesSlope has been enabled. This configuration handles the ramp in a much smarter way. Note that all the values in the image are just example values, they may be different for your scene.

uint[] neighbourCosts = new uint[8]

Costs to neighbour nodes.

int[] neighbourOffsets = new int[8]

Index offset to get neighbour nodes.

Added to a node's index to get a neighbour node index.

Z
|
|

6 2 5
\ | /
-- 3 - X - 1 ----- X
/ | \
7 0 4

|
|


NumNeighbours neighbours = NumNeighbours.Eight

Number of neighbours for each node.

Either four, six, eight connections per node.

Six connections is primarily for emulating hexagon graphs.

GridNodeBase[] nodes

All nodes in this graph.

Nodes are laid out row by row.

The first node has grid coordinates X=0, Z=0, the second one X=1, Z=0
the last one has grid coordinates X=width-1, Z=depth-1.

var gg = AstarPath.active.data.gridGraph;
int x = 5;
int z = 8;
GridNodeBase node = gg.nodes[z*gg.width + x];


float nodeSize = 1

Size of one node in world units.

bool penaltyAngle

float penaltyAngleFactor = 100F

How much penalty is applied depending on the slope of the terrain.

At a 90 degree slope (not that exactly 90 degree slopes can occur, but almost 90 degree), this penalty is applied. At a 45 degree slope, half of this is applied and so on. Note that you may require very large values, a value of 1000 is equivalent to the cost of moving 1 world unit.

float penaltyAnglePower = 1

How much extra to penalize very steep angles.

bool penaltyPosition

Use position (y-coordinate) to calculate penalty.

float penaltyPositionFactor = 1F

Scale factor for penalty when calculating from position.

float penaltyPositionOffset

Offset for the position when calculating penalty.

Vector3 rotation

Rotation of the grid in degrees.

GridGraphRules rules = new GridGraphRules()

Additional rules to use when scanning the grid graph.

// Get the first grid graph in the scene
var gridGraph = AstarPath.active.data.gridGraph;

gridGraph.rules.AddRule(new RuleAnglePenalty {
penaltyScale = 10000,
curve = AnimationCurve.Linear(0, 0, 90, 1),
});


bool showMeshOutline = true

Show an outline of the grid nodes in the Unity Editor.

bool showMeshSurface = true

Show the surface of the graph.

Each node will be drawn as a square (unless e.g hexagon graph mode has been enabled).

bool showNodeConnections

Show the connections between the grid nodes in the Unity Editor.

Vector2 size

Size of the grid.

Will always be positive and larger than nodeSize.

TextureData textureData = new TextureData()

Holds settings for using a texture as source for a grid graph.

Texure data can be used for fine grained control over how the graph will look. It can be used for positioning, penalty and walkability control.
Below is a screenshot of a grid graph with a penalty map applied. It has the effect of the AI taking the longer path along the green (low penalty) areas.
Color data is got as 0...255 values.

GraphTransform transform

Determines how the graph transforms graph space to world space.

Vector2 unclampedSize

Size of the grid.

Might be negative or smaller than nodeSize

bool uniformEdgeCosts

If true, all edge costs will be set to the same value.

If false, diagonals will cost more. This is useful for a hexagon graph where the diagonals are actually the same length as the normal edges (since the graph has been skewed)

bool uniformWidthDepthGrid

This is placed here so generators inheriting from this one can override it and set it to false.

If it is true, it means that the nodes array's length will always be equal to width*depth It is used mainly in the editor to do auto-scanning calls, setting it to false for a non-uniform grid will reduce the number of scans

bool useJumpPointSearch

Use jump point search to speed up pathfinding.

Jump point search can improve pathfinding performance significantly by making use of some assumptions of the graph. More specifically it assumes a grid graph with no penalties.

int width

Width of the grid in nodes.

int Width

int BATCH_SIZE = 512

const int getNearestForceOverlap = 2

In GetNearestForce, determines how far to search after a valid node has been found.

int[] neighbourXOffsets = { 0, 1, 0, -1, 1, 1, -1, -1 }

Offsets in the X direction for neighbour nodes.

Only 1, 0 or -1

int[] neighbourZOffsets = { -1, 0, 1, 0, -1, 1, 1, -1 }

Offsets in the Z direction for neighbour nodes.

Only 1, 0 or -1

float StandardDimetricAngle = Mathf.Acos(1/2f)*Mathf.Rad2Deg

Commonly used value for isometricAngle.

float StandardIsometricAngle = 90-Mathf.Atan(1/Mathf.Sqrt(2))*Mathf.Rad2Deg

Commonly used value for isometricAngle.

bool USE_BURST = true

bool USE_BURST_UPDATE = true

RecalculationMode

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.

NNInfoInternal GetNearest (

Vector3

position

The position to try to find a close node to

)

Returns the nearest node to a position.

NNInfoInternal GetNearest (

Vector3	position	The position to try to find a close node to
NNConstraint	constraint	Can for example tell the function to try to return a walkable node. If you do not get a good node back, consider calling GetNearestForce.

)

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

void GetNodes (

System.Func<GraphNode, bool>

action

)

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

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.

Matrix4x4 inverseMatrix = Matrix4x4.identity

Inverse of matrix.

Matrix4x4 matrix = Matrix4x4.identity

A matrix for translating/rotating/scaling the graph.

string name

Name of the graph.

Can be set in the unity editor

bool open

Is the graph open in the editor.

void RelocateNodes (

Matrix4x4	oldMatrix
Matrix4x4	newMatrix

)

Moves nodes in this graph.

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

Scan the graph.

void SetMatrix (

Matrix4x4

m

)

Use to set both matrix and inverseMatrix at the same time.

GridNodeBase[] AllocateNodesJob (

int	size
out JobHandle	dependency

)

void CalculateAffectedRegions (

GraphUpdateObject	o
outIntRect	originalRect
outIntRect	affectRect
outIntRect	physicsRect
out bool	willChangeWalkability
out int	erosion

)

void CalculateDimensions (

out int	width
out int	depth
out float	nodeSize

)

Calculates the width/depth of the graph from unclampedSize and nodeSize.

The node size may be changed due to constraints that the width/depth is not allowed to be larger than 1024 (artificial limit).

GraphUpdateThreadingIUpdatableGraph. CanUpdateAsync (

GraphUpdateObject

o

)

bool ClipLineSegmentToBounds (

Vector3	a
Vector3	b
out Vector3	outA
out Vector3	outB

)

Clips a line segment in graph space to the graph bounds.

That is (0,0,0) is the bottom left corner of the graph and (width,0,depth) is the top right corner. The first node is placed at (0.5,y,0.5). One unit distance is the same as nodeSize.

Returns false if the line segment does not intersect the graph at all.

void CreateNavmeshSurfaceVisualization (

GridNodeBase[]	nodes
int	nodeCount
GraphGizmoHelper	helper

)

Draw the surface as well as an outline of the grid graph.

The nodes will be drawn as squares (or hexagons when using neighbours = Six).

long CrossMagnitude (

Int2	a
Int2	b

)

Magnitude of the cross product a x b.

float CrossMagnitude (

Vector2	a
Vector2	b

)

Magnitude of the cross product a x b.

void DeserializeExtraInfo (

GraphSerializationContext

ctx

)

Deserializes graph type specific node data.

void DeserializeNodeSurfaceNormals (

GraphSerializationContext	ctx
GridNodeBase[]	nodes
bool	ignoreForCompatibility

)

void DeserializeSettingsCompatibility (

GraphSerializationContext

ctx

)

An old format for serializing settings.

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

GraphNode

node

)

Internal method used for erosion.

void ErodeNodeWithTags (

GraphNode	node
int	iteration

)

Internal method used for erosion.

void ErodeNodeWithTagsInit (

GraphNode

node

)

Internal method used for erosion.

bool ErosionAnyFalseConnections (

GraphNode

baseNode

)

True if the node has any blocked connections.

For 4 and 8 neighbours the 4 axis aligned connections will be checked. For 6 neighbours all 6 neighbours will be checked.

Internal method used for erosion.

bool exists

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

GridNode GetNodeConnection (

int	index
int	x
int	z
int	dir

)

Get the connecting node from the node at (x,z) in the specified direction.

List<GraphNode> GetNodesInRegion (

Bounds	bounds
GraphUpdateShape	shape

)

All nodes inside the shape or if null, the bounding box.

If a shape is supplied, it is assumed to be contained inside the bounding box.

void HandleBackwardsCompatibility (

GraphSerializationContext

ctx

)

const int HexagonConnectionMask = 0b010101111

Mask based on hexagonNeighbourIndices.

This indicates which connections (out of the 8 standard ones) should be enabled for hexagonal graphs.

int hexagonConnectionMask = 0;
for (int i = 0; i < GridGraph.hexagonNeighbourIndices.Length; i++) hexagonConnectionMask |= 1 << GridGraph.hexagonNeighbourIndices[i];


int[] hexagonNeighbourIndices = { 0, 1, 5, 2, 3, 7 }

Which neighbours are going to be used when neighbours=6.

System.Func<GridNodeBase> newGridNodeDelegate = () => new GridNode()

Delegate which creates and returns a single instance of the node type for this graph.

This may be set in the constructor for graphs inheriting from the GridGraph to change the node type of the graph.

NativeArray<float4> nodeSurfaceNormals

Surface normal for each node.

This needs to be saved when the maxStepUsesSlope option is enabled for graph updates to work.

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

IEnumerable<Progress> ScanInternal ()

Internal method to scan the graph.

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.

IEnumerable<Progress> ScanInternalBurst (

bool

async

)

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.

void SerializeNodeSurfaceNormals (

GraphSerializationContext

ctx

)

void IUpdatableGraph. UpdateArea (

GraphUpdateObject

o

)

Internal function to update an area of the graph.

JobHandleWithMainThreadWork UpdateAreaBurst (

GridNodeBase[]	newNodes
int3	nodeArrayBounds
IntRect	bounds
JobDependencyTracker	dependencyTracker
JobHandle	nodesDependsOn
Allocator	allocationMethod
RecalculationMode	recalculationMode
GraphUpdateObject	graphUpdateObject=null

)

IEnumerator<JobHandle> UpdateAreaBurstCoroutine (

GridNodeBase[]	newNodes
int3	nodeArrayBounds
IntRect	rect
JobDependencyTracker	dependencyTracker
JobHandle	nodesDependsOn
Allocator	allocationMethod
RecalculationMode	recalculationMode
GraphUpdateObject	graphUpdateObject

)

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

o

)

May be called on the Unity thread after executing the update.

JobHandleWithMainThreadWork UpdateRegion (

IntRect	bounds
JobDependencyTracker	dependencyTracker
Allocator	allocator
JobHandle	dependsOn=default

)

bool useRaycastNormal

Use heigh raycasting normal for max slope calculation.

True if maxSlope is less than 90 degrees.