using System;
using System.Collections.Generic;
using TriangleNet.Algorithm;
using TriangleNet.Data;
using TriangleNet.Geometry;
using TriangleNet.IO;
using TriangleNet.Log;
using TriangleNet.Smoothing;
using TriangleNet.Tools;

namespace TriangleNet
{
	// Token: 0x0200000E RID: 14
	public class Mesh
	{
		// Token: 0x17000013 RID: 19
		// (get) Token: 0x0600005C RID: 92 RVA: 0x0000B456 File Offset: 0x00009656
		public Behavior Behavior
		{
			get
			{
				return this.behavior;
			}
		}

		// Token: 0x17000014 RID: 20
		// (get) Token: 0x0600005D RID: 93 RVA: 0x0000B45E File Offset: 0x0000965E
		public BoundingBox Bounds
		{
			get
			{
				return this.bounds;
			}
		}

		// Token: 0x17000015 RID: 21
		// (get) Token: 0x0600005E RID: 94 RVA: 0x0000B466 File Offset: 0x00009666
		public ICollection<Vertex> Vertices
		{
			get
			{
				return this.vertices.Values;
			}
		}

		// Token: 0x17000016 RID: 22
		// (get) Token: 0x0600005F RID: 95 RVA: 0x0000B473 File Offset: 0x00009673
		public IList<Point> Holes
		{
			get
			{
				return this.holes;
			}
		}

		// Token: 0x17000017 RID: 23
		// (get) Token: 0x06000060 RID: 96 RVA: 0x0000B47B File Offset: 0x0000967B
		public ICollection<Triangle> Triangles
		{
			get
			{
				return this.triangles.Values;
			}
		}

		// Token: 0x17000018 RID: 24
		// (get) Token: 0x06000061 RID: 97 RVA: 0x0000B488 File Offset: 0x00009688
		public ICollection<Segment> Segments
		{
			get
			{
				return this.subsegs.Values;
			}
		}

		// Token: 0x17000019 RID: 25
		// (get) Token: 0x06000062 RID: 98 RVA: 0x0000B495 File Offset: 0x00009695
		public IEnumerable<Edge> Edges
		{
			get
			{
				EdgeEnumerator e = new EdgeEnumerator(this);
				while (e.MoveNext())
				{
					Edge edge = e.Current;
					yield return edge;
				}
				yield break;
			}
		}

		// Token: 0x1700001A RID: 26
		// (get) Token: 0x06000063 RID: 99 RVA: 0x0000B4A5 File Offset: 0x000096A5
		public int NumberOfInputPoints
		{
			get
			{
				return this.invertices;
			}
		}

		// Token: 0x1700001B RID: 27
		// (get) Token: 0x06000064 RID: 100 RVA: 0x0000B4AD File Offset: 0x000096AD
		public int NumberOfEdges
		{
			get
			{
				return this.edges;
			}
		}

		// Token: 0x1700001C RID: 28
		// (get) Token: 0x06000065 RID: 101 RVA: 0x0000B4B5 File Offset: 0x000096B5
		public bool IsPolygon
		{
			get
			{
				return this.insegments > 0;
			}
		}

		// Token: 0x1700001D RID: 29
		// (get) Token: 0x06000066 RID: 102 RVA: 0x0000B4C0 File Offset: 0x000096C0
		public NodeNumbering CurrentNumbering
		{
			get
			{
				return this.numbering;
			}
		}

		// Token: 0x06000067 RID: 103 RVA: 0x0000B4C8 File Offset: 0x000096C8
		public Mesh()
			: this(new Behavior())
		{
		}

		// Token: 0x06000068 RID: 104 RVA: 0x0000B4D8 File Offset: 0x000096D8
		public Mesh(Behavior behavior)
		{
			this.behavior = behavior;
			this.logger = SimpleLog.Instance;
			this.vertices = new Dictionary<int, Vertex>();
			this.triangles = new Dictionary<int, Triangle>();
			this.subsegs = new Dictionary<int, Segment>();
			this.flipstack = new Stack<Otri>();
			this.holes = new List<Point>();
			this.regions = new List<RegionPointer>();
			this.quality = new QualityMesher(this);
			this.locator = new TriangleLocator(this);
			Primitives.ExactInit();
			if (Mesh.dummytri == null)
			{
				this.DummyInit();
			}
		}

		// Token: 0x06000069 RID: 105 RVA: 0x0000B56C File Offset: 0x0000976C
		public void Load(string filename)
		{
			InputGeometry inputGeometry;
			List<ITriangle> list;
			FileReader.Read(filename, out inputGeometry, out list);
			if (inputGeometry != null && list != null)
			{
				this.Load(inputGeometry, list);
			}
		}

		// Token: 0x0600006A RID: 106 RVA: 0x0000B594 File Offset: 0x00009794
		public void Load(InputGeometry input, List<ITriangle> triangles)
		{
			if (input == null || triangles == null)
			{
				throw new ArgumentException("Invalid input (argument is null).");
			}
			this.ResetData();
			if (input.HasSegments)
			{
				this.behavior.Poly = true;
				this.holes.AddRange(input.Holes);
			}
			if (!this.behavior.Poly)
			{
				this.behavior.VarArea = false;
				this.behavior.useRegions = false;
			}
			this.behavior.useRegions = input.Regions.Count > 0;
			this.TransferNodes(input);
			this.hullsize = DataReader.Reconstruct(this, input, triangles.ToArray());
			this.edges = (3 * triangles.Count + this.hullsize) / 2;
		}

		// Token: 0x0600006B RID: 107 RVA: 0x0000B64C File Offset: 0x0000984C
		public void Triangulate(string inputFile)
		{
			InputGeometry inputGeometry = FileReader.Read(inputFile);
			this.Triangulate(inputGeometry);
		}

		// Token: 0x0600006C RID: 108 RVA: 0x0000B668 File Offset: 0x00009868
		public void Triangulate(InputGeometry input)
		{
			this.ResetData();
			this.behavior.Poly = input.HasSegments;
			if (!this.behavior.Poly)
			{
				this.behavior.VarArea = false;
				this.behavior.useRegions = false;
			}
			this.behavior.useRegions = input.Regions.Count > 0;
			this.steinerleft = this.behavior.SteinerPoints;
			this.TransferNodes(input);
			this.hullsize = this.Delaunay();
			this.infvertex1 = null;
			this.infvertex2 = null;
			this.infvertex3 = null;
			ConstraintMesher constraintMesher = new ConstraintMesher(this);
			if (this.behavior.useSegments)
			{
				this.checksegments = true;
				constraintMesher.FormSkeleton(input);
			}
			if (this.behavior.Poly && this.triangles.Count > 0)
			{
				foreach (Point point in input.holes)
				{
					this.holes.Add(point);
				}
				foreach (RegionPointer regionPointer in input.regions)
				{
					this.regions.Add(regionPointer);
				}
				constraintMesher.CarveHoles();
			}
			else
			{
				this.holes.Clear();
				this.regions.Clear();
			}
			if ((this.behavior.Quality || this.behavior.ConformingDelaunay) && this.triangles.Count > 0)
			{
				this.quality.EnforceQuality();
			}
			this.edges = (3 * this.triangles.Count + this.hullsize) / 2;
		}

		// Token: 0x0600006D RID: 109 RVA: 0x0000B848 File Offset: 0x00009A48
		public void Refine(bool halfArea)
		{
			if (halfArea)
			{
				double num = 0.0;
				foreach (Triangle triangle in this.triangles.Values)
				{
					double num2 = (triangle.vertices[2].x - triangle.vertices[0].x) * (triangle.vertices[1].y - triangle.vertices[0].y) - (triangle.vertices[1].x - triangle.vertices[0].x) * (triangle.vertices[2].y - triangle.vertices[0].y);
					num2 = Math.Abs(num2) / 2.0;
					if (num2 > num)
					{
						num = num2;
					}
				}
				this.Refine(num / 2.0);
				return;
			}
			this.Refine();
		}

		// Token: 0x0600006E RID: 110 RVA: 0x0000B950 File Offset: 0x00009B50
		public void Refine(double areaConstraint)
		{
			this.behavior.fixedArea = true;
			this.behavior.MaxArea = areaConstraint;
			this.Refine();
			this.behavior.fixedArea = false;
			this.behavior.MaxArea = -1.0;
		}

		// Token: 0x0600006F RID: 111 RVA: 0x0000B990 File Offset: 0x00009B90
		public void Refine()
		{
			this.inelements = this.triangles.Count;
			this.invertices = this.vertices.Count;
			if (this.behavior.Poly)
			{
				if (this.behavior.useSegments)
				{
					this.insegments = this.subsegs.Count;
				}
				else
				{
					this.insegments = this.hullsize;
				}
			}
			this.Reset();
			this.steinerleft = this.behavior.SteinerPoints;
			this.infvertex1 = null;
			this.infvertex2 = null;
			this.infvertex3 = null;
			if (this.behavior.useSegments)
			{
				this.checksegments = true;
			}
			if (this.triangles.Count > 0)
			{
				this.quality.EnforceQuality();
			}
			this.edges = (3 * this.triangles.Count + this.hullsize) / 2;
		}

		// Token: 0x06000070 RID: 112 RVA: 0x0000BA6D File Offset: 0x00009C6D
		public void Smooth()
		{
			this.numbering = NodeNumbering.None;
			((ISmoother)new SimpleSmoother(this)).Smooth();
		}

		// Token: 0x06000071 RID: 113 RVA: 0x0000BA81 File Offset: 0x00009C81
		public void Renumber()
		{
			this.Renumber(NodeNumbering.Linear);
		}

		// Token: 0x06000072 RID: 114 RVA: 0x0000BA8C File Offset: 0x00009C8C
		public void Renumber(NodeNumbering num)
		{
			if (num == this.numbering)
			{
				return;
			}
			int num2;
			if (num == NodeNumbering.Linear)
			{
				num2 = 0;
				using (Dictionary<int, Vertex>.ValueCollection.Enumerator enumerator = this.vertices.Values.GetEnumerator())
				{
					while (enumerator.MoveNext())
					{
						Vertex vertex = enumerator.Current;
						vertex.id = num2++;
					}
					goto IL_9F;
				}
			}
			if (num == NodeNumbering.CuthillMcKee)
			{
				int[] array = new CuthillMcKee().Renumber(this);
				foreach (Vertex vertex2 in this.vertices.Values)
				{
					vertex2.id = array[vertex2.id];
				}
			}
			IL_9F:
			this.numbering = num;
			num2 = 0;
			foreach (Triangle triangle in this.triangles.Values)
			{
				triangle.id = num2++;
			}
		}

		// Token: 0x06000073 RID: 115 RVA: 0x0000BBA8 File Offset: 0x00009DA8
		private int Delaunay()
		{
			int num;
			if (this.behavior.Algorithm == TriangulationAlgorithm.Dwyer)
			{
				num = new Dwyer().Triangulate(this);
			}
			else if (this.behavior.Algorithm == TriangulationAlgorithm.SweepLine)
			{
				num = new SweepLine().Triangulate(this);
			}
			else
			{
				num = new Incremental().Triangulate(this);
			}
			if (this.triangles.Count != 0)
			{
				return num;
			}
			return 0;
		}

		// Token: 0x06000074 RID: 116 RVA: 0x0000BC0C File Offset: 0x00009E0C
		private void ResetData()
		{
			this.vertices.Clear();
			this.triangles.Clear();
			this.subsegs.Clear();
			this.holes.Clear();
			this.regions.Clear();
			this.hash_vtx = 0;
			this.hash_seg = 0;
			this.hash_tri = 0;
			this.flipstack.Clear();
			this.hullsize = 0;
			this.edges = 0;
			this.Reset();
			this.locator.Reset();
		}

		// Token: 0x06000075 RID: 117 RVA: 0x0000BC90 File Offset: 0x00009E90
		private void Reset()
		{
			this.numbering = NodeNumbering.None;
			this.undeads = 0;
			this.checksegments = false;
			this.checkquality = false;
			Statistic.InCircleCount = 0L;
			Statistic.CounterClockwiseCount = 0L;
			Statistic.InCircleAdaptCount = 0L;
			Statistic.CounterClockwiseAdaptCount = 0L;
			Statistic.Orient3dCount = 0L;
			Statistic.HyperbolaCount = 0L;
			Statistic.CircleTopCount = 0L;
			Statistic.CircumcenterCount = 0L;
		}

		// Token: 0x06000076 RID: 118 RVA: 0x0000BCF4 File Offset: 0x00009EF4
		private void DummyInit()
		{
			Mesh.dummytri = new Triangle();
			Mesh.dummytri.hash = -1;
			Mesh.dummytri.id = -1;
			Mesh.dummytri.neighbors[0].triangle = Mesh.dummytri;
			Mesh.dummytri.neighbors[1].triangle = Mesh.dummytri;
			Mesh.dummytri.neighbors[2].triangle = Mesh.dummytri;
			if (this.behavior.useSegments)
			{
				Mesh.dummysub = new Segment();
				Mesh.dummysub.hash = -1;
				Mesh.dummysub.subsegs[0].seg = Mesh.dummysub;
				Mesh.dummysub.subsegs[1].seg = Mesh.dummysub;
				Mesh.dummytri.subsegs[0].seg = Mesh.dummysub;
				Mesh.dummytri.subsegs[1].seg = Mesh.dummysub;
				Mesh.dummytri.subsegs[2].seg = Mesh.dummysub;
			}
		}

		// Token: 0x06000077 RID: 119 RVA: 0x0000BE18 File Offset: 0x0000A018
		private void TransferNodes(InputGeometry data)
		{
			List<Vertex> points = data.points;
			this.invertices = points.Count;
			this.mesh_dim = 2;
			if (this.invertices < 3)
			{
				this.logger.Error("Input must have at least three input vertices.", "MeshReader.TransferNodes()");
				throw new Exception("Input must have at least three input vertices.");
			}
			this.nextras = ((points[0].attributes == null) ? 0 : points[0].attributes.Length);
			foreach (Vertex vertex in points)
			{
				Vertex vertex2 = vertex;
				int num = this.hash_vtx;
				this.hash_vtx = num + 1;
				vertex2.hash = num;
				vertex.id = vertex.hash;
				this.vertices.Add(vertex.hash, vertex);
			}
			this.bounds = data.Bounds;
		}

		// Token: 0x06000078 RID: 120 RVA: 0x0000BF08 File Offset: 0x0000A108
		internal void MakeVertexMap()
		{
			Otri otri = default(Otri);
			foreach (Triangle triangle in this.triangles.Values)
			{
				otri.triangle = triangle;
				otri.orient = 0;
				while (otri.orient < 3)
				{
					otri.Org().tri = otri;
					otri.orient++;
				}
			}
		}

		// Token: 0x06000079 RID: 121 RVA: 0x0000BF98 File Offset: 0x0000A198
		internal void MakeTriangle(ref Otri newotri)
		{
			Triangle triangle = new Triangle();
			Triangle triangle2 = triangle;
			int num = this.hash_tri;
			this.hash_tri = num + 1;
			triangle2.hash = num;
			triangle.id = triangle.hash;
			newotri.triangle = triangle;
			newotri.orient = 0;
			this.triangles.Add(triangle.hash, triangle);
		}

		// Token: 0x0600007A RID: 122 RVA: 0x0000BFF0 File Offset: 0x0000A1F0
		internal void MakeSegment(ref Osub newsubseg)
		{
			Segment segment = new Segment();
			Segment segment2 = segment;
			int num = this.hash_seg;
			this.hash_seg = num + 1;
			segment2.hash = num;
			newsubseg.seg = segment;
			newsubseg.orient = 0;
			this.subsegs.Add(segment.hash, segment);
		}

		// Token: 0x0600007B RID: 123 RVA: 0x0000C03C File Offset: 0x0000A23C
		internal InsertVertexResult InsertVertex(Vertex newvertex, ref Otri searchtri, ref Osub splitseg, bool segmentflaws, bool triflaws)
		{
			Otri otri = default(Otri);
			Otri otri2 = default(Otri);
			Otri otri3 = default(Otri);
			Otri otri4 = default(Otri);
			Otri otri5 = default(Otri);
			Otri otri6 = default(Otri);
			Otri otri7 = default(Otri);
			Otri otri8 = default(Otri);
			Otri otri9 = default(Otri);
			Otri otri10 = default(Otri);
			Otri otri11 = default(Otri);
			Otri otri12 = default(Otri);
			Otri otri13 = default(Otri);
			Otri otri14 = default(Otri);
			Osub osub = default(Osub);
			Osub osub2 = default(Osub);
			Osub osub3 = default(Osub);
			Osub osub4 = default(Osub);
			Osub osub5 = default(Osub);
			Osub osub6 = default(Osub);
			Osub osub7 = default(Osub);
			Osub osub8 = default(Osub);
			LocateResult locateResult;
			if (splitseg.seg == null)
			{
				if (searchtri.triangle == Mesh.dummytri)
				{
					otri.triangle = Mesh.dummytri;
					otri.orient = 0;
					otri.SymSelf();
					locateResult = this.locator.Locate(newvertex, ref otri);
				}
				else
				{
					searchtri.Copy(ref otri);
					locateResult = this.locator.PreciseLocate(newvertex, ref otri, true);
				}
			}
			else
			{
				searchtri.Copy(ref otri);
				locateResult = LocateResult.OnEdge;
			}
			if (locateResult == LocateResult.OnVertex)
			{
				otri.Copy(ref searchtri);
				this.locator.Update(ref otri);
				return InsertVertexResult.Duplicate;
			}
			Vertex vertex;
			Vertex vertex2;
			if (locateResult == LocateResult.OnEdge || locateResult == LocateResult.Outside)
			{
				if (this.checksegments && splitseg.seg == null)
				{
					otri.SegPivot(ref osub5);
					if (osub5.seg != Mesh.dummysub)
					{
						if (segmentflaws)
						{
							bool flag = this.behavior.NoBisect != 2;
							if (flag && this.behavior.NoBisect == 1)
							{
								otri.Sym(ref otri14);
								flag = otri14.triangle != Mesh.dummytri;
							}
							if (flag)
							{
								BadSubseg badSubseg = new BadSubseg();
								badSubseg.encsubseg = osub5;
								badSubseg.subsegorg = osub5.Org();
								badSubseg.subsegdest = osub5.Dest();
								this.quality.AddBadSubseg(badSubseg);
							}
						}
						otri.Copy(ref searchtri);
						this.locator.Update(ref otri);
						return InsertVertexResult.Violating;
					}
				}
				otri.Lprev(ref otri4);
				otri4.Sym(ref otri11);
				otri.Sym(ref otri6);
				bool flag2 = otri6.triangle != Mesh.dummytri;
				if (flag2)
				{
					otri6.LnextSelf();
					otri6.Sym(ref otri13);
					this.MakeTriangle(ref otri9);
				}
				else
				{
					this.hullsize++;
				}
				this.MakeTriangle(ref otri8);
				vertex = otri.Org();
				vertex2 = otri.Dest();
				Vertex vertex3 = otri.Apex();
				otri8.SetOrg(vertex3);
				otri8.SetDest(vertex);
				otri8.SetApex(newvertex);
				otri.SetOrg(newvertex);
				otri8.triangle.region = otri4.triangle.region;
				if (this.behavior.VarArea)
				{
					otri8.triangle.area = otri4.triangle.area;
				}
				if (flag2)
				{
					Vertex vertex4 = otri6.Dest();
					otri9.SetOrg(vertex);
					otri9.SetDest(vertex4);
					otri9.SetApex(newvertex);
					otri6.SetOrg(newvertex);
					otri9.triangle.region = otri6.triangle.region;
					if (this.behavior.VarArea)
					{
						otri9.triangle.area = otri6.triangle.area;
					}
				}
				if (this.checksegments)
				{
					otri4.SegPivot(ref osub2);
					if (osub2.seg != Mesh.dummysub)
					{
						otri4.SegDissolve();
						otri8.SegBond(ref osub2);
					}
					if (flag2)
					{
						otri6.SegPivot(ref osub4);
						if (osub4.seg != Mesh.dummysub)
						{
							otri6.SegDissolve();
							otri9.SegBond(ref osub4);
						}
					}
				}
				otri8.Bond(ref otri11);
				otri8.LprevSelf();
				otri8.Bond(ref otri4);
				otri8.LprevSelf();
				if (flag2)
				{
					otri9.Bond(ref otri13);
					otri9.LnextSelf();
					otri9.Bond(ref otri6);
					otri9.LnextSelf();
					otri9.Bond(ref otri8);
				}
				if (splitseg.seg != null)
				{
					splitseg.SetDest(newvertex);
					Vertex vertex5 = splitseg.SegOrg();
					Vertex vertex6 = splitseg.SegDest();
					splitseg.SymSelf();
					splitseg.Pivot(ref osub7);
					this.InsertSubseg(ref otri8, splitseg.seg.boundary);
					otri8.SegPivot(ref osub8);
					osub8.SetSegOrg(vertex5);
					osub8.SetSegDest(vertex6);
					splitseg.Bond(ref osub8);
					osub8.SymSelf();
					osub8.Bond(ref osub7);
					splitseg.SymSelf();
					if (newvertex.mark == 0)
					{
						newvertex.mark = splitseg.seg.boundary;
					}
				}
				if (this.checkquality)
				{
					this.flipstack.Clear();
					this.flipstack.Push(default(Otri));
					this.flipstack.Push(otri);
				}
				otri.LnextSelf();
			}
			else
			{
				otri.Lnext(ref otri3);
				otri.Lprev(ref otri4);
				otri3.Sym(ref otri10);
				otri4.Sym(ref otri11);
				this.MakeTriangle(ref otri7);
				this.MakeTriangle(ref otri8);
				vertex = otri.Org();
				vertex2 = otri.Dest();
				Vertex vertex3 = otri.Apex();
				otri7.SetOrg(vertex2);
				otri7.SetDest(vertex3);
				otri7.SetApex(newvertex);
				otri8.SetOrg(vertex3);
				otri8.SetDest(vertex);
				otri8.SetApex(newvertex);
				otri.SetApex(newvertex);
				otri7.triangle.region = otri.triangle.region;
				otri8.triangle.region = otri.triangle.region;
				if (this.behavior.VarArea)
				{
					double num = otri.triangle.area;
					otri7.triangle.area = num;
					otri8.triangle.area = num;
				}
				if (this.checksegments)
				{
					otri3.SegPivot(ref osub);
					if (osub.seg != Mesh.dummysub)
					{
						otri3.SegDissolve();
						otri7.SegBond(ref osub);
					}
					otri4.SegPivot(ref osub2);
					if (osub2.seg != Mesh.dummysub)
					{
						otri4.SegDissolve();
						otri8.SegBond(ref osub2);
					}
				}
				otri7.Bond(ref otri10);
				otri8.Bond(ref otri11);
				otri7.LnextSelf();
				otri8.LprevSelf();
				otri7.Bond(ref otri8);
				otri7.LnextSelf();
				otri3.Bond(ref otri7);
				otri8.LprevSelf();
				otri4.Bond(ref otri8);
				if (this.checkquality)
				{
					this.flipstack.Clear();
					this.flipstack.Push(otri);
				}
			}
			InsertVertexResult insertVertexResult = InsertVertexResult.Successful;
			Vertex vertex7 = otri.Org();
			vertex = vertex7;
			vertex2 = otri.Dest();
			for (;;)
			{
				bool flag3 = true;
				if (this.checksegments)
				{
					otri.SegPivot(ref osub6);
					if (osub6.seg != Mesh.dummysub)
					{
						flag3 = false;
						if (segmentflaws && this.quality.CheckSeg4Encroach(ref osub6) > 0)
						{
							insertVertexResult = InsertVertexResult.Encroaching;
						}
					}
				}
				if (flag3)
				{
					otri.Sym(ref otri2);
					if (otri2.triangle == Mesh.dummytri)
					{
						flag3 = false;
					}
					else
					{
						Vertex vertex8 = otri2.Apex();
						if (vertex2 == this.infvertex1 || vertex2 == this.infvertex2 || vertex2 == this.infvertex3)
						{
							flag3 = Primitives.CounterClockwise(newvertex, vertex, vertex8) > 0.0;
						}
						else if (vertex == this.infvertex1 || vertex == this.infvertex2 || vertex == this.infvertex3)
						{
							flag3 = Primitives.CounterClockwise(vertex8, vertex2, newvertex) > 0.0;
						}
						else
						{
							flag3 = !(vertex8 == this.infvertex1) && !(vertex8 == this.infvertex2) && !(vertex8 == this.infvertex3) && Primitives.InCircle(vertex2, newvertex, vertex, vertex8) > 0.0;
						}
						if (flag3)
						{
							otri2.Lprev(ref otri5);
							otri5.Sym(ref otri12);
							otri2.Lnext(ref otri6);
							otri6.Sym(ref otri13);
							otri.Lnext(ref otri3);
							otri3.Sym(ref otri10);
							otri.Lprev(ref otri4);
							otri4.Sym(ref otri11);
							otri5.Bond(ref otri10);
							otri3.Bond(ref otri11);
							otri4.Bond(ref otri13);
							otri6.Bond(ref otri12);
							if (this.checksegments)
							{
								otri5.SegPivot(ref osub3);
								otri3.SegPivot(ref osub);
								otri4.SegPivot(ref osub2);
								otri6.SegPivot(ref osub4);
								if (osub3.seg == Mesh.dummysub)
								{
									otri6.SegDissolve();
								}
								else
								{
									otri6.SegBond(ref osub3);
								}
								if (osub.seg == Mesh.dummysub)
								{
									otri5.SegDissolve();
								}
								else
								{
									otri5.SegBond(ref osub);
								}
								if (osub2.seg == Mesh.dummysub)
								{
									otri3.SegDissolve();
								}
								else
								{
									otri3.SegBond(ref osub2);
								}
								if (osub4.seg == Mesh.dummysub)
								{
									otri4.SegDissolve();
								}
								else
								{
									otri4.SegBond(ref osub4);
								}
							}
							otri.SetOrg(vertex8);
							otri.SetDest(newvertex);
							otri.SetApex(vertex);
							otri2.SetOrg(newvertex);
							otri2.SetDest(vertex8);
							otri2.SetApex(vertex2);
							int num2 = Math.Min(otri2.triangle.region, otri.triangle.region);
							otri2.triangle.region = num2;
							otri.triangle.region = num2;
							if (this.behavior.VarArea)
							{
								double num;
								if (otri2.triangle.area <= 0.0 || otri.triangle.area <= 0.0)
								{
									num = -1.0;
								}
								else
								{
									num = 0.5 * (otri2.triangle.area + otri.triangle.area);
								}
								otri2.triangle.area = num;
								otri.triangle.area = num;
							}
							if (this.checkquality)
							{
								this.flipstack.Push(otri);
							}
							otri.LprevSelf();
							vertex2 = vertex8;
						}
					}
				}
				if (!flag3)
				{
					if (triflaws)
					{
						this.quality.TestTriangle(ref otri);
					}
					otri.LnextSelf();
					otri.Sym(ref otri14);
					if (vertex2 == vertex7 || otri14.triangle == Mesh.dummytri)
					{
						break;
					}
					otri14.Lnext(ref otri);
					vertex = vertex2;
					vertex2 = otri.Dest();
				}
			}
			otri.Lnext(ref searchtri);
			Otri otri15 = default(Otri);
			otri.Lnext(ref otri15);
			this.locator.Update(ref otri15);
			return insertVertexResult;
		}

		// Token: 0x0600007C RID: 124 RVA: 0x0000CAD4 File Offset: 0x0000ACD4
		internal void InsertSubseg(ref Otri tri, int subsegmark)
		{
			Otri otri = default(Otri);
			Osub osub = default(Osub);
			Vertex vertex = tri.Org();
			Vertex vertex2 = tri.Dest();
			if (vertex.mark == 0)
			{
				vertex.mark = subsegmark;
			}
			if (vertex2.mark == 0)
			{
				vertex2.mark = subsegmark;
			}
			tri.SegPivot(ref osub);
			if (osub.seg == Mesh.dummysub)
			{
				this.MakeSegment(ref osub);
				osub.SetOrg(vertex2);
				osub.SetDest(vertex);
				osub.SetSegOrg(vertex2);
				osub.SetSegDest(vertex);
				tri.SegBond(ref osub);
				tri.Sym(ref otri);
				osub.SymSelf();
				otri.SegBond(ref osub);
				osub.seg.boundary = subsegmark;
				return;
			}
			if (osub.seg.boundary == 0)
			{
				osub.seg.boundary = subsegmark;
			}
		}

		// Token: 0x0600007D RID: 125 RVA: 0x0000CBA0 File Offset: 0x0000ADA0
		internal void Flip(ref Otri flipedge)
		{
			Otri otri = default(Otri);
			Otri otri2 = default(Otri);
			Otri otri3 = default(Otri);
			Otri otri4 = default(Otri);
			Otri otri5 = default(Otri);
			Otri otri6 = default(Otri);
			Otri otri7 = default(Otri);
			Otri otri8 = default(Otri);
			Otri otri9 = default(Otri);
			Osub osub = default(Osub);
			Osub osub2 = default(Osub);
			Osub osub3 = default(Osub);
			Osub osub4 = default(Osub);
			Vertex vertex = flipedge.Org();
			Vertex vertex2 = flipedge.Dest();
			Vertex vertex3 = flipedge.Apex();
			flipedge.Sym(ref otri5);
			Vertex vertex4 = otri5.Apex();
			otri5.Lprev(ref otri3);
			otri3.Sym(ref otri8);
			otri5.Lnext(ref otri4);
			otri4.Sym(ref otri9);
			flipedge.Lnext(ref otri);
			otri.Sym(ref otri6);
			flipedge.Lprev(ref otri2);
			otri2.Sym(ref otri7);
			otri3.Bond(ref otri6);
			otri.Bond(ref otri7);
			otri2.Bond(ref otri9);
			otri4.Bond(ref otri8);
			if (this.checksegments)
			{
				otri3.SegPivot(ref osub3);
				otri.SegPivot(ref osub);
				otri2.SegPivot(ref osub2);
				otri4.SegPivot(ref osub4);
				if (osub3.seg == Mesh.dummysub)
				{
					otri4.SegDissolve();
				}
				else
				{
					otri4.SegBond(ref osub3);
				}
				if (osub.seg == Mesh.dummysub)
				{
					otri3.SegDissolve();
				}
				else
				{
					otri3.SegBond(ref osub);
				}
				if (osub2.seg == Mesh.dummysub)
				{
					otri.SegDissolve();
				}
				else
				{
					otri.SegBond(ref osub2);
				}
				if (osub4.seg == Mesh.dummysub)
				{
					otri2.SegDissolve();
				}
				else
				{
					otri2.SegBond(ref osub4);
				}
			}
			flipedge.SetOrg(vertex4);
			flipedge.SetDest(vertex3);
			flipedge.SetApex(vertex);
			otri5.SetOrg(vertex3);
			otri5.SetDest(vertex4);
			otri5.SetApex(vertex2);
		}

		// Token: 0x0600007E RID: 126 RVA: 0x0000CD8C File Offset: 0x0000AF8C
		internal void Unflip(ref Otri flipedge)
		{
			Otri otri = default(Otri);
			Otri otri2 = default(Otri);
			Otri otri3 = default(Otri);
			Otri otri4 = default(Otri);
			Otri otri5 = default(Otri);
			Otri otri6 = default(Otri);
			Otri otri7 = default(Otri);
			Otri otri8 = default(Otri);
			Otri otri9 = default(Otri);
			Osub osub = default(Osub);
			Osub osub2 = default(Osub);
			Osub osub3 = default(Osub);
			Osub osub4 = default(Osub);
			Vertex vertex = flipedge.Org();
			Vertex vertex2 = flipedge.Dest();
			Vertex vertex3 = flipedge.Apex();
			flipedge.Sym(ref otri5);
			Vertex vertex4 = otri5.Apex();
			otri5.Lprev(ref otri3);
			otri3.Sym(ref otri8);
			otri5.Lnext(ref otri4);
			otri4.Sym(ref otri9);
			flipedge.Lnext(ref otri);
			otri.Sym(ref otri6);
			flipedge.Lprev(ref otri2);
			otri2.Sym(ref otri7);
			otri3.Bond(ref otri9);
			otri.Bond(ref otri8);
			otri2.Bond(ref otri6);
			otri4.Bond(ref otri7);
			if (this.checksegments)
			{
				otri3.SegPivot(ref osub3);
				otri.SegPivot(ref osub);
				otri2.SegPivot(ref osub2);
				otri4.SegPivot(ref osub4);
				if (osub3.seg == Mesh.dummysub)
				{
					otri.SegDissolve();
				}
				else
				{
					otri.SegBond(ref osub3);
				}
				if (osub.seg == Mesh.dummysub)
				{
					otri2.SegDissolve();
				}
				else
				{
					otri2.SegBond(ref osub);
				}
				if (osub2.seg == Mesh.dummysub)
				{
					otri4.SegDissolve();
				}
				else
				{
					otri4.SegBond(ref osub2);
				}
				if (osub4.seg == Mesh.dummysub)
				{
					otri3.SegDissolve();
				}
				else
				{
					otri3.SegBond(ref osub4);
				}
			}
			flipedge.SetOrg(vertex3);
			flipedge.SetDest(vertex4);
			flipedge.SetApex(vertex2);
			otri5.SetOrg(vertex4);
			otri5.SetDest(vertex3);
			otri5.SetApex(vertex);
		}

		// Token: 0x0600007F RID: 127 RVA: 0x0000CF78 File Offset: 0x0000B178
		private void TriangulatePolygon(Otri firstedge, Otri lastedge, int edgecount, bool doflip, bool triflaws)
		{
			Otri otri = default(Otri);
			Otri otri2 = default(Otri);
			Otri otri3 = default(Otri);
			int num = 1;
			Vertex vertex = lastedge.Apex();
			Vertex vertex2 = firstedge.Dest();
			firstedge.Onext(ref otri2);
			Vertex vertex3 = otri2.Dest();
			otri2.Copy(ref otri);
			for (int i = 2; i <= edgecount - 2; i++)
			{
				otri.OnextSelf();
				Vertex vertex4 = otri.Dest();
				if (Primitives.InCircle(vertex, vertex2, vertex3, vertex4) > 0.0)
				{
					otri.Copy(ref otri2);
					vertex3 = vertex4;
					num = i;
				}
			}
			if (num > 1)
			{
				otri2.Oprev(ref otri3);
				this.TriangulatePolygon(firstedge, otri3, num + 1, true, triflaws);
			}
			if (num < edgecount - 2)
			{
				otri2.Sym(ref otri3);
				this.TriangulatePolygon(otri2, lastedge, edgecount - num, true, triflaws);
				otri3.Sym(ref otri2);
			}
			if (doflip)
			{
				this.Flip(ref otri2);
				if (triflaws)
				{
					otri2.Sym(ref otri);
					this.quality.TestTriangle(ref otri);
				}
			}
			otri2.Copy(ref lastedge);
		}

		// Token: 0x06000080 RID: 128 RVA: 0x0000D08C File Offset: 0x0000B28C
		internal void DeleteVertex(ref Otri deltri)
		{
			Otri otri = default(Otri);
			Otri otri2 = default(Otri);
			Otri otri3 = default(Otri);
			Otri otri4 = default(Otri);
			Otri otri5 = default(Otri);
			Otri otri6 = default(Otri);
			Otri otri7 = default(Otri);
			Otri otri8 = default(Otri);
			Osub osub = default(Osub);
			Osub osub2 = default(Osub);
			Vertex vertex = deltri.Org();
			this.VertexDealloc(vertex);
			deltri.Onext(ref otri);
			int num = 1;
			while (!deltri.Equal(otri))
			{
				num++;
				otri.OnextSelf();
			}
			if (num > 3)
			{
				deltri.Onext(ref otri2);
				deltri.Oprev(ref otri3);
				this.TriangulatePolygon(otri2, otri3, num, false, this.behavior.NoBisect == 0);
			}
			deltri.Lprev(ref otri4);
			deltri.Dnext(ref otri5);
			otri5.Sym(ref otri7);
			otri4.Oprev(ref otri6);
			otri6.Sym(ref otri8);
			deltri.Bond(ref otri7);
			otri4.Bond(ref otri8);
			otri5.SegPivot(ref osub);
			if (osub.seg != Mesh.dummysub)
			{
				deltri.SegBond(ref osub);
			}
			otri6.SegPivot(ref osub2);
			if (osub2.seg != Mesh.dummysub)
			{
				otri4.SegBond(ref osub2);
			}
			Vertex vertex2 = otri5.Org();
			deltri.SetOrg(vertex2);
			if (this.behavior.NoBisect == 0)
			{
				this.quality.TestTriangle(ref deltri);
			}
			this.TriangleDealloc(otri5.triangle);
			this.TriangleDealloc(otri6.triangle);
		}

		// Token: 0x06000081 RID: 129 RVA: 0x0000D20C File Offset: 0x0000B40C
		internal void UndoVertex()
		{
			Otri otri = default(Otri);
			Otri otri2 = default(Otri);
			Otri otri3 = default(Otri);
			Otri otri4 = default(Otri);
			Otri otri5 = default(Otri);
			Otri otri6 = default(Otri);
			Otri otri7 = default(Otri);
			Osub osub = default(Osub);
			Osub osub2 = default(Osub);
			Osub osub3 = default(Osub);
			while (this.flipstack.Count > 0)
			{
				Otri otri8 = this.flipstack.Pop();
				if (this.flipstack.Count == 0)
				{
					otri8.Dprev(ref otri);
					otri.LnextSelf();
					otri8.Onext(ref otri2);
					otri2.LprevSelf();
					otri.Sym(ref otri4);
					otri2.Sym(ref otri5);
					Vertex vertex = otri.Dest();
					otri8.SetApex(vertex);
					otri8.LnextSelf();
					otri8.Bond(ref otri4);
					otri.SegPivot(ref osub);
					otri8.SegBond(ref osub);
					otri8.LnextSelf();
					otri8.Bond(ref otri5);
					otri2.SegPivot(ref osub2);
					otri8.SegBond(ref osub2);
					this.TriangleDealloc(otri.triangle);
					this.TriangleDealloc(otri2.triangle);
				}
				else if (this.flipstack.Peek().triangle == null)
				{
					otri8.Lprev(ref otri7);
					otri7.Sym(ref otri2);
					otri2.LnextSelf();
					otri2.Sym(ref otri5);
					Vertex vertex2 = otri2.Dest();
					otri8.SetOrg(vertex2);
					otri7.Bond(ref otri5);
					otri2.SegPivot(ref osub2);
					otri7.SegBond(ref osub2);
					this.TriangleDealloc(otri2.triangle);
					otri8.Sym(ref otri7);
					if (otri7.triangle != Mesh.dummytri)
					{
						otri7.LnextSelf();
						otri7.Dnext(ref otri3);
						otri3.Sym(ref otri6);
						otri7.SetOrg(vertex2);
						otri7.Bond(ref otri6);
						otri3.SegPivot(ref osub3);
						otri7.SegBond(ref osub3);
						this.TriangleDealloc(otri3.triangle);
					}
					this.flipstack.Clear();
				}
				else
				{
					this.Unflip(ref otri8);
				}
			}
		}

		// Token: 0x06000082 RID: 130 RVA: 0x0000D425 File Offset: 0x0000B625
		internal void TriangleDealloc(Triangle dyingtriangle)
		{
			Otri.Kill(dyingtriangle);
			this.triangles.Remove(dyingtriangle.hash);
		}

		// Token: 0x06000083 RID: 131 RVA: 0x0000D43F File Offset: 0x0000B63F
		internal void VertexDealloc(Vertex dyingvertex)
		{
			dyingvertex.type = VertexType.DeadVertex;
			this.vertices.Remove(dyingvertex.hash);
		}

		// Token: 0x06000084 RID: 132 RVA: 0x0000D45A File Offset: 0x0000B65A
		internal void SubsegDealloc(Segment dyingsubseg)
		{
			Osub.Kill(dyingsubseg);
			this.subsegs.Remove(dyingsubseg.hash);
		}

		// Token: 0x04000053 RID: 83
		private ILog<SimpleLogItem> logger;

		// Token: 0x04000054 RID: 84
		private QualityMesher quality;

		// Token: 0x04000055 RID: 85
		private Stack<Otri> flipstack;

		// Token: 0x04000056 RID: 86
		internal Dictionary<int, Triangle> triangles;

		// Token: 0x04000057 RID: 87
		internal Dictionary<int, Segment> subsegs;

		// Token: 0x04000058 RID: 88
		internal Dictionary<int, Vertex> vertices;

		// Token: 0x04000059 RID: 89
		internal int hash_vtx;

		// Token: 0x0400005A RID: 90
		internal int hash_seg;

		// Token: 0x0400005B RID: 91
		internal int hash_tri;

		// Token: 0x0400005C RID: 92
		internal List<Point> holes;

		// Token: 0x0400005D RID: 93
		internal List<RegionPointer> regions;

		// Token: 0x0400005E RID: 94
		internal BoundingBox bounds;

		// Token: 0x0400005F RID: 95
		internal int invertices;

		// Token: 0x04000060 RID: 96
		internal int inelements;

		// Token: 0x04000061 RID: 97
		internal int insegments;

		// Token: 0x04000062 RID: 98
		internal int undeads;

		// Token: 0x04000063 RID: 99
		internal int edges;

		// Token: 0x04000064 RID: 100
		internal int mesh_dim;

		// Token: 0x04000065 RID: 101
		internal int nextras;

		// Token: 0x04000066 RID: 102
		internal int hullsize;

		// Token: 0x04000067 RID: 103
		internal int steinerleft;

		// Token: 0x04000068 RID: 104
		internal bool checksegments;

		// Token: 0x04000069 RID: 105
		internal bool checkquality;

		// Token: 0x0400006A RID: 106
		internal Vertex infvertex1;

		// Token: 0x0400006B RID: 107
		internal Vertex infvertex2;

		// Token: 0x0400006C RID: 108
		internal Vertex infvertex3;

		// Token: 0x0400006D RID: 109
		internal static Triangle dummytri;

		// Token: 0x0400006E RID: 110
		internal static Segment dummysub;

		// Token: 0x0400006F RID: 111
		internal TriangleLocator locator;

		// Token: 0x04000070 RID: 112
		internal Behavior behavior;

		// Token: 0x04000071 RID: 113
		internal NodeNumbering numbering;
	}
}