public void DebugDraw(ref Matrix drawMatrix, MyWingedEdgeMesh mesh)
{
Dictionary <Vector3I, int> .Enumerator enumerator = this.m_outerEdgePoints.EnumerateBins();
for (int i = 0; enumerator.MoveNext(); i++)
{
int binIndex = MyCestmirDebugInputComponent.BinIndex;
if ((binIndex == this.m_outerEdgePoints.InvalidIndex) || (i == binIndex))
{
BoundingBoxD xd;
BoundingBoxD xd2;
Vector3I key = enumerator.Current.Key;
int index = enumerator.Current.Value;
this.m_outerEdgePoints.GetLocalBinBB(ref key, out xd);
xd2.Min = Vector3D.Transform(xd.Min, drawMatrix);
xd2.Max = Vector3D.Transform(xd.Max, drawMatrix);
while (true)
{
if (index == this.m_outerEdgePoints.InvalidIndex)
{
MyRenderProxy.DebugDrawAABB(xd2, Color.PowderBlue, 1f, 1f, false, false, false);
break;
}
Vector3 point = this.m_outerEdgePoints.GetPoint(index);
MyWingedEdgeMesh.Edge edge = mesh.GetEdge(this.m_outerEdgePoints.GetData(index).EdgeIndex);
Vector3 vertexPosition = mesh.GetVertexPosition(edge.Vertex2);
Vector3D pointTo = Vector3D.Transform(point, drawMatrix);
MyRenderProxy.DebugDrawArrow3D(Vector3D.Transform((mesh.GetVertexPosition(edge.Vertex1) + vertexPosition) * 0.5f, drawMatrix), pointTo, Color.Yellow, new Color?(Color.Yellow), false, 0.1, null, 0.5f, false);
index = this.m_outerEdgePoints.GetNextBinIndex(index);
}
}
}
}
public void GetEdgeVertices(int index, out Vector3 pred, out Vector3 succ)
{
MyWingedEdgeMesh mesh = this.m_navMesh.Mesh;
MyWingedEdgeMesh.Edge edge = mesh.GetEdge(this.GetEdgeIndex(index));
pred = mesh.GetVertexPosition(edge.GetFacePredVertex(this.m_triIndex));
succ = mesh.GetVertexPosition(edge.GetFaceSuccVertex(this.m_triIndex));
}
public void GetEdgeVertices(int index, out Vector3 pred, out Vector3 succ)
{
MyWingedEdgeMesh mesh = m_navMesh.Mesh;
int i = GetEdgeIndex(index);
MyWingedEdgeMesh.Edge edge = mesh.GetEdge(i);
pred = mesh.GetVertex(edge.GetFacePredVertex(m_triIndex));
succ = mesh.GetVertex(edge.GetFaceSuccVertex(m_triIndex));
}
protected MyNavigationTriangle AddTriangle(ref Vector3 A, ref Vector3 B, ref Vector3 C, ref int edgeAB, ref int edgeBC, ref int edgeCA)
{
MyNavigationTriangle userData = this.m_triPool.Allocate();
int num = ((0 + ((edgeAB == -1) ? 1 : 0)) + ((edgeBC == -1) ? 1 : 0)) + ((edgeCA == -1) ? 1 : 0);
int triangleIndex = -1;
if (num == 3)
{
triangleIndex = this.m_mesh.MakeNewTriangle(userData, ref A, ref B, ref C, out edgeAB, out edgeBC, out edgeCA);
}
else if (num == 2)
{
triangleIndex = (edgeAB == -1) ? ((edgeBC == -1) ? this.m_mesh.ExtrudeTriangleFromEdge(ref B, edgeCA, userData, out edgeAB, out edgeBC) : this.m_mesh.ExtrudeTriangleFromEdge(ref A, edgeBC, userData, out edgeCA, out edgeAB)) : this.m_mesh.ExtrudeTriangleFromEdge(ref C, edgeAB, userData, out edgeBC, out edgeCA);
}
else if (num == 1)
{
triangleIndex = (edgeAB != -1) ? ((edgeBC != -1) ? this.GetTriangleOneNewEdge(ref edgeCA, ref edgeAB, ref edgeBC, userData) : this.GetTriangleOneNewEdge(ref edgeBC, ref edgeCA, ref edgeAB, userData)) : this.GetTriangleOneNewEdge(ref edgeAB, ref edgeBC, ref edgeCA, userData);
}
else
{
MyWingedEdgeMesh.Edge other = this.m_mesh.GetEdge(edgeAB);
MyWingedEdgeMesh.Edge edge = this.m_mesh.GetEdge(edgeBC);
MyWingedEdgeMesh.Edge edge3 = this.m_mesh.GetEdge(edgeCA);
int sharedB = edge3.TryGetSharedVertex(ref other);
int sharedC = other.TryGetSharedVertex(ref edge);
int num5 = edge.TryGetSharedVertex(ref edge3);
int num6 = ((0 + ((sharedB == -1) ? 0 : 1)) + ((sharedC == -1) ? 0 : 1)) + ((num5 == -1) ? 0 : 1);
if (num6 == 3)
{
triangleIndex = this.m_mesh.MakeFace(userData, edgeAB);
}
else if (num6 == 2)
{
triangleIndex = (sharedB != -1) ? ((sharedC != -1) ? this.GetTriangleTwoSharedVertices(edgeCA, edgeAB, ref edgeBC, sharedB, sharedC, userData) : this.GetTriangleTwoSharedVertices(edgeBC, edgeCA, ref edgeAB, num5, sharedB, userData)) : this.GetTriangleTwoSharedVertices(edgeAB, edgeBC, ref edgeCA, sharedC, num5, userData);
}
else if (num6 == 1)
{
triangleIndex = (sharedB == -1) ? ((sharedC == -1) ? this.GetTriangleOneSharedVertex(edgeBC, edgeCA, ref edgeAB, num5, userData) : this.GetTriangleOneSharedVertex(edgeAB, edgeBC, ref edgeCA, sharedC, userData)) : this.GetTriangleOneSharedVertex(edgeCA, edgeAB, ref edgeBC, sharedB, userData);
}
else
{
int num7;
int num8;
triangleIndex = this.m_mesh.ExtrudeTriangleFromEdge(ref C, edgeAB, userData, out num7, out num8);
this.m_mesh.MergeEdges(num8, edgeCA);
this.m_mesh.MergeEdges(num7, edgeBC);
}
}
userData.Init(this, triangleIndex);
return(userData);
}
public override IMyPathVertex <MyNavigationPrimitive> GetOwnNeighbor(int index)
{
int i = GetEdgeIndex(index);
MyWingedEdgeMesh.Edge edge = m_navMesh.Mesh.GetEdge(i);
int neighborIndex = edge.OtherFace(m_triIndex);
if (neighborIndex != -1)
{
return(m_navMesh.Mesh.GetFace(neighborIndex).GetUserData <MyNavigationPrimitive>());
}
else
{
return(null);
}
}
private void CheckOuterEdgeConsistency()
{
if (DO_CONSISTENCY_CHECKS)
{
foreach (MyTuple <MyVoxelConnectionHelper.OuterEdgePoint, Vector3> local1 in new List <MyTuple <MyVoxelConnectionHelper.OuterEdgePoint, Vector3> >())
{
int edgeIndex = local1.Item1.EdgeIndex;
MyWingedEdgeMesh.Edge edge = base.Mesh.GetEdge(edgeIndex);
if (local1.Item1.FirstPoint)
{
edge.GetFaceSuccVertex(-1);
continue;
}
edge.GetFacePredVertex(-1);
}
}
}
private int GetTriangleOneNewEdge(ref int newEdge, ref int succ, ref int pred, MyNavigationTriangle newTri)
{
MyWingedEdgeMesh.Edge edge = this.m_mesh.GetEdge(pred);
MyWingedEdgeMesh.Edge other = this.m_mesh.GetEdge(succ);
int vertex = edge.TryGetSharedVertex(ref other);
if (vertex != -1)
{
int num3 = edge.OtherVertex(vertex);
return(this.m_mesh.MakeEdgeFace(num3, other.OtherVertex(vertex), pred, succ, newTri, out newEdge));
}
int num2 = succ;
Vector3 vertexPosition = this.m_mesh.GetVertexPosition(other.GetFacePredVertex(-1));
this.m_mesh.MergeEdges(num2, succ);
return(this.m_mesh.ExtrudeTriangleFromEdge(ref vertexPosition, pred, newTri, out newEdge, out succ));
}
public bool IsEdgeVertexDangerous(int index, bool predVertex)
{
MyWingedEdgeMesh mesh = this.m_navMesh.Mesh;
int edgeIndex = this.GetEdgeIndex(index);
MyWingedEdgeMesh.Edge edge = mesh.GetEdge(edgeIndex);
int vertexIndex = predVertex ? edge.GetFacePredVertex(this.m_triIndex) : edge.GetFaceSuccVertex(this.m_triIndex);
while (!IsTriangleDangerous(edge.VertexLeftFace(vertexIndex)))
{
int nextVertexEdge = edge.GetNextVertexEdge(vertexIndex);
edge = mesh.GetEdge(nextVertexEdge);
if (nextVertexEdge == edgeIndex)
{
return(false);
}
}
return(true);
}
public MyNavigationEdge GetNavigationEdge(int index)
{
MyWingedEdgeMesh mesh = this.m_navMesh.Mesh;
int edgeIndex = this.GetEdgeIndex(index);
MyWingedEdgeMesh.Edge edge = mesh.GetEdge(edgeIndex);
MyNavigationTriangle triA = null;
MyNavigationTriangle triB = null;
if (edge.LeftFace != -1)
{
triA = mesh.GetFace(edge.LeftFace).GetUserData <MyNavigationTriangle>();
}
if (edge.RightFace != -1)
{
triB = mesh.GetFace(edge.RightFace).GetUserData <MyNavigationTriangle>();
}
MyNavigationEdge.Static.Init(triA, triB, edgeIndex);
return(MyNavigationEdge.Static);
}
/// <summary>
/// Whether it's dangerous for the bot to navigate close to this edge
/// </summary>
public bool IsEdgeVertexDangerous(int index, bool predVertex)
{
MyWingedEdgeMesh mesh = m_navMesh.Mesh;
int i = GetEdgeIndex(index);
int e = i;
MyWingedEdgeMesh.Edge edge = mesh.GetEdge(e);
int v = predVertex ? edge.GetFacePredVertex(m_triIndex) : edge.GetFaceSuccVertex(m_triIndex);
do
{
if (IsTriangleDangerous(edge.VertexLeftFace(v)))
{
return(true);
}
e = edge.GetNextVertexEdge(v);
edge = mesh.GetEdge(e);
} while (e != i);
return(false);
}
public override unsafe void DebugDraw(ref Matrix drawMatrix)
{
if (MyFakes.DEBUG_DRAW_NAVMESH_PROCESSED_VOXEL_CELLS)
{
Vector3 vector = Vector3.TransformNormal(this.m_cellSize, (Matrix)drawMatrix);
Vector3 vector2 = Vector3.Transform((Vector3)(this.m_voxelMap.PositionLeftBottomCorner - this.m_voxelMap.PositionComp.GetPosition()), (Matrix)drawMatrix);
foreach (Vector3I vectori in this.m_processedCells)
{
BoundingBoxD xd;
xd.Min = vector2 + (vector * (new Vector3(0.0625f) + vectori));
BoundingBoxD *xdPtr1 = (BoundingBoxD *)ref xd;
xdPtr1->Max = xd.Min + vector;
xd.Inflate((double)-0.20000000298023224);
MyRenderProxy.DebugDrawAABB(xd, Color.Orange, 1f, 1f, false, false, false);
MyRenderProxy.DebugDrawText3D(xd.Center, vectori.ToString(), Color.Orange, 0.5f, false, MyGuiDrawAlignEnum.HORISONTAL_LEFT_AND_VERTICAL_TOP, -1, false);
}
}
if (MyFakes.DEBUG_DRAW_NAVMESH_CELLS_ON_PATHS)
{
Vector3 vector3 = Vector3.TransformNormal(this.m_cellSize, (Matrix)drawMatrix);
Vector3 vector4 = Vector3.Transform((Vector3)(this.m_voxelMap.PositionLeftBottomCorner - this.m_voxelMap.PositionComp.GetPosition()), (Matrix)drawMatrix);
MyCellCoord coord = new MyCellCoord();
foreach (ulong num in this.m_cellsOnWayCoords)
{
BoundingBoxD xd2;
coord.SetUnpack(num);
Vector3I coordInLod = coord.CoordInLod;
xd2.Min = vector4 + (vector3 * (new Vector3(0.0625f) + coordInLod));
BoundingBoxD *xdPtr2 = (BoundingBoxD *)ref xd2;
xdPtr2->Max = xd2.Min + vector3;
xd2.Inflate((double)-0.30000001192092896);
MyRenderProxy.DebugDrawAABB(xd2, Color.Green, 1f, 1f, false, false, false);
}
}
if (MyFakes.DEBUG_DRAW_NAVMESH_PREPARED_VOXEL_CELLS)
{
Vector3 vector5 = Vector3.TransformNormal(this.m_cellSize, (Matrix)drawMatrix);
Vector3 vector6 = Vector3.Transform((Vector3)(this.m_voxelMap.PositionLeftBottomCorner - this.m_voxelMap.PositionComp.GetPosition()), (Matrix)drawMatrix);
float negativeInfinity = float.NegativeInfinity;
Vector3I zero = Vector3I.Zero;
int index = 0;
while (true)
{
if (index >= this.m_toAdd.Count)
{
for (int i = 0; i < this.m_toAdd.Count; i++)
{
BoundingBoxD xd3;
CellToAddHeapItem local1 = this.m_toAdd.GetItem(i);
float num6 = local1.HeapKey;
Vector3I position = local1.Position;
xd3.Min = vector6 + (vector5 * (new Vector3(0.0625f) + position));
BoundingBoxD *xdPtr3 = (BoundingBoxD *)ref xd3;
xdPtr3->Max = xd3.Min + vector5;
xd3.Inflate((double)-0.10000000149011612);
Color aqua = Color.Aqua;
if (position.Equals(zero))
{
aqua = Color.Red;
}
MyRenderProxy.DebugDrawAABB(xd3, aqua, 1f, 1f, false, false, false);
string text = $"{num6.ToString("n2")}";
MyRenderProxy.DebugDrawText3D(xd3.Center, text, aqua, 0.7f, false, MyGuiDrawAlignEnum.HORISONTAL_LEFT_AND_VERTICAL_TOP, -1, false);
}
break;
}
CellToAddHeapItem item = this.m_toAdd.GetItem(index);
float heapKey = item.HeapKey;
if (heapKey > negativeInfinity)
{
negativeInfinity = heapKey;
zero = item.Position;
}
index++;
}
}
MyRenderProxy.DebugDrawSphere(this.m_debugPos1, 0.2f, Color.Red, 1f, false, false, true, false);
MyRenderProxy.DebugDrawSphere(this.m_debugPos2, 0.2f, Color.Green, 1f, false, false, true, false);
MyRenderProxy.DebugDrawSphere(this.m_debugPos3, 0.1f, Color.Red, 1f, false, false, true, false);
MyRenderProxy.DebugDrawSphere(this.m_debugPos4, 0.1f, Color.Green, 1f, false, false, true, false);
if (MyFakes.DEBUG_DRAW_VOXEL_CONNECTION_HELPER)
{
this.m_connectionHelper.DebugDraw(ref drawMatrix, base.Mesh);
}
if (MyFakes.DEBUG_DRAW_NAVMESH_CELL_BORDERS)
{
foreach (KeyValuePair <ulong, List <DebugDrawEdge> > pair in this.m_debugCellEdges)
{
foreach (DebugDrawEdge edge in pair.Value)
{
MyRenderProxy.DebugDrawLine3D(edge.V1, edge.V2, Color.Orange, Color.Orange, false, false);
}
}
}
else
{
this.m_debugCellEdges.Clear();
}
if (MyFakes.DEBUG_DRAW_NAVMESH_HIERARCHY)
{
if (MyFakes.DEBUG_DRAW_NAVMESH_HIERARCHY_LITE)
{
this.m_higherLevel.DebugDraw(true);
}
else
{
this.m_higherLevel.DebugDraw(false);
this.m_higherLevelHelper.DebugDraw();
}
}
if ((MyDebugDrawSettings.DEBUG_DRAW_NAVMESHES == MyWEMDebugDrawMode.LINES) && !(this.m_voxelMap is MyVoxelPhysics))
{
int num7 = 0;
MyWingedEdgeMesh.EdgeEnumerator edges = base.Mesh.GetEdges(null);
Vector3D position = this.m_voxelMap.PositionComp.GetPosition();
while (edges.MoveNext())
{
MyWingedEdgeMesh.Edge current = edges.Current;
Vector3D vectord2 = base.Mesh.GetVertexPosition(current.Vertex2) + position;
Vector3D point = ((base.Mesh.GetVertexPosition(edges.Current.Vertex1) + position) + vectord2) * 0.5;
if (MyCestmirPathfindingShorts.Pathfinding.Obstacles.IsInObstacle(point))
{
MyRenderProxy.DebugDrawSphere(point, 0.05f, Color.Red, 1f, false, false, true, false);
}
num7++;
}
}
}
protected MyNavigationTriangle GetEdgeTriangle(int edgeIndex)
{
MyWingedEdgeMesh.Edge edge = this.m_mesh.GetEdge(edgeIndex);
return((edge.LeftFace != -1) ? this.GetTriangle(edge.LeftFace) : this.GetTriangle(edge.RightFace));
}
