/// <summary>
/// Build a tile and link all the polygons togther, both internally and externally.
/// Make sure to link off-mesh connections as well.
/// </summary>
/// <param name="data">Navigation Mesh data</param>
/// <param name="lastRef">Last polygon reference</param>
/// <param name="result">Last tile reference</param>
public void AddTile(NavMeshBuilder data, PolyId lastRef, out PolyId result)
{
result = PolyId.Null;
//make sure data is in right format
PathfindingCommon.NavMeshInfo header = data.Header;
//make sure location is free
if (GetTileAt(header.X, header.Y, header.Layer) != null)
{
return;
}
//allocate a tile
MeshTile tile = null;
if (lastRef == PolyId.Null)
{
if (nextFree != null)
{
tile = nextFree;
nextFree = tile.Next;
tile.Next = null;
}
}
else
{
//try to relocate tile to specific index with the same salt
int tileIndex = lastRef.DecodeTileIndex(polyBits, tileBits);
if (tileIndex >= maxTiles)
{
return;
}
//try to find specific tile id from free list
MeshTile target = tiles[tileIndex];
MeshTile prev = null;
tile = nextFree;
while (tile != null && tile != target)
{
prev = tile;
tile = tile.Next;
}
//couldn't find correct location
if (tile != target)
{
return;
}
//remove from freelist
if (prev == null)
{
nextFree = tile.Next;
}
else
{
prev.Next = tile.Next;
}
//restore salt
tile.Salt = lastRef.DecodeSalt(polyBits, tileBits, saltBits);
}
//make sure we could allocate a tile
if (tile == null)
{
return;
}
//insert tile into position LookUp Table (lut)
int h = ComputeTileHash(header.X, header.Y, tileLookupTableMask);
tile.Next = posLookup[h];
posLookup[h] = tile;
if (header.BvNodeCount == 0)
{
tile.BVTree = null;
}
//patch header
tile.Verts = data.NavVerts;
tile.Polys = data.NavPolys;
tile.DetailMeshes = data.NavDMeshes;
tile.DetailVerts = data.NavDVerts;
tile.DetailTris = data.NavDTris;
tile.BVTree = data.NavBvTree;
tile.OffMeshConnections = data.OffMeshCons;
//build links freelist
tile.LinksFreeList = 0;
tile.Links = new Link[header.MaxLinkCount];
for (int i = 0; i < header.MaxLinkCount; i++)
{
tile.Links[i] = new Link();
}
tile.Links[header.MaxLinkCount - 1].Next = Link.Null;
for (int i = 0; i < header.MaxLinkCount - 1; i++)
{
tile.Links[i].Next = i + 1;
}
//init tile
tile.Header = header;
tile.Data = data;
ConnectIntLinks(ref tile);
BaseOffMeshLinks(ref tile);
//create connections with neighbor tiles
MeshTile[] neis = new MeshTile[32];
int nneis;
//connect with layers in current tile
nneis = GetTilesAt(header.X, header.Y, neis);
for (int j = 0; j < nneis; j++)
{
if (neis[j] != tile)
{
ConnectExtLinks(ref tile, ref neis[j], BoundarySide.Internal);
ConnectExtLinks(ref neis[j], ref tile, BoundarySide.Internal);
}
ConnectExtOffMeshLinks(ref tile, ref neis[j], BoundarySide.Internal);
ConnectExtOffMeshLinks(ref neis[j], ref tile, BoundarySide.Internal);
}
//connect with neighbour tiles
for (int i = 0; i < 8; i++)
{
BoundarySide b = (BoundarySide)i;
BoundarySide bo = b.GetOpposite();
nneis = GetNeighbourTilesAt(header.X, header.Y, b, neis);
for (int j = 0; j < nneis; j++)
{
ConnectExtLinks(ref tile, ref neis[j], b);
ConnectExtLinks(ref neis[j], ref tile, bo);
ConnectExtOffMeshLinks(ref tile, ref neis[j], b);
ConnectExtOffMeshLinks(ref neis[j], ref tile, bo);
}
}
result = GetTileRef(tile);
}
/// <summary>
/// Initializes a new instance of the <see cref="NavMeshBuilder" /> class.
/// Add all the PolyMesh and PolyMeshDetail attributes to the Navigation Mesh.
/// Then, add Off-Mesh connection support.
/// </summary>
/// <param name="polyMesh">The PolyMesh</param>
/// <param name="polyMeshDetail">The PolyMeshDetail</param>
/// <param name="offMeshCons">Offmesh connection data</param>
/// <param name="settings">The settings used to build.</param>
public NavMeshBuilder(PolyMesh polyMesh, PolyMeshDetail polyMeshDetail, OffMeshConnection[] offMeshCons, NavMeshGenerationSettings settings)
{
if (settings.VertsPerPoly > PathfindingCommon.VERTS_PER_POLYGON)
{
throw new InvalidOperationException("The number of vertices per polygon is above SharpNav's limit");
}
if (polyMesh.VertCount == 0)
{
throw new InvalidOperationException("The provided PolyMesh has no vertices.");
}
if (polyMesh.PolyCount == 0)
{
throw new InvalidOperationException("The provided PolyMesh has not polys.");
}
int nvp = settings.VertsPerPoly;
//classify off-mesh connection points
BoundarySide[] offMeshSides = new BoundarySide[offMeshCons.Length * 2];
int storedOffMeshConCount = 0;
int offMeshConLinkCount = 0;
if (offMeshCons.Length > 0)
{
//find height bounds
float hmin = float.MaxValue;
float hmax = -float.MaxValue;
if (polyMeshDetail != null)
{
for (int i = 0; i < polyMeshDetail.VertCount; i++)
{
float h = polyMeshDetail.Verts[i].Y;
hmin = Math.Min(hmin, h);
hmax = Math.Max(hmax, h);
}
}
else
{
for (int i = 0; i < polyMesh.VertCount; i++)
{
PolyVertex iv = polyMesh.Verts[i];
float h = polyMesh.Bounds.Min.Y + iv.Y * settings.CellHeight;
hmin = Math.Min(hmin, h);
hmax = Math.Max(hmax, h);
}
}
hmin -= settings.MaxClimb;
hmax += settings.MaxClimb;
BBox3 bounds = polyMesh.Bounds;
bounds.Min.Y = hmin;
bounds.Max.Y = hmax;
for (int i = 0; i < offMeshCons.Length; i++)
{
Vector3 p0 = offMeshCons[i].Pos0;
Vector3 p1 = offMeshCons[i].Pos1;
offMeshSides[i * 2 + 0] = BoundarySideExtensions.FromPoint(p0, bounds);
offMeshSides[i * 2 + 1] = BoundarySideExtensions.FromPoint(p1, bounds);
//off-mesh start position isn't touching mesh
if (offMeshSides[i * 2 + 0] == BoundarySide.Internal)
{
if (p0.Y < bounds.Min.Y || p0.Y > bounds.Max.Y)
{
offMeshSides[i * 2 + 0] = 0;
}
}
//count number of links to allocate
if (offMeshSides[i * 2 + 0] == BoundarySide.Internal)
{
offMeshConLinkCount++;
}
if (offMeshSides[i * 2 + 1] == BoundarySide.Internal)
{
offMeshConLinkCount++;
}
if (offMeshSides[i * 2 + 0] == BoundarySide.Internal)
{
storedOffMeshConCount++;
}
}
}
//off-mesh connections stored as polygons, adjust values
int totPolyCount = polyMesh.PolyCount + storedOffMeshConCount;
int totVertCount = polyMesh.VertCount + storedOffMeshConCount * 2;
//find portal edges
int edgeCount = 0;
int portalCount = 0;
for (int i = 0; i < polyMesh.PolyCount; i++)
{
PolyMesh.Polygon p = polyMesh.Polys[i];
for (int j = 0; j < nvp; j++)
{
if (p.Vertices[j] == PolyMesh.NullId)
{
break;
}
edgeCount++;
if (PolyMesh.IsBoundaryEdge(p.NeighborEdges[j]))
{
int dir = p.NeighborEdges[j] % 16;
if (dir != 15)
{
portalCount++;
}
}
}
}
int maxLinkCount = edgeCount + portalCount * 2 + offMeshConLinkCount * 2;
//find unique detail vertices
int uniqueDetailVertCount = 0;
int detailTriCount = 0;
if (polyMeshDetail != null)
{
detailTriCount = polyMeshDetail.TrisCount;
for (int i = 0; i < polyMesh.PolyCount; i++)
{
int numDetailVerts = polyMeshDetail.Meshes[i].VertexCount;
int numPolyVerts = polyMesh.Polys[i].VertexCount;
uniqueDetailVertCount += numDetailVerts - numPolyVerts;
}
}
else
{
uniqueDetailVertCount = 0;
detailTriCount = 0;
for (int i = 0; i < polyMesh.PolyCount; i++)
{
int numPolyVerts = polyMesh.Polys[i].VertexCount;
uniqueDetailVertCount += numPolyVerts - 2;
}
}
//allocate data
header = new PathfindingCommon.NavMeshInfo();
navVerts = new Vector3[totVertCount];
navPolys = new Poly[totPolyCount];
navDMeshes = new PolyMeshDetail.MeshData[polyMesh.PolyCount];
navDVerts = new Vector3[uniqueDetailVertCount];
navDTris = new PolyMeshDetail.TriangleData[detailTriCount];
offMeshConnections = new OffMeshConnection[storedOffMeshConCount];
//store header
//HACK TiledNavMesh should figure out the X/Y/layer instead of the user maybe?
header.X = 0;
header.Y = 0;
header.Layer = 0;
header.PolyCount = totPolyCount;
header.VertCount = totVertCount;
header.MaxLinkCount = maxLinkCount;
header.Bounds = polyMesh.Bounds;
header.DetailMeshCount = polyMesh.PolyCount;
header.DetailVertCount = uniqueDetailVertCount;
header.DetailTriCount = detailTriCount;
header.OffMeshBase = polyMesh.PolyCount;
header.WalkableHeight = settings.AgentHeight;
header.WalkableRadius = settings.AgentRadius;
header.WalkableClimb = settings.MaxClimb;
header.OffMeshConCount = storedOffMeshConCount;
header.BvNodeCount = settings.BuildBoundingVolumeTree ? polyMesh.PolyCount * 2 : 0;
header.BvQuantFactor = 1f / settings.CellSize;
int offMeshVertsBase = polyMesh.VertCount;
int offMeshPolyBase = polyMesh.PolyCount;
//store vertices
for (int i = 0; i < polyMesh.VertCount; i++)
{
PolyVertex iv = polyMesh.Verts[i];
navVerts[i].X = polyMesh.Bounds.Min.X + iv.X * settings.CellSize;
navVerts[i].Y = polyMesh.Bounds.Min.Y + iv.Y * settings.CellHeight;
navVerts[i].Z = polyMesh.Bounds.Min.Z + iv.Z * settings.CellSize;
}
//off-mesh link vertices
int n = 0;
for (int i = 0; i < offMeshCons.Length; i++)
{
//only store connections which start from this tile
if (offMeshSides[i * 2 + 0] == BoundarySide.Internal)
{
navVerts[offMeshVertsBase + (n * 2 + 0)] = offMeshCons[i].Pos0;
navVerts[offMeshVertsBase + (n * 2 + 1)] = offMeshCons[i].Pos1;
n++;
}
}
//store polygons
for (int i = 0; i < polyMesh.PolyCount; i++)
{
navPolys[i] = new Poly();
navPolys[i].VertCount = 0;
navPolys[i].Tag = polyMesh.Polys[i].Tag;
navPolys[i].Area = polyMesh.Polys[i].Area;
navPolys[i].PolyType = PolygonType.Ground;
navPolys[i].Verts = new int[nvp];
navPolys[i].Neis = new int[nvp];
for (int j = 0; j < nvp; j++)
{
if (polyMesh.Polys[i].Vertices[j] == PolyMesh.NullId)
{
break;
}
navPolys[i].Verts[j] = polyMesh.Polys[i].Vertices[j];
if (PolyMesh.IsBoundaryEdge(polyMesh.Polys[i].NeighborEdges[j]))
{
//border or portal edge
int dir = polyMesh.Polys[i].NeighborEdges[j] % 16;
if (dir == 0xf) //border
{
navPolys[i].Neis[j] = 0;
}
else if (dir == 0) //portal x-
{
navPolys[i].Neis[j] = Link.External | 4;
}
else if (dir == 1) //portal z+
{
navPolys[i].Neis[j] = Link.External | 2;
}
else if (dir == 2) //portal x+
{
navPolys[i].Neis[j] = Link.External | 0;
}
else if (dir == 3) //portal z-
{
navPolys[i].Neis[j] = Link.External | 6;
}
}
else
{
//normal connection
navPolys[i].Neis[j] = polyMesh.Polys[i].NeighborEdges[j] + 1;
}
navPolys[i].VertCount++;
}
}
//off-mesh connection vertices
n = 0;
for (int i = 0; i < offMeshCons.Length; i++)
{
//only store connections which start from this tile
if (offMeshSides[i * 2 + 0] == BoundarySide.Internal)
{
navPolys[offMeshPolyBase + n].VertCount = 2;
navPolys[offMeshPolyBase + n].Verts = new int[nvp];
navPolys[offMeshPolyBase + n].Verts[0] = offMeshVertsBase + (n * 2 + 0);
navPolys[offMeshPolyBase + n].Verts[1] = offMeshVertsBase + (n * 2 + 1);
navPolys[offMeshPolyBase + n].Tag = offMeshCons[i].Flags;
navPolys[offMeshPolyBase + n].Area = polyMesh.Polys[offMeshCons[i].Poly].Area; //HACK is this correct?
navPolys[offMeshPolyBase + n].PolyType = PolygonType.OffMeshConnection;
n++;
}
}
//store detail meshes and vertices
if (polyMeshDetail != null)
{
int vbase = 0;
List <Vector3> storedDetailVerts = new List <Vector3>();
for (int i = 0; i < polyMesh.PolyCount; i++)
{
int vb = polyMeshDetail.Meshes[i].VertexIndex;
int numDetailVerts = polyMeshDetail.Meshes[i].VertexCount;
int numPolyVerts = navPolys[i].VertCount;
navDMeshes[i].VertexIndex = vbase;
navDMeshes[i].VertexCount = numDetailVerts - numPolyVerts;
navDMeshes[i].TriangleIndex = polyMeshDetail.Meshes[i].TriangleIndex;
navDMeshes[i].TriangleCount = polyMeshDetail.Meshes[i].TriangleCount;
//Copy detail vertices
//first 'nv' verts are equal to nav poly verts
//the rest are detail verts
for (int j = 0; j < navDMeshes[i].VertexCount; j++)
{
storedDetailVerts.Add(polyMeshDetail.Verts[vb + numPolyVerts + j]);
}
vbase += numDetailVerts - numPolyVerts;
}
navDVerts = storedDetailVerts.ToArray();
//store triangles
for (int j = 0; j < polyMeshDetail.TrisCount; j++)
{
navDTris[j] = polyMeshDetail.Tris[j];
}
}
else
{
//create dummy detail mesh by triangulating polys
int tbase = 0;
for (int i = 0; i < polyMesh.PolyCount; i++)
{
int numPolyVerts = navPolys[i].VertCount;
navDMeshes[i].VertexIndex = 0;
navDMeshes[i].VertexCount = 0;
navDMeshes[i].TriangleIndex = tbase;
navDMeshes[i].TriangleCount = numPolyVerts - 2;
//triangulate polygon
for (int j = 2; j < numPolyVerts; j++)
{
navDTris[tbase].VertexHash0 = 0;
navDTris[tbase].VertexHash1 = j - 1;
navDTris[tbase].VertexHash2 = j;
//bit for each edge that belongs to the poly boundary
navDTris[tbase].Flags = 1 << 2;
if (j == 2)
{
navDTris[tbase].Flags |= 1 << 0;
}
if (j == numPolyVerts - 1)
{
navDTris[tbase].Flags |= 1 << 4;
}
tbase++;
}
}
}
//store and create BV tree
if (settings.BuildBoundingVolumeTree)
{
//build tree
navBvTree = new BVTree(polyMesh.Verts, polyMesh.Polys, nvp, settings.CellSize, settings.CellHeight);
}
//store off-mesh connections
n = 0;
for (int i = 0; i < offMeshConnections.Length; i++)
{
//only store connections which start from this tile
if (offMeshSides[i * 2 + 0] == BoundarySide.Internal)
{
offMeshConnections[n].Poly = offMeshPolyBase + n;
//copy connection end points
offMeshConnections[n].Pos0 = offMeshCons[i].Pos0;
offMeshConnections[n].Pos1 = offMeshCons[i].Pos1;
offMeshConnections[n].Radius = offMeshCons[i].Radius;
offMeshConnections[n].Flags = offMeshCons[i].Flags;
offMeshConnections[n].Side = offMeshSides[i * 2 + 1];
offMeshConnections[n].Tag = offMeshCons[i].Tag;
n++;
}
}
}
/// <summary>
/// Build a tile and link all the polygons togther, both internally and externally.
/// Make sure to link off-mesh connections as well.
/// </summary>
/// <param name="data">Navigation Mesh data</param>
/// <param name="lastRef">Last polygon reference</param>
/// <param name="result">Last tile reference</param>
public PolyId AddTile(NavMeshBuilder data)
{
//make sure data is in right format
PathfindingCommon.NavMeshInfo header = data.Header;
//make sure location is free
if (GetTileAt(header.X, header.Y, header.Layer) != null)
{
return(PolyId.Null);
}
PolyId newTileId = GetNextTileRef();
MeshTile tile = new MeshTile(new Vector2i(header.X, header.Y), header.Layer, idManager, newTileId);
tile.Salt = idManager.DecodeSalt(ref newTileId);
if (header.BvNodeCount == 0)
{
tile.BVTree = null;
}
//patch header
tile.Verts = data.NavVerts;
tile.Polys = data.NavPolys;
tile.PolyCount = header.PolyCount;
tile.DetailMeshes = data.NavDMeshes;
tile.DetailVerts = data.NavDVerts;
tile.DetailTris = data.NavDTris;
tile.BVTree = data.NavBvTree;
tile.OffMeshConnections = data.OffMeshCons;
tile.OffMeshConnectionCount = header.OffMeshConCount;
tile.BvQuantFactor = header.BvQuantFactor;
tile.BvNodeCount = header.BvNodeCount;
tile.Bounds = header.Bounds;
tile.WalkableClimb = header.WalkableClimb;
//create connections within tile
tile.ConnectIntLinks();
tile.BaseOffMeshLinks();
//create connections with neighbor tiles
//connect with layers in current tile
foreach (MeshTile layerTile in GetTilesAt(header.X, header.Y))
{
if (layerTile != tile)
{
tile.ConnectExtLinks(layerTile, BoundarySide.Internal);
layerTile.ConnectExtLinks(tile, BoundarySide.Internal);
}
tile.ConnectExtOffMeshLinks(layerTile, BoundarySide.Internal);
layerTile.ConnectExtOffMeshLinks(tile, BoundarySide.Internal);
}
//connect with neighbor tiles
for (int i = 0; i < 8; i++)
{
BoundarySide b = (BoundarySide)i;
BoundarySide bo = b.GetOpposite();
foreach (MeshTile neighborTile in GetNeighborTilesAt(header.X, header.Y, b))
{
tile.ConnectExtLinks(neighborTile, b);
neighborTile.ConnectExtLinks(tile, bo);
tile.ConnectExtOffMeshLinks(neighborTile, b);
neighborTile.ConnectExtOffMeshLinks(tile, bo);
}
}
AddTileAt(tile, GetNextTileRef());
return(newTileId);
}
