public override void OnDrawGizmos(Util.RetainedGizmos gizmos, bool drawNodes)
{
base.OnDrawGizmos(gizmos, drawNodes);
if (!drawNodes)
{
return;
}
Gizmos.color = new Color(0.161f, 0.341f, 1f, 0.5f);
if (root != null)
{
DrawChildren(this, root);
}
else if (!string.IsNullOrEmpty(searchTag))
{
var gos = GameObject.FindGameObjectsWithTag(searchTag);
for (var i = 0; i < gos.Length; i++)
{
Gizmos.DrawCube(gos[i].transform.position,
Vector3.one * UnityEditor.HandleUtility.GetHandleSize(gos[i].transform.position) * 0.1F);
}
}
}
void SubmitMeshes(RetainedGizmos gizmos, ulong hash)
{
for (int i = 0; i < meshes.Count; i++)
{
gizmos.meshes.Add(new MeshWithHash {
hash = hash, mesh = meshes[i], lines = false
});
gizmos.existingHashes.Add(hash);
}
}
// Token: 0x06002DB1 RID: 11697 RVA: 0x001D0890 File Offset: 0x001CEA90
public void DrawMesh(RetainedGizmos gizmos, Vector3[] vertices, List <int> triangles, Color[] colors)
{
Mesh mesh = gizmos.GetMesh();
mesh.vertices = vertices;
mesh.SetTriangles(triangles, 0);
mesh.colors = colors;
mesh.UploadMeshData(true);
this.meshes.Add(mesh);
}
public void Init(RetainedGizmos.Hasher hasher, RetainedGizmos gizmos)
{
debugData = PathFindHelper.debugPathData;
debugPathID = PathFindHelper.debugPathID;
debugMode = AstarPath.active.debugMode;
debugFloor = AstarPath.active.debugFloor;
debugRoof = AstarPath.active.debugRoof;
showSearchTree = AstarPath.active.showSearchTree && debugData != null;
this.gizmos = gizmos;
this.hasher = hasher;
builder = ObjectPool <RetainedGizmos.Builder> .Claim();
}
public void DrawMesh(RetainedGizmos gizmos, Vector3[] vertices, List <int> triangles, Color[] colors)
{
var mesh = gizmos.GetMesh();
// Set all data on the mesh
mesh.vertices = vertices;
mesh.SetTriangles(triangles, 0);
mesh.colors = colors;
// Upload all data
mesh.UploadMeshData(false);
meshes.Add(mesh);
}
public void Init(AstarPath active, RetainedGizmos.Hasher hasher, RetainedGizmos gizmos)
{
this.debugData = active.debugPathData;
this.debugPathID = active.debugPathID;
this.debugMode = active.debugMode;
this.debugFloor = active.debugFloor;
this.debugRoof = active.debugRoof;
this.gizmos = gizmos;
this.hasher = hasher;
this.builder = ObjectPool <RetainedGizmos.Builder> .Claim();
this.showSearchTree = (active.showSearchTree && this.debugData != null);
}
public void OnDrawGizmos(Pathfinding.Util.RetainedGizmos gizmos)
{
var hasher = new Pathfinding.Util.RetainedGizmos.Hasher(AstarPath.active);
hasher.AddHash(gizmoVersion);
if (!gizmos.Draw(hasher))
{
var builder = ObjectPool <RetainedGizmos.Builder> .Claim();
var centers = ArrayPool <UnityEngine.Vector3> .Claim(areas.Length);
for (int i = 0; i < areas.Length; i++)
{
Int3 center = Int3.zero;
var childs = children[i];
if (childs.Count > 0)
{
for (int j = 0; j < childs.Count; j++)
{
center += childs[j].position;
}
center /= childs.Count;
centers[i] = (UnityEngine.Vector3)center;
}
}
for (int i = 0; i < areas.Length; i++)
{
if (children[i].Count > 0)
{
for (int j = 0; j < connections[i].Count; j++)
{
if (connections[i][j] > i)
{
builder.DrawLine(centers[i], centers[connections[i][j]], UnityEngine.Color.black);
}
}
}
}
builder.Submit(gizmos, hasher);
}
}
void SubmitLines(RetainedGizmos gizmos, ulong hash)
{
// Unity only supports 65535 vertices per mesh. 65532 used because MaxLineEndPointsPerBatch needs to be even.
const int MaxLineEndPointsPerBatch = 65532 / 2;
int batches = (lines.Count + MaxLineEndPointsPerBatch - 1) / MaxLineEndPointsPerBatch;
for (int batch = 0; batch < batches; batch++)
{
int startIndex = MaxLineEndPointsPerBatch * batch;
int endIndex = Mathf.Min(startIndex + MaxLineEndPointsPerBatch, lines.Count);
int lineEndPointCount = endIndex - startIndex;
UnityEngine.Assertions.Assert.IsTrue(lineEndPointCount % 2 == 0);
// Use pooled lists to avoid excessive allocations
var vertices = ListPool <Vector3> .Claim(lineEndPointCount *2);
var colors = ListPool <Color32> .Claim(lineEndPointCount *2);
var normals = ListPool <Vector3> .Claim(lineEndPointCount *2);
var uv = ListPool <Vector2> .Claim(lineEndPointCount *2);
var tris = ListPool <int> .Claim(lineEndPointCount *3);
// Loop through each endpoint of the lines
// and add 2 vertices for each
for (int j = startIndex; j < endIndex; j++)
{
var vertex = (Vector3)lines[j];
vertices.Add(vertex);
vertices.Add(vertex);
var color = (Color32)lineColors[j];
colors.Add(color);
colors.Add(color);
uv.Add(new Vector2(0, 0));
uv.Add(new Vector2(1, 0));
}
// Loop through each line and add
// one normal for each vertex
for (int j = startIndex; j < endIndex; j += 2)
{
var lineDir = (Vector3)(lines[j + 1] - lines[j]);
// Store the line direction in the normals.
// A line consists of 4 vertices. The line direction will be used to
// offset the vertices to create a line with a fixed pixel thickness
normals.Add(lineDir);
normals.Add(lineDir);
normals.Add(lineDir);
normals.Add(lineDir);
}
// Setup triangle indices
// A triangle consists of 3 indices
// A line (4 vertices) consists of 2 triangles, so 6 triangle indices
for (int j = 0, v = 0; j < lineEndPointCount * 3; j += 6, v += 4)
{
// First triangle
tris.Add(v + 0);
tris.Add(v + 1);
tris.Add(v + 2);
// Second triangle
tris.Add(v + 1);
tris.Add(v + 3);
tris.Add(v + 2);
}
var mesh = gizmos.GetMesh();
// Set all data on the mesh
mesh.SetVertices(vertices);
mesh.SetTriangles(tris, 0);
mesh.SetColors(colors);
mesh.SetNormals(normals);
mesh.SetUVs(0, uv);
// Upload all data
mesh.UploadMeshData(false);
// Release the lists back to the pool
ListPool <Vector3> .Release(ref vertices);
ListPool <Color32> .Release(ref colors);
ListPool <Vector3> .Release(ref normals);
ListPool <Vector2> .Release(ref uv);
ListPool <int> .Release(ref tris);
gizmos.meshes.Add(new MeshWithHash {
hash = hash, mesh = mesh, lines = true
});
gizmos.existingHashes.Add(hash);
}
}
public void Submit(RetainedGizmos gizmos, Hasher hasher)
{
SubmitLines(gizmos, hasher.Hash);
SubmitMeshes(gizmos, hasher.Hash);
}
public static void OnDrawGizmos(this NavmeshBase navmeshBase, Pathfinding.Util.RetainedGizmos gizmos, bool drawNodes)
{
if (!drawNodes)
{
return;
}
using (var helper = gizmos.GetSingleFrameGizmoHelper()) {
var bounds = new Bounds();
bounds.SetMinMax(Vector3.zero, navmeshBase.forcedBoundsSize);
// Draw a write cube using the latest transform
// (this makes the bounds update immediately if some field is changed in the editor)
helper.builder.DrawWireCube(navmeshBase.CalculateTransform(), bounds, Color.white);
}
if (navmeshBase.tiles != null)
{
// Update navmesh vizualizations for
// the tiles that have been changed
for (int i = 0; i < navmeshBase.tiles.Length; i++)
{
// This may happen if an exception has been thrown when the graph was scanned.
// We don't want the gizmo code to start to throw exceptions as well then as
// that would obscure the actual source of the error.
if (navmeshBase.tiles[i] == null)
{
continue;
}
// Calculate a hash of the tile
var hasher = new RetainedGizmos.Hasher(AstarPath.active);
hasher.AddHash(navmeshBase.showMeshOutline ? 1 : 0);
hasher.AddHash(navmeshBase.showMeshSurface ? 1 : 0);
hasher.AddHash(navmeshBase.showNodeConnections ? 1 : 0);
var nodes = navmeshBase.tiles[i].nodes;
for (int j = 0; j < nodes.Length; j++)
{
hasher.HashNode(nodes[j]);
}
if (!gizmos.Draw(hasher))
{
using (var helper = gizmos.GetGizmoHelper(hasher)) {
if (navmeshBase.showMeshSurface || navmeshBase.showMeshOutline)
{
navmeshBase.CreateNavmeshSurfaceVisualization(navmeshBase.tiles[i], helper);
}
if (navmeshBase.showMeshSurface || navmeshBase.showMeshOutline)
{
CreateNavmeshOutlineVisualization(navmeshBase.tiles[i], helper);
}
if (navmeshBase.showNodeConnections)
{
for (int j = 0; j < nodes.Length; j++)
{
helper.DrawConnections(nodes[j]);
}
}
}
}
gizmos.Draw(hasher);
}
}
if (AstarPath.active.showUnwalkableNodes)
{
navmeshBase.DrawUnwalkableNodes(AstarPath.active.unwalkableNodeDebugSize);
}
}
// Token: 0x06002DB6 RID: 11702 RVA: 0x001D0CC8 File Offset: 0x001CEEC8
private void SubmitLines(RetainedGizmos gizmos, ulong hash)
{
int num = (this.lines.Count + 32766 - 1) / 32766;
for (int i = 0; i < num; i++)
{
int num2 = 32766 * i;
int num3 = Mathf.Min(num2 + 32766, this.lines.Count);
int num4 = num3 - num2;
List <Vector3> list = ListPool <Vector3> .Claim(num4 * 2);
List <Color32> list2 = ListPool <Color32> .Claim(num4 * 2);
List <Vector3> list3 = ListPool <Vector3> .Claim(num4 * 2);
List <Vector2> list4 = ListPool <Vector2> .Claim(num4 * 2);
List <int> list5 = ListPool <int> .Claim(num4 * 3);
for (int j = num2; j < num3; j++)
{
Vector3 item = this.lines[j];
list.Add(item);
list.Add(item);
Color32 item2 = this.lineColors[j];
list2.Add(item2);
list2.Add(item2);
list4.Add(new Vector2(0f, 0f));
list4.Add(new Vector2(1f, 0f));
}
for (int k = num2; k < num3; k += 2)
{
Vector3 item3 = this.lines[k + 1] - this.lines[k];
list3.Add(item3);
list3.Add(item3);
list3.Add(item3);
list3.Add(item3);
}
int l = 0;
int num5 = 0;
while (l < num4 * 3)
{
list5.Add(num5);
list5.Add(num5 + 1);
list5.Add(num5 + 2);
list5.Add(num5 + 1);
list5.Add(num5 + 3);
list5.Add(num5 + 2);
l += 6;
num5 += 4;
}
Mesh mesh = gizmos.GetMesh();
mesh.SetVertices(list);
mesh.SetTriangles(list5, 0);
mesh.SetColors(list2);
mesh.SetNormals(list3);
mesh.SetUVs(0, list4);
mesh.UploadMeshData(true);
ListPool <Vector3> .Release(ref list);
ListPool <Color32> .Release(ref list2);
ListPool <Vector3> .Release(ref list3);
ListPool <Vector2> .Release(ref list4);
ListPool <int> .Release(ref list5);
gizmos.meshes.Add(new RetainedGizmos.MeshWithHash
{
hash = hash,
mesh = mesh,
lines = true
});
gizmos.existingHashes.Add(hash);
}
}
// Token: 0x06002DB4 RID: 11700 RVA: 0x001D0C40 File Offset: 0x001CEE40
public void Submit(RetainedGizmos gizmos, RetainedGizmos.Hasher hasher)
{
this.SubmitLines(gizmos, hasher.Hash);
this.SubmitMeshes(gizmos, hasher.Hash);
}
