/** Async method for moving the graph */
IEnumerator UpdateGraphCoroutine () {
// Find the direction
// that we want to move the graph in.
// Calcuculate this in graph space (where a distance of one is the size of one node)
Vector3 dir = PointToGraphSpace(target.position) - PointToGraphSpace(graph.center);
// Snap to a whole number of nodes
dir.x = Mathf.Round(dir.x);
dir.z = Mathf.Round(dir.z);
dir.y = 0;
// Nothing do to
if ( dir == Vector3.zero ) yield break;
// Number of nodes to offset in each direction
Int2 offset = new Int2(-Mathf.RoundToInt(dir.x), -Mathf.RoundToInt(dir.z));
// Move the center (this is in world units, so we need to convert it back from graph space)
graph.center += graph.matrix.MultiplyVector (dir);
graph.GenerateMatrix ();
// Create a temporary buffer
// required for the calculations
if ( tmp == null || tmp.Length != graph.nodes.Length ) {
tmp = new GridNode[graph.nodes.Length];
}
// Cache some variables for easier access
int width = graph.width;
int depth = graph.depth;
GridNode[] nodes = graph.nodes;
// Check if we have moved
// less than a whole graph
// width in any direction
if ( Mathf.Abs(offset.x) <= width && Mathf.Abs(offset.y) <= depth ) {
// Offset each node by the #offset variable
// nodes which would end up outside the graph
// will wrap around to the other side of it
for ( int z=0; z < depth; z++ ) {
int pz = z*width;
int tz = ((z+offset.y + depth)%depth)*width;
for ( int x=0; x < width; x++ ) {
tmp[tz + ((x+offset.x + width) % width)] = nodes[pz + x];
}
}
yield return null;
// Copy the nodes back to the graph
// and set the correct indices
for ( int z=0; z < depth; z++ ) {
int pz = z*width;
for ( int x=0; x < width; x++ ) {
GridNode node = tmp[pz + x];
node.NodeInGridIndex = pz + x;
nodes[pz + x] = node;
}
}
IntRect r = new IntRect ( 0, 0, offset.x, offset.y );
int minz = r.ymax;
int maxz = depth;
// If offset.x < 0, adjust the rect
if ( r.xmin > r.xmax ) {
int tmp2 = r.xmax;
r.xmax = width + r.xmin;
r.xmin = width + tmp2;
}
// If offset.y < 0, adjust the rect
if ( r.ymin > r.ymax ) {
int tmp2 = r.ymax;
r.ymax = depth + r.ymin;
r.ymin = depth + tmp2;
minz = 0;
maxz = r.ymin;
}
// Make sure erosion is taken into account
// Otherwise we would end up with ugly artifacts
r = r.Expand ( graph.erodeIterations + 1 );
// Makes sure the rect stays inside the grid
r = IntRect.Intersection ( r, new IntRect ( 0, 0, width, depth ) );
yield return null;
// Update all nodes along one edge of the graph
// With the same width as the rect
for ( int z = r.ymin; z < r.ymax; z++ ) {
for ( int x = 0; x < width; x++ ) {
graph.UpdateNodePositionCollision ( nodes[z*width + x], x, z, false );
}
}
yield return null;
// Update all nodes along the other edge of the graph
// With the same width as the rect
for ( int z = minz; z < maxz; z++ ) {
for ( int x = r.xmin; x < r.xmax; x++ ) {
graph.UpdateNodePositionCollision ( nodes[z*width + x], x, z, false );
}
}
yield return null;
// Calculate all connections for the nodes
// that might have changed
for ( int z = r.ymin; z < r.ymax; z++ ) {
for ( int x = 0; x < width; x++ ) {
graph.CalculateConnections (nodes, x, z, nodes[z*width+x]);
}
}
yield return null;
// Calculate all connections for the nodes
// that might have changed
for ( int z = minz; z < maxz; z++ ) {
for ( int x = r.xmin; x < r.xmax; x++ ) {
graph.CalculateConnections (nodes, x, z, nodes[z*width+x]);
}
}
yield return null;
// Calculate all connections for the nodes along the boundary
// of the graph, these always need to be updated
/** \todo Optimize to not traverse all nodes in the graph, only those at the edges */
for ( int z = 0; z < depth; z++ ) {
for ( int x = 0; x < width; x++ ) {
if ( x == 0 || z == 0 || x >= width-1 || z >= depth-1 ) graph.CalculateConnections (nodes, x, z, nodes[z*width+x]);
}
}
} else {
// Just update all nodes
for ( int z = 0; z < depth; z++ ) {
for ( int x = 0; x < width; x++ ) {
graph.UpdateNodePositionCollision ( nodes[z*width + x], x, z, false );
}
}
// Recalculate the connections of all nodes
for ( int z = 0; z < depth; z++ ) {
for ( int x = 0; x < width; x++ ) {
graph.CalculateConnections (nodes, x, z, nodes[z*width+x]);
}
}
}
if ( floodFill ) {
yield return null;
// Make sure the areas for the graph
// have been recalculated
// not doing this can cause pathfinding to fail
AstarPath.active.QueueWorkItemFloodFill ();
}
}
public void UpdateArea (GraphUpdateObject guo) {
Bounds b = guo.bounds;
b.center -= forcedBounds.min;
//Figure out which tiles are affected
var r = new IntRect (Mathf.FloorToInt (b.min.x / (tileSizeX*cellSize)), Mathf.FloorToInt (b.min.z / (tileSizeZ*cellSize)), Mathf.FloorToInt (b.max.x / (tileSizeX*cellSize)), Mathf.FloorToInt (b.max.z / (tileSizeZ*cellSize)));
//Clamp to bounds
r = IntRect.Intersection (r, new IntRect (0,0,tileXCount-1,tileZCount-1));
if (!guo.updatePhysics) {
for ( int z=r.ymin;z<=r.ymax;z++) {
for ( int x=r.xmin;x<=r.xmax;x++) {
NavmeshTile tile = tiles[z*tileXCount + x];
tile.flag = true;
}
}
for ( int z=r.ymin;z<=r.ymax;z++) {
for ( int x=r.xmin;x<=r.xmax;x++) {
NavmeshTile tile = tiles[z*tileXCount + x];
if ( tile.flag ) {
tile.flag = false;
NavMeshGraph.UpdateArea (guo, tile);
}
}
}
return;
}
if (!dynamic) {
throw new System.Exception ("Recast graph must be marked as dynamic to enable graph updates with updatePhysics = true");
}
Voxelize vox = globalVox;
if (vox == null) {
throw new System.InvalidOperationException ("No Voxelizer object. UpdateAreaInit should have been called before this function.");
}
AstarProfiler.StartProfile ("Init");
/** \bug No bounds checking */
//r.DebugDraw (Matrix4x4.TRS (forcedBounds.min, Quaternion.identity, new Vector3 (tileSize*cellSize, 1, tileSize*cellSize)), Color.red);
//Debug.Break ();
AstarProfiler.StartProfile ("RemoveConnections");
for (int x=r.xmin;x<=r.xmax;x++) {
for (int z=r.ymin;z<=r.ymax;z++) {
RemoveConnectionsFromTile (tiles[x + z*tileXCount]);
}
}
AstarProfiler.EndProfile ("RemoveConnections");
AstarProfiler.StartProfile ("Build Tiles");
for (int x=r.xmin;x<=r.xmax;x++) {
for (int z=r.ymin;z<=r.ymax;z++) {
BuildTileMesh (vox, x,z);
}
}
AstarProfiler.EndProfile ("Build Tiles");
AstarProfiler.StartProfile ("ConnectTiles");
uint graphIndex = (uint)AstarPath.active.astarData.GetGraphIndex (this);
for (int x=r.xmin;x<=r.xmax;x++) {
for (int z=r.ymin;z<=r.ymax;z++) {
NavmeshTile tile = tiles[x + z*tileXCount];
GraphNode[] nodes = tile.nodes;
for (int i=0;i<nodes.Length;i++) nodes[i].GraphIndex = graphIndex;
}
}
//Connect the newly create tiles with the old tiles and with each other
r = r.Expand (1);
//Clamp to bounds
r = IntRect.Intersection (r, new IntRect (0,0,tileXCount-1,tileZCount-1));
for (int x=r.xmin;x<=r.xmax;x++) {
for (int z=r.ymin;z<=r.ymax;z++) {
if (x < tileXCount-1 && r.Contains (x+1, z)) {
ConnectTiles (tiles[x + z*tileXCount], tiles[x+1 + z*tileXCount]);
}
if (z < tileZCount-1 && r.Contains (x, z+1)) {
ConnectTiles (tiles[x + z*tileXCount], tiles[x + (z+1)*tileXCount]);
}
}
}
AstarProfiler.EndProfile ("ConnectTiles");
AstarProfiler.PrintResults ();
}