using System;
using TriangleNet.Data;
using TriangleNet.Geometry;
using TriangleNet.Log;
using TriangleNet.Tools;

namespace TriangleNet
{
	// Token: 0x02000006 RID: 6
	internal class NewLocation
	{
		// Token: 0x0600003C RID: 60 RVA: 0x00003DA4 File Offset: 0x00001FA4
		public NewLocation(Mesh mesh)
		{
			this.mesh = mesh;
			this.behavior = mesh.behavior;
		}

		// Token: 0x0600003D RID: 61 RVA: 0x00003E67 File Offset: 0x00002067
		public Point FindLocation(Vertex torg, Vertex tdest, Vertex tapex, ref double xi, ref double eta, bool offcenter, Otri badotri)
		{
			if (this.behavior.MaxAngle == 0.0)
			{
				return this.FindNewLocationWithoutMaxAngle(torg, tdest, tapex, ref xi, ref eta, true, badotri);
			}
			return this.FindNewLocation(torg, tdest, tapex, ref xi, ref eta, true, badotri);
		}

		// Token: 0x0600003E RID: 62 RVA: 0x00003EA0 File Offset: 0x000020A0
		private Point FindNewLocationWithoutMaxAngle(Vertex torg, Vertex tdest, Vertex tapex, ref double xi, ref double eta, bool offcenter, Otri badotri)
		{
			double offconstant = this.behavior.offconstant;
			int num = 0;
			Otri otri = default(Otri);
			double[] array = new double[2];
			double num2 = 0.0;
			double num3 = 0.0;
			double[] array2 = new double[5];
			double[] array3 = new double[4];
			double num4 = 0.06;
			double num5 = 1.0;
			double num6 = 1.0;
			int num7 = 0;
			double[] array4 = new double[2];
			double num8 = 0.0;
			double num9 = 0.0;
			Statistic.CircumcenterCount += 1L;
			double num10 = tdest.x - torg.x;
			double num11 = tdest.y - torg.y;
			double num12 = tapex.x - torg.x;
			double num13 = tapex.y - torg.y;
			double num14 = tapex.x - tdest.x;
			double num15 = tapex.y - tdest.y;
			double num16 = num10 * num10 + num11 * num11;
			double num17 = num12 * num12 + num13 * num13;
			double num18 = (tdest.x - tapex.x) * (tdest.x - tapex.x) + (tdest.y - tapex.y) * (tdest.y - tapex.y);
			double num19;
			if (Behavior.NoExact)
			{
				num19 = 0.5 / (num10 * num13 - num12 * num11);
			}
			else
			{
				num19 = 0.5 / Primitives.CounterClockwise(tdest, tapex, torg);
				Statistic.CounterClockwiseCount -= 1L;
			}
			double num20 = (num13 * num16 - num11 * num17) * num19;
			double num21 = (num10 * num17 - num12 * num16) * num19;
			Point point = new Point(torg.x + num20, torg.y + num21);
			Otri otri2 = badotri;
			int num22 = this.LongestShortestEdge(num17, num18, num16);
			double num23;
			double num24;
			double num25;
			double num26;
			double num27;
			Point point2;
			Point point3;
			Point point4;
			if (num22 <= 213)
			{
				if (num22 == 123)
				{
					num23 = num12;
					num24 = num13;
					num25 = num17;
					num26 = num18;
					num27 = num16;
					point2 = tdest;
					point3 = torg;
					point4 = tapex;
					goto IL_2F9;
				}
				if (num22 == 132)
				{
					num23 = num12;
					num24 = num13;
					num25 = num17;
					num26 = num16;
					num27 = num18;
					point2 = tdest;
					point3 = tapex;
					point4 = torg;
					goto IL_2F9;
				}
				if (num22 == 213)
				{
					num23 = num14;
					num24 = num15;
					num25 = num18;
					num26 = num17;
					num27 = num16;
					point2 = torg;
					point3 = tdest;
					point4 = tapex;
					goto IL_2F9;
				}
			}
			else
			{
				if (num22 == 231)
				{
					num23 = num14;
					num24 = num15;
					num25 = num18;
					num26 = num16;
					num27 = num17;
					point2 = torg;
					point3 = tapex;
					point4 = tdest;
					goto IL_2F9;
				}
				if (num22 == 312)
				{
					num23 = num10;
					num24 = num11;
					num25 = num16;
					num26 = num17;
					num27 = num18;
					point2 = tapex;
					point3 = tdest;
					point4 = torg;
					goto IL_2F9;
				}
				if (num22 != 321)
				{
				}
			}
			num23 = num10;
			num24 = num11;
			num25 = num16;
			num26 = num18;
			num27 = num17;
			point2 = tapex;
			point3 = torg;
			point4 = tdest;
			IL_2F9:
			if (offcenter && offconstant > 0.0)
			{
				if (num22 == 213 || num22 == 231)
				{
					double num28 = 0.5 * num23 - offconstant * num24;
					double num29 = 0.5 * num24 + offconstant * num23;
					if (num28 * num28 + num29 * num29 < (num20 - num10) * (num20 - num10) + (num21 - num11) * (num21 - num11))
					{
						num20 = num10 + num28;
						num21 = num11 + num29;
					}
					else
					{
						num = 1;
					}
				}
				else if (num22 == 123 || num22 == 132)
				{
					double num28 = 0.5 * num23 + offconstant * num24;
					double num29 = 0.5 * num24 - offconstant * num23;
					if (num28 * num28 + num29 * num29 < num20 * num20 + num21 * num21)
					{
						num20 = num28;
						num21 = num29;
					}
					else
					{
						num = 1;
					}
				}
				else
				{
					double num28 = 0.5 * num23 - offconstant * num24;
					double num29 = 0.5 * num24 + offconstant * num23;
					if (num28 * num28 + num29 * num29 < num20 * num20 + num21 * num21)
					{
						num20 = num28;
						num21 = num29;
					}
					else
					{
						num = 1;
					}
				}
			}
			if (num == 1)
			{
				double num30 = (num26 + num25 - num27) / (2.0 * Math.Sqrt(num26) * Math.Sqrt(num25));
				bool flag = num30 < 0.0 || Math.Abs(num30 - 0.0) <= 1E-50;
				num7 = this.DoSmoothing(otri2, torg, tdest, tapex, ref array4);
				if (num7 > 0)
				{
					Statistic.RelocationCount += 1L;
					num20 = array4[0] - torg.x;
					num21 = array4[1] - torg.y;
					num8 = torg.x;
					num9 = torg.y;
					switch (num7)
					{
					case 1:
						this.mesh.DeleteVertex(ref otri2);
						break;
					case 2:
						otri2.LnextSelf();
						this.mesh.DeleteVertex(ref otri2);
						break;
					case 3:
						otri2.LprevSelf();
						this.mesh.DeleteVertex(ref otri2);
						break;
					}
				}
				else
				{
					double num31 = Math.Sqrt(num25) / (2.0 * Math.Sin(this.behavior.MinAngle * 3.141592653589793 / 180.0));
					double num32 = (point3.x + point4.x) / 2.0;
					double num33 = (point3.y + point4.y) / 2.0;
					double num34 = num32 + Math.Sqrt(num31 * num31 - num25 / 4.0) * (point3.y - point4.y) / Math.Sqrt(num25);
					double num35 = num33 + Math.Sqrt(num31 * num31 - num25 / 4.0) * (point4.x - point3.x) / Math.Sqrt(num25);
					double num36 = num32 - Math.Sqrt(num31 * num31 - num25 / 4.0) * (point3.y - point4.y) / Math.Sqrt(num25);
					double num37 = num33 - Math.Sqrt(num31 * num31 - num25 / 4.0) * (point4.x - point3.x) / Math.Sqrt(num25);
					double num38 = (num34 - point2.x) * (num34 - point2.x);
					double num39 = (num35 - point2.y) * (num35 - point2.y);
					double num40 = (num36 - point2.x) * (num36 - point2.x);
					double num41 = (num37 - point2.y) * (num37 - point2.y);
					double num42;
					double num43;
					if (num38 + num39 <= num40 + num41)
					{
						num42 = num34;
						num43 = num35;
					}
					else
					{
						num42 = num36;
						num43 = num37;
					}
					bool neighborsVertex = this.GetNeighborsVertex(badotri, point3.x, point3.y, point2.x, point2.y, ref array, ref otri);
					double num44 = num20;
					double num45 = num21;
					if (!neighborsVertex)
					{
						Point point5 = otri.Org();
						Vertex vertex = otri.Dest();
						Vertex vertex2 = otri.Apex();
						Point point6 = Primitives.FindCircumcenter(point5, vertex, vertex2, ref num2, ref num3);
						double num46 = point3.y - point2.y;
						double num47 = point2.x - point3.x;
						num46 = point.x + num46;
						num47 = point.y + num47;
						this.CircleLineIntersection(point.x, point.y, num46, num47, num42, num43, num31, ref array2);
						double num48 = (point3.x + point2.x) / 2.0;
						double num49 = (point3.y + point2.y) / 2.0;
						double num50;
						double num51;
						if (this.ChooseCorrectPoint(num48, num49, array2[3], array2[4], point.x, point.y, flag))
						{
							num50 = array2[3];
							num51 = array2[4];
						}
						else
						{
							num50 = array2[1];
							num51 = array2[2];
						}
						this.PointBetweenPoints(num50, num51, point.x, point.y, point6.x, point6.y, ref array3);
						if (array2[0] > 0.0)
						{
							if (Math.Abs(array3[0] - 1.0) <= 1E-50)
							{
								if (this.IsBadTriangleAngle(point3.x, point3.y, point4.x, point4.y, point6.x, point6.y))
								{
									num44 = num20;
									num45 = num21;
								}
								else
								{
									num44 = array3[2] - torg.x;
									num45 = array3[3] - torg.y;
								}
							}
							else if (this.IsBadTriangleAngle(point4.x, point4.y, point3.x, point3.y, num50, num51))
							{
								double num52 = Math.Sqrt((num50 - point.x) * (num50 - point.x) + (num51 - point.y) * (num51 - point.y));
								double num53 = point.x - num50;
								double num54 = point.y - num51;
								num53 /= num52;
								num54 /= num52;
								num50 += num53 * num4 * Math.Sqrt(num25);
								num51 += num54 * num4 * Math.Sqrt(num25);
								if (this.IsBadTriangleAngle(point3.x, point3.y, point4.x, point4.y, num50, num51))
								{
									num44 = num20;
									num45 = num21;
								}
								else
								{
									num44 = num50 - torg.x;
									num45 = num51 - torg.y;
								}
							}
							else
							{
								num44 = num50 - torg.x;
								num45 = num51 - torg.y;
							}
							if ((point2.x - point.x) * (point2.x - point.x) + (point2.y - point.y) * (point2.y - point.y) > num5 * ((point2.x - (num44 + torg.x)) * (point2.x - (num44 + torg.x)) + (point2.y - (num45 + torg.y)) * (point2.y - (num45 + torg.y))))
							{
								num44 = num20;
								num45 = num21;
							}
						}
					}
					bool neighborsVertex2 = this.GetNeighborsVertex(badotri, point4.x, point4.y, point2.x, point2.y, ref array, ref otri);
					double num55 = num20;
					double num56 = num21;
					if (!neighborsVertex2)
					{
						Point point7 = otri.Org();
						Vertex vertex = otri.Dest();
						Vertex vertex2 = otri.Apex();
						Point point6 = Primitives.FindCircumcenter(point7, vertex, vertex2, ref num2, ref num3);
						double num46 = point4.y - point2.y;
						double num47 = point2.x - point4.x;
						num46 = point.x + num46;
						num47 = point.y + num47;
						this.CircleLineIntersection(point.x, point.y, num46, num47, num42, num43, num31, ref array2);
						double num57 = (point4.x + point2.x) / 2.0;
						double num58 = (point4.y + point2.y) / 2.0;
						double num50;
						double num51;
						if (this.ChooseCorrectPoint(num57, num58, array2[3], array2[4], point.x, point.y, false))
						{
							num50 = array2[3];
							num51 = array2[4];
						}
						else
						{
							num50 = array2[1];
							num51 = array2[2];
						}
						this.PointBetweenPoints(num50, num51, point.x, point.y, point6.x, point6.y, ref array3);
						if (array2[0] > 0.0)
						{
							if (Math.Abs(array3[0] - 1.0) <= 1E-50)
							{
								if (this.IsBadTriangleAngle(point3.x, point3.y, point4.x, point4.y, point6.x, point6.y))
								{
									num55 = num20;
									num56 = num21;
								}
								else
								{
									num55 = array3[2] - torg.x;
									num56 = array3[3] - torg.y;
								}
							}
							else if (this.IsBadTriangleAngle(point3.x, point3.y, point4.x, point4.y, num50, num51))
							{
								double num52 = Math.Sqrt((num50 - point.x) * (num50 - point.x) + (num51 - point.y) * (num51 - point.y));
								double num53 = point.x - num50;
								double num54 = point.y - num51;
								num53 /= num52;
								num54 /= num52;
								num50 += num53 * num4 * Math.Sqrt(num25);
								num51 += num54 * num4 * Math.Sqrt(num25);
								if (this.IsBadTriangleAngle(point3.x, point3.y, point4.x, point4.y, num50, num51))
								{
									num55 = num20;
									num56 = num21;
								}
								else
								{
									num55 = num50 - torg.x;
									num56 = num51 - torg.y;
								}
							}
							else
							{
								num55 = num50 - torg.x;
								num56 = num51 - torg.y;
							}
							if ((point2.x - point.x) * (point2.x - point.x) + (point2.y - point.y) * (point2.y - point.y) > num5 * ((point2.x - (num55 + torg.x)) * (point2.x - (num55 + torg.x)) + (point2.y - (num56 + torg.y)) * (point2.y - (num56 + torg.y))))
							{
								num55 = num20;
								num56 = num21;
							}
						}
					}
					if (flag)
					{
						num20 = num44;
						num21 = num45;
					}
					else if (num6 * ((point2.x - (num55 + torg.x)) * (point2.x - (num55 + torg.x)) + (point2.y - (num56 + torg.y)) * (point2.y - (num56 + torg.y))) > (point2.x - (num44 + torg.x)) * (point2.x - (num44 + torg.x)) + (point2.y - (num45 + torg.y)) * (point2.y - (num45 + torg.y)))
					{
						num20 = num55;
						num21 = num56;
					}
					else
					{
						num20 = num44;
						num21 = num45;
					}
				}
			}
			Point point8 = new Point();
			if (num7 <= 0)
			{
				point8.x = torg.x + num20;
				point8.y = torg.y + num21;
			}
			else
			{
				point8.x = num8 + num20;
				point8.y = num9 + num21;
			}
			xi = (num13 * num20 - num12 * num21) * (2.0 * num19);
			eta = (num10 * num21 - num11 * num20) * (2.0 * num19);
			return point8;
		}

		// Token: 0x0600003F RID: 63 RVA: 0x00004DB8 File Offset: 0x00002FB8
		private Point FindNewLocation(Vertex torg, Vertex tdest, Vertex tapex, ref double xi, ref double eta, bool offcenter, Otri badotri)
		{
			double offconstant = this.behavior.offconstant;
			int num = 0;
			Otri otri = default(Otri);
			double[] array = new double[2];
			double num2 = 0.0;
			double num3 = 0.0;
			double[] array2 = new double[5];
			double[] array3 = new double[4];
			double num4 = 0.06;
			double num5 = 1.0;
			double num6 = 1.0;
			int num7 = 0;
			double[] array4 = new double[2];
			double num8 = 0.0;
			double num9 = 0.0;
			double num10 = 0.0;
			double num11 = 0.0;
			double[] array5 = new double[3];
			double[] array6 = new double[4];
			Statistic.CircumcenterCount += 1L;
			double num12 = tdest.x - torg.x;
			double num13 = tdest.y - torg.y;
			double num14 = tapex.x - torg.x;
			double num15 = tapex.y - torg.y;
			double num16 = tapex.x - tdest.x;
			double num17 = tapex.y - tdest.y;
			double num18 = num12 * num12 + num13 * num13;
			double num19 = num14 * num14 + num15 * num15;
			double num20 = (tdest.x - tapex.x) * (tdest.x - tapex.x) + (tdest.y - tapex.y) * (tdest.y - tapex.y);
			double num21;
			if (Behavior.NoExact)
			{
				num21 = 0.5 / (num12 * num15 - num14 * num13);
			}
			else
			{
				num21 = 0.5 / Primitives.CounterClockwise(tdest, tapex, torg);
				Statistic.CounterClockwiseCount -= 1L;
			}
			double num22 = (num15 * num18 - num13 * num19) * num21;
			double num23 = (num12 * num19 - num14 * num18) * num21;
			Point point = new Point(torg.x + num22, torg.y + num23);
			Otri otri2 = badotri;
			int num24 = this.LongestShortestEdge(num19, num20, num18);
			double num25;
			double num26;
			double num27;
			double num28;
			double num29;
			Point point2;
			Point point3;
			Point point4;
			if (num24 <= 213)
			{
				if (num24 == 123)
				{
					num25 = num14;
					num26 = num15;
					num27 = num19;
					num28 = num20;
					num29 = num18;
					point2 = tdest;
					point3 = torg;
					point4 = tapex;
					goto IL_31F;
				}
				if (num24 == 132)
				{
					num25 = num14;
					num26 = num15;
					num27 = num19;
					num28 = num18;
					num29 = num20;
					point2 = tdest;
					point3 = tapex;
					point4 = torg;
					goto IL_31F;
				}
				if (num24 == 213)
				{
					num25 = num16;
					num26 = num17;
					num27 = num20;
					num28 = num19;
					num29 = num18;
					point2 = torg;
					point3 = tdest;
					point4 = tapex;
					goto IL_31F;
				}
			}
			else
			{
				if (num24 == 231)
				{
					num25 = num16;
					num26 = num17;
					num27 = num20;
					num28 = num18;
					num29 = num19;
					point2 = torg;
					point3 = tapex;
					point4 = tdest;
					goto IL_31F;
				}
				if (num24 == 312)
				{
					num25 = num12;
					num26 = num13;
					num27 = num18;
					num28 = num19;
					num29 = num20;
					point2 = tapex;
					point3 = tdest;
					point4 = torg;
					goto IL_31F;
				}
				if (num24 != 321)
				{
				}
			}
			num25 = num12;
			num26 = num13;
			num27 = num18;
			num28 = num20;
			num29 = num19;
			point2 = tapex;
			point3 = torg;
			point4 = tdest;
			IL_31F:
			if (offcenter && offconstant > 0.0)
			{
				if (num24 == 213 || num24 == 231)
				{
					double num30 = 0.5 * num25 - offconstant * num26;
					double num31 = 0.5 * num26 + offconstant * num25;
					if (num30 * num30 + num31 * num31 < (num22 - num12) * (num22 - num12) + (num23 - num13) * (num23 - num13))
					{
						num22 = num12 + num30;
						num23 = num13 + num31;
					}
					else
					{
						num = 1;
					}
				}
				else if (num24 == 123 || num24 == 132)
				{
					double num30 = 0.5 * num25 + offconstant * num26;
					double num31 = 0.5 * num26 - offconstant * num25;
					if (num30 * num30 + num31 * num31 < num22 * num22 + num23 * num23)
					{
						num22 = num30;
						num23 = num31;
					}
					else
					{
						num = 1;
					}
				}
				else
				{
					double num30 = 0.5 * num25 - offconstant * num26;
					double num31 = 0.5 * num26 + offconstant * num25;
					if (num30 * num30 + num31 * num31 < num22 * num22 + num23 * num23)
					{
						num22 = num30;
						num23 = num31;
					}
					else
					{
						num = 1;
					}
				}
			}
			if (num == 1)
			{
				double num32 = (num28 + num27 - num29) / (2.0 * Math.Sqrt(num28) * Math.Sqrt(num27));
				bool flag = num32 < 0.0 || Math.Abs(num32 - 0.0) <= 1E-50;
				num7 = this.DoSmoothing(otri2, torg, tdest, tapex, ref array4);
				if (num7 > 0)
				{
					Statistic.RelocationCount += 1L;
					num22 = array4[0] - torg.x;
					num23 = array4[1] - torg.y;
					num8 = torg.x;
					num9 = torg.y;
					switch (num7)
					{
					case 1:
						this.mesh.DeleteVertex(ref otri2);
						break;
					case 2:
						otri2.LnextSelf();
						this.mesh.DeleteVertex(ref otri2);
						break;
					case 3:
						otri2.LprevSelf();
						this.mesh.DeleteVertex(ref otri2);
						break;
					}
				}
				else
				{
					double num33 = Math.Acos((num28 + num29 - num27) / (2.0 * Math.Sqrt(num28) * Math.Sqrt(num29))) * 180.0 / 3.141592653589793;
					if (this.behavior.MinAngle > num33)
					{
						num33 = this.behavior.MinAngle;
					}
					else
					{
						num33 += 0.5;
					}
					double num34 = Math.Sqrt(num27) / (2.0 * Math.Sin(num33 * 3.141592653589793 / 180.0));
					double num35 = (point3.x + point4.x) / 2.0;
					double num36 = (point3.y + point4.y) / 2.0;
					double num37 = num35 + Math.Sqrt(num34 * num34 - num27 / 4.0) * (point3.y - point4.y) / Math.Sqrt(num27);
					double num38 = num36 + Math.Sqrt(num34 * num34 - num27 / 4.0) * (point4.x - point3.x) / Math.Sqrt(num27);
					double num39 = num35 - Math.Sqrt(num34 * num34 - num27 / 4.0) * (point3.y - point4.y) / Math.Sqrt(num27);
					double num40 = num36 - Math.Sqrt(num34 * num34 - num27 / 4.0) * (point4.x - point3.x) / Math.Sqrt(num27);
					double num41 = (num37 - point2.x) * (num37 - point2.x);
					double num42 = (num38 - point2.y) * (num38 - point2.y);
					double num43 = (num39 - point2.x) * (num39 - point2.x);
					double num44 = (num40 - point2.y) * (num40 - point2.y);
					double num45;
					double num46;
					if (num41 + num42 <= num43 + num44)
					{
						num45 = num37;
						num46 = num38;
					}
					else
					{
						num45 = num39;
						num46 = num40;
					}
					bool neighborsVertex = this.GetNeighborsVertex(badotri, point3.x, point3.y, point2.x, point2.y, ref array, ref otri);
					double num47 = num22;
					double num48 = num23;
					double num49 = Math.Sqrt((num45 - num35) * (num45 - num35) + (num46 - num36) * (num46 - num36));
					double num50 = (num45 - num35) / num49;
					double num51 = (num46 - num36) / num49;
					double num52 = num45 + num50 * num34;
					double num53 = num46 + num51 * num34;
					double num54 = (2.0 * this.behavior.MaxAngle + num33 - 180.0) * 3.141592653589793 / 180.0;
					double num55 = num52 * Math.Cos(num54) + num53 * Math.Sin(num54) + num45 - num45 * Math.Cos(num54) - num46 * Math.Sin(num54);
					double num56 = -num52 * Math.Sin(num54) + num53 * Math.Cos(num54) + num46 + num45 * Math.Sin(num54) - num46 * Math.Cos(num54);
					double num57 = num52 * Math.Cos(num54) - num53 * Math.Sin(num54) + num45 - num45 * Math.Cos(num54) + num46 * Math.Sin(num54);
					double num58 = num52 * Math.Sin(num54) + num53 * Math.Cos(num54) + num46 - num45 * Math.Sin(num54) - num46 * Math.Cos(num54);
					double num59;
					double num60;
					double num61;
					double num62;
					if (this.ChooseCorrectPoint(num57, num58, point3.x, point3.y, num55, num56, true))
					{
						num59 = num55;
						num60 = num56;
						num61 = num57;
						num62 = num58;
					}
					else
					{
						num59 = num57;
						num60 = num58;
						num61 = num55;
						num62 = num56;
					}
					double num63 = (point3.x + point2.x) / 2.0;
					double num64 = (point3.y + point2.y) / 2.0;
					if (!neighborsVertex)
					{
						Point point5 = otri.Org();
						Vertex vertex = otri.Dest();
						Vertex vertex2 = otri.Apex();
						Point point6 = Primitives.FindCircumcenter(point5, vertex, vertex2, ref num2, ref num3);
						double num65 = point3.y - point2.y;
						double num66 = point2.x - point3.x;
						num65 = point.x + num65;
						num66 = point.y + num66;
						this.CircleLineIntersection(point.x, point.y, num65, num66, num45, num46, num34, ref array2);
						double num67;
						double num68;
						if (this.ChooseCorrectPoint(num63, num64, array2[3], array2[4], point.x, point.y, flag))
						{
							num67 = array2[3];
							num68 = array2[4];
						}
						else
						{
							num67 = array2[1];
							num68 = array2[2];
						}
						double num69 = point3.x;
						double num70 = point3.y;
						num50 = point4.x - point3.x;
						num51 = point4.y - point3.y;
						double num71 = num59;
						double num72 = num60;
						this.LineLineIntersection(point.x, point.y, num65, num66, num69, num70, num71, num72, ref array5);
						if (array5[0] > 0.0)
						{
							num10 = array5[1];
							num11 = array5[2];
						}
						this.PointBetweenPoints(num67, num68, point.x, point.y, point6.x, point6.y, ref array3);
						if (array2[0] > 0.0)
						{
							if (Math.Abs(array3[0] - 1.0) <= 1E-50)
							{
								this.PointBetweenPoints(array3[2], array3[3], point.x, point.y, num10, num11, ref array6);
								if (Math.Abs(array6[0] - 1.0) <= 1E-50 && array5[0] > 0.0)
								{
									if ((point2.x - num59) * (point2.x - num59) + (point2.y - num60) * (point2.y - num60) > num5 * ((point2.x - num10) * (point2.x - num10) + (point2.y - num11) * (point2.y - num11)) && this.IsBadTriangleAngle(point3.x, point3.y, point4.x, point4.y, num59, num60) && this.MinDistanceToNeighbor(num59, num60, ref otri) > this.MinDistanceToNeighbor(num10, num11, ref otri))
									{
										num47 = num59 - torg.x;
										num48 = num60 - torg.y;
									}
									else if (this.IsBadTriangleAngle(point3.x, point3.y, point4.x, point4.y, num10, num11))
									{
										double num73 = Math.Sqrt((num10 - point.x) * (num10 - point.x) + (num11 - point.y) * (num11 - point.y));
										double num74 = point.x - num10;
										double num75 = point.y - num11;
										num74 /= num73;
										num75 /= num73;
										num10 += num74 * num4 * Math.Sqrt(num27);
										num11 += num75 * num4 * Math.Sqrt(num27);
										if (this.IsBadTriangleAngle(point3.x, point3.y, point4.x, point4.y, num10, num11))
										{
											num47 = num22;
											num48 = num23;
										}
										else
										{
											num47 = num10 - torg.x;
											num48 = num11 - torg.y;
										}
									}
									else
									{
										num47 = array6[2] - torg.x;
										num48 = array6[3] - torg.y;
									}
								}
								else if (this.IsBadTriangleAngle(point3.x, point3.y, point4.x, point4.y, point6.x, point6.y))
								{
									num47 = num22;
									num48 = num23;
								}
								else
								{
									num47 = array3[2] - torg.x;
									num48 = array3[3] - torg.y;
								}
							}
							else
							{
								this.PointBetweenPoints(num67, num68, point.x, point.y, num10, num11, ref array6);
								if (Math.Abs(array6[0] - 1.0) <= 1E-50 && array5[0] > 0.0)
								{
									if ((point2.x - num59) * (point2.x - num59) + (point2.y - num60) * (point2.y - num60) > num5 * ((point2.x - num10) * (point2.x - num10) + (point2.y - num11) * (point2.y - num11)) && this.IsBadTriangleAngle(point3.x, point3.y, point4.x, point4.y, num59, num60) && this.MinDistanceToNeighbor(num59, num60, ref otri) > this.MinDistanceToNeighbor(num10, num11, ref otri))
									{
										num47 = num59 - torg.x;
										num48 = num60 - torg.y;
									}
									else if (this.IsBadTriangleAngle(point4.x, point4.y, point3.x, point3.y, num10, num11))
									{
										double num73 = Math.Sqrt((num10 - point.x) * (num10 - point.x) + (num11 - point.y) * (num11 - point.y));
										double num74 = point.x - num10;
										double num75 = point.y - num11;
										num74 /= num73;
										num75 /= num73;
										num10 += num74 * num4 * Math.Sqrt(num27);
										num11 += num75 * num4 * Math.Sqrt(num27);
										if (this.IsBadTriangleAngle(point3.x, point3.y, point4.x, point4.y, num10, num11))
										{
											num47 = num22;
											num48 = num23;
										}
										else
										{
											num47 = num10 - torg.x;
											num48 = num11 - torg.y;
										}
									}
									else
									{
										num47 = array6[2] - torg.x;
										num48 = array6[3] - torg.y;
									}
								}
								else if (this.IsBadTriangleAngle(point4.x, point4.y, point3.x, point3.y, num67, num68))
								{
									double num73 = Math.Sqrt((num67 - point.x) * (num67 - point.x) + (num68 - point.y) * (num68 - point.y));
									double num74 = point.x - num67;
									double num75 = point.y - num68;
									num74 /= num73;
									num75 /= num73;
									num67 += num74 * num4 * Math.Sqrt(num27);
									num68 += num75 * num4 * Math.Sqrt(num27);
									if (this.IsBadTriangleAngle(point3.x, point3.y, point4.x, point4.y, num67, num68))
									{
										num47 = num22;
										num48 = num23;
									}
									else
									{
										num47 = num67 - torg.x;
										num48 = num68 - torg.y;
									}
								}
								else
								{
									num47 = num67 - torg.x;
									num48 = num68 - torg.y;
								}
							}
							if ((point2.x - point.x) * (point2.x - point.x) + (point2.y - point.y) * (point2.y - point.y) > num5 * ((point2.x - (num47 + torg.x)) * (point2.x - (num47 + torg.x)) + (point2.y - (num48 + torg.y)) * (point2.y - (num48 + torg.y))))
							{
								num47 = num22;
								num48 = num23;
							}
						}
					}
					bool neighborsVertex2 = this.GetNeighborsVertex(badotri, point4.x, point4.y, point2.x, point2.y, ref array, ref otri);
					double num76 = num22;
					double num77 = num23;
					double num78 = (point4.x + point2.x) / 2.0;
					double num79 = (point4.y + point2.y) / 2.0;
					if (!neighborsVertex2)
					{
						Point point7 = otri.Org();
						Vertex vertex = otri.Dest();
						Vertex vertex2 = otri.Apex();
						Point point6 = Primitives.FindCircumcenter(point7, vertex, vertex2, ref num2, ref num3);
						double num65 = point4.y - point2.y;
						double num66 = point2.x - point4.x;
						num65 = point.x + num65;
						num66 = point.y + num66;
						this.CircleLineIntersection(point.x, point.y, num65, num66, num45, num46, num34, ref array2);
						double num67;
						double num68;
						if (this.ChooseCorrectPoint(num78, num79, array2[3], array2[4], point.x, point.y, false))
						{
							num67 = array2[3];
							num68 = array2[4];
						}
						else
						{
							num67 = array2[1];
							num68 = array2[2];
						}
						double num69 = point4.x;
						double num70 = point4.y;
						num50 = point3.x - point4.x;
						num51 = point3.y - point4.y;
						double num71 = num61;
						double num72 = num62;
						this.LineLineIntersection(point.x, point.y, num65, num66, num69, num70, num71, num72, ref array5);
						if (array5[0] > 0.0)
						{
							num10 = array5[1];
							num11 = array5[2];
						}
						this.PointBetweenPoints(num67, num68, point.x, point.y, point6.x, point6.y, ref array3);
						if (array2[0] > 0.0)
						{
							if (Math.Abs(array3[0] - 1.0) <= 1E-50)
							{
								this.PointBetweenPoints(array3[2], array3[3], point.x, point.y, num10, num11, ref array6);
								if (Math.Abs(array6[0] - 1.0) <= 1E-50 && array5[0] > 0.0)
								{
									if ((point2.x - num61) * (point2.x - num61) + (point2.y - num62) * (point2.y - num62) > num5 * ((point2.x - num10) * (point2.x - num10) + (point2.y - num11) * (point2.y - num11)) && this.IsBadTriangleAngle(point3.x, point3.y, point4.x, point4.y, num61, num62) && this.MinDistanceToNeighbor(num61, num62, ref otri) > this.MinDistanceToNeighbor(num10, num11, ref otri))
									{
										num76 = num61 - torg.x;
										num77 = num62 - torg.y;
									}
									else if (this.IsBadTriangleAngle(point3.x, point3.y, point4.x, point4.y, num10, num11))
									{
										double num73 = Math.Sqrt((num10 - point.x) * (num10 - point.x) + (num11 - point.y) * (num11 - point.y));
										double num74 = point.x - num10;
										double num75 = point.y - num11;
										num74 /= num73;
										num75 /= num73;
										num10 += num74 * num4 * Math.Sqrt(num27);
										num11 += num75 * num4 * Math.Sqrt(num27);
										if (this.IsBadTriangleAngle(point3.x, point3.y, point4.x, point4.y, num10, num11))
										{
											num76 = num22;
											num77 = num23;
										}
										else
										{
											num76 = num10 - torg.x;
											num77 = num11 - torg.y;
										}
									}
									else
									{
										num76 = array6[2] - torg.x;
										num77 = array6[3] - torg.y;
									}
								}
								else if (this.IsBadTriangleAngle(point3.x, point3.y, point4.x, point4.y, point6.x, point6.y))
								{
									num76 = num22;
									num77 = num23;
								}
								else
								{
									num76 = array3[2] - torg.x;
									num77 = array3[3] - torg.y;
								}
							}
							else
							{
								this.PointBetweenPoints(num67, num68, point.x, point.y, num10, num11, ref array6);
								if (Math.Abs(array6[0] - 1.0) <= 1E-50 && array5[0] > 0.0)
								{
									if ((point2.x - num61) * (point2.x - num61) + (point2.y - num62) * (point2.y - num62) > num5 * ((point2.x - num10) * (point2.x - num10) + (point2.y - num11) * (point2.y - num11)) && this.IsBadTriangleAngle(point3.x, point3.y, point4.x, point4.y, num61, num62) && this.MinDistanceToNeighbor(num61, num62, ref otri) > this.MinDistanceToNeighbor(num10, num11, ref otri))
									{
										num76 = num61 - torg.x;
										num77 = num62 - torg.y;
									}
									else if (this.IsBadTriangleAngle(point4.x, point4.y, point3.x, point3.y, num10, num11))
									{
										double num73 = Math.Sqrt((num10 - point.x) * (num10 - point.x) + (num11 - point.y) * (num11 - point.y));
										double num74 = point.x - num10;
										double num75 = point.y - num11;
										num74 /= num73;
										num75 /= num73;
										num10 += num74 * num4 * Math.Sqrt(num27);
										num11 += num75 * num4 * Math.Sqrt(num27);
										if (this.IsBadTriangleAngle(point3.x, point3.y, point4.x, point4.y, num10, num11))
										{
											num76 = num22;
											num77 = num23;
										}
										else
										{
											num76 = num10 - torg.x;
											num77 = num11 - torg.y;
										}
									}
									else
									{
										num76 = array6[2] - torg.x;
										num77 = array6[3] - torg.y;
									}
								}
								else if (this.IsBadTriangleAngle(point3.x, point3.y, point4.x, point4.y, num67, num68))
								{
									double num73 = Math.Sqrt((num67 - point.x) * (num67 - point.x) + (num68 - point.y) * (num68 - point.y));
									double num74 = point.x - num67;
									double num75 = point.y - num68;
									num74 /= num73;
									num75 /= num73;
									num67 += num74 * num4 * Math.Sqrt(num27);
									num68 += num75 * num4 * Math.Sqrt(num27);
									if (this.IsBadTriangleAngle(point3.x, point3.y, point4.x, point4.y, num67, num68))
									{
										num76 = num22;
										num77 = num23;
									}
									else
									{
										num76 = num67 - torg.x;
										num77 = num68 - torg.y;
									}
								}
								else
								{
									num76 = num67 - torg.x;
									num77 = num68 - torg.y;
								}
							}
							if ((point2.x - point.x) * (point2.x - point.x) + (point2.y - point.y) * (point2.y - point.y) > num5 * ((point2.x - (num76 + torg.x)) * (point2.x - (num76 + torg.x)) + (point2.y - (num77 + torg.y)) * (point2.y - (num77 + torg.y))))
							{
								num76 = num22;
								num77 = num23;
							}
						}
					}
					if (flag)
					{
						if (neighborsVertex && neighborsVertex2)
						{
							if (num6 * ((point2.x - num78) * (point2.x - num78) + (point2.y - num79) * (point2.y - num79)) > (point2.x - num63) * (point2.x - num63) + (point2.y - num64) * (point2.y - num64))
							{
								num22 = num76;
								num23 = num77;
							}
							else
							{
								num22 = num47;
								num23 = num48;
							}
						}
						else if (neighborsVertex)
						{
							if (num6 * ((point2.x - (num76 + torg.x)) * (point2.x - (num76 + torg.x)) + (point2.y - (num77 + torg.y)) * (point2.y - (num77 + torg.y))) > (point2.x - num63) * (point2.x - num63) + (point2.y - num64) * (point2.y - num64))
							{
								num22 = num76;
								num23 = num77;
							}
							else
							{
								num22 = num47;
								num23 = num48;
							}
						}
						else if (neighborsVertex2)
						{
							if (num6 * ((point2.x - num78) * (point2.x - num78) + (point2.y - num79) * (point2.y - num79)) > (point2.x - (num47 + torg.x)) * (point2.x - (num47 + torg.x)) + (point2.y - (num48 + torg.y)) * (point2.y - (num48 + torg.y)))
							{
								num22 = num76;
								num23 = num77;
							}
							else
							{
								num22 = num47;
								num23 = num48;
							}
						}
						else if (num6 * ((point2.x - (num76 + torg.x)) * (point2.x - (num76 + torg.x)) + (point2.y - (num77 + torg.y)) * (point2.y - (num77 + torg.y))) > (point2.x - (num47 + torg.x)) * (point2.x - (num47 + torg.x)) + (point2.y - (num48 + torg.y)) * (point2.y - (num48 + torg.y)))
						{
							num22 = num76;
							num23 = num77;
						}
						else
						{
							num22 = num47;
							num23 = num48;
						}
					}
					else if (neighborsVertex && neighborsVertex2)
					{
						if (num6 * ((point2.x - num78) * (point2.x - num78) + (point2.y - num79) * (point2.y - num79)) > (point2.x - num63) * (point2.x - num63) + (point2.y - num64) * (point2.y - num64))
						{
							num22 = num76;
							num23 = num77;
						}
						else
						{
							num22 = num47;
							num23 = num48;
						}
					}
					else if (neighborsVertex)
					{
						if (num6 * ((point2.x - (num76 + torg.x)) * (point2.x - (num76 + torg.x)) + (point2.y - (num77 + torg.y)) * (point2.y - (num77 + torg.y))) > (point2.x - num63) * (point2.x - num63) + (point2.y - num64) * (point2.y - num64))
						{
							num22 = num76;
							num23 = num77;
						}
						else
						{
							num22 = num47;
							num23 = num48;
						}
					}
					else if (neighborsVertex2)
					{
						if (num6 * ((point2.x - num78) * (point2.x - num78) + (point2.y - num79) * (point2.y - num79)) > (point2.x - (num47 + torg.x)) * (point2.x - (num47 + torg.x)) + (point2.y - (num48 + torg.y)) * (point2.y - (num48 + torg.y)))
						{
							num22 = num76;
							num23 = num77;
						}
						else
						{
							num22 = num47;
							num23 = num48;
						}
					}
					else if (num6 * ((point2.x - (num76 + torg.x)) * (point2.x - (num76 + torg.x)) + (point2.y - (num77 + torg.y)) * (point2.y - (num77 + torg.y))) > (point2.x - (num47 + torg.x)) * (point2.x - (num47 + torg.x)) + (point2.y - (num48 + torg.y)) * (point2.y - (num48 + torg.y)))
					{
						num22 = num76;
						num23 = num77;
					}
					else
					{
						num22 = num47;
						num23 = num48;
					}
				}
			}
			Point point8 = new Point();
			if (num7 <= 0)
			{
				point8.x = torg.x + num22;
				point8.y = torg.y + num23;
			}
			else
			{
				point8.x = num8 + num22;
				point8.y = num9 + num23;
			}
			xi = (num15 * num22 - num14 * num23) * (2.0 * num21);
			eta = (num12 * num23 - num13 * num22) * (2.0 * num21);
			return point8;
		}

		// Token: 0x06000040 RID: 64 RVA: 0x00006C54 File Offset: 0x00004E54
		private int LongestShortestEdge(double aodist, double dadist, double dodist)
		{
			int num;
			int num2;
			int num3;
			if (dodist < aodist && dodist < dadist)
			{
				num = 3;
				if (aodist < dadist)
				{
					num2 = 2;
					num3 = 1;
				}
				else
				{
					num2 = 1;
					num3 = 2;
				}
			}
			else if (aodist < dadist)
			{
				num = 1;
				if (dodist < dadist)
				{
					num2 = 2;
					num3 = 3;
				}
				else
				{
					num2 = 3;
					num3 = 2;
				}
			}
			else
			{
				num = 2;
				if (aodist < dodist)
				{
					num2 = 3;
					num3 = 1;
				}
				else
				{
					num2 = 1;
					num3 = 3;
				}
			}
			return num * 100 + num3 * 10 + num2;
		}

		// Token: 0x06000041 RID: 65 RVA: 0x00006CB4 File Offset: 0x00004EB4
		private int DoSmoothing(Otri badotri, Vertex torg, Vertex tdest, Vertex tapex, ref double[] newloc)
		{
			double[] array = new double[6];
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			int num4 = 0;
			int starPoints = this.GetStarPoints(badotri, torg, tdest, tapex, 1, ref this.points_p);
			if (torg.type == VertexType.FreeVertex && starPoints != 0 && this.ValidPolygonAngles(starPoints, this.points_p))
			{
				bool flag;
				if (this.behavior.MaxAngle == 0.0)
				{
					flag = this.GetWedgeIntersectionWithoutMaxAngle(starPoints, this.points_p, ref newloc);
				}
				else
				{
					flag = this.GetWedgeIntersection(starPoints, this.points_p, ref newloc);
				}
				if (flag)
				{
					array[0] = newloc[0];
					array[1] = newloc[1];
					num++;
					num2 = 1;
				}
			}
			int starPoints2 = this.GetStarPoints(badotri, torg, tdest, tapex, 2, ref this.points_q);
			if (tdest.type == VertexType.FreeVertex && starPoints2 != 0 && this.ValidPolygonAngles(starPoints2, this.points_q))
			{
				bool flag;
				if (this.behavior.MaxAngle == 0.0)
				{
					flag = this.GetWedgeIntersectionWithoutMaxAngle(starPoints2, this.points_q, ref newloc);
				}
				else
				{
					flag = this.GetWedgeIntersection(starPoints2, this.points_q, ref newloc);
				}
				if (flag)
				{
					array[2] = newloc[0];
					array[3] = newloc[1];
					num++;
					num3 = 2;
				}
			}
			int starPoints3 = this.GetStarPoints(badotri, torg, tdest, tapex, 3, ref this.points_r);
			if (tapex.type == VertexType.FreeVertex && starPoints3 != 0 && this.ValidPolygonAngles(starPoints3, this.points_r))
			{
				bool flag;
				if (this.behavior.MaxAngle == 0.0)
				{
					flag = this.GetWedgeIntersectionWithoutMaxAngle(starPoints3, this.points_r, ref newloc);
				}
				else
				{
					flag = this.GetWedgeIntersection(starPoints3, this.points_r, ref newloc);
				}
				if (flag)
				{
					array[4] = newloc[0];
					array[5] = newloc[1];
					num++;
					num4 = 3;
				}
			}
			if (num > 0)
			{
				if (num2 > 0)
				{
					newloc[0] = array[0];
					newloc[1] = array[1];
					return num2;
				}
				if (num3 > 0)
				{
					newloc[0] = array[2];
					newloc[1] = array[3];
					return num3;
				}
				if (num4 > 0)
				{
					newloc[0] = array[4];
					newloc[1] = array[5];
					return num4;
				}
			}
			return 0;
		}

		// Token: 0x06000042 RID: 66 RVA: 0x00006EBC File Offset: 0x000050BC
		private int GetStarPoints(Otri badotri, Vertex p, Vertex q, Vertex r, int whichPoint, ref double[] points)
		{
			Otri otri = default(Otri);
			double num = 0.0;
			double num2 = 0.0;
			double num3 = 0.0;
			double num4 = 0.0;
			double num5 = 0.0;
			double num6 = 0.0;
			double[] array = new double[2];
			int num7 = 0;
			switch (whichPoint)
			{
			case 1:
				num = p.x;
				num2 = p.y;
				num3 = r.x;
				num4 = r.y;
				num5 = q.x;
				num6 = q.y;
				break;
			case 2:
				num = q.x;
				num2 = q.y;
				num3 = p.x;
				num4 = p.y;
				num5 = r.x;
				num6 = r.y;
				break;
			case 3:
				num = r.x;
				num2 = r.y;
				num3 = q.x;
				num4 = q.y;
				num5 = p.x;
				num6 = p.y;
				break;
			}
			Otri otri2 = badotri;
			points[num7] = num3;
			num7++;
			points[num7] = num4;
			num7++;
			array[0] = num3;
			array[1] = num4;
			while (!this.GetNeighborsVertex(otri2, num, num2, num3, num4, ref array, ref otri))
			{
				otri2 = otri;
				num3 = array[0];
				num4 = array[1];
				points[num7] = array[0];
				num7++;
				points[num7] = array[1];
				num7++;
				if (Math.Abs(array[0] - num5) <= 1E-50 && Math.Abs(array[1] - num6) <= 1E-50)
				{
					IL_1A1:
					return num7 / 2;
				}
			}
			num7 = 0;
			goto IL_1A1;
		}

		// Token: 0x06000043 RID: 67 RVA: 0x00007070 File Offset: 0x00005270
		private bool GetNeighborsVertex(Otri badotri, double first_x, double first_y, double second_x, double second_y, ref double[] thirdpoint, ref Otri neighotri)
		{
			Otri otri = default(Otri);
			bool flag = false;
			Vertex vertex = null;
			Vertex vertex2 = null;
			Vertex vertex3 = null;
			int num = 0;
			int num2 = 0;
			badotri.orient = 0;
			while (badotri.orient < 3)
			{
				badotri.Sym(ref otri);
				if (otri.triangle != Mesh.dummytri)
				{
					vertex = otri.Org();
					vertex2 = otri.Dest();
					vertex3 = otri.Apex();
					if ((vertex.x != vertex2.x || vertex.y != vertex2.y) && (vertex2.x != vertex3.x || vertex2.y != vertex3.y) && (vertex.x != vertex3.x || vertex.y != vertex3.y))
					{
						num = 0;
						if (Math.Abs(first_x - vertex.x) < 1E-50 && Math.Abs(first_y - vertex.y) < 1E-50)
						{
							num = 11;
						}
						else if (Math.Abs(first_x - vertex2.x) < 1E-50 && Math.Abs(first_y - vertex2.y) < 1E-50)
						{
							num = 12;
						}
						else if (Math.Abs(first_x - vertex3.x) < 1E-50 && Math.Abs(first_y - vertex3.y) < 1E-50)
						{
							num = 13;
						}
						num2 = 0;
						if (Math.Abs(second_x - vertex.x) < 1E-50 && Math.Abs(second_y - vertex.y) < 1E-50)
						{
							num2 = 21;
						}
						else if (Math.Abs(second_x - vertex2.x) < 1E-50 && Math.Abs(second_y - vertex2.y) < 1E-50)
						{
							num2 = 22;
						}
						else if (Math.Abs(second_x - vertex3.x) < 1E-50 && Math.Abs(second_y - vertex3.y) < 1E-50)
						{
							num2 = 23;
						}
					}
				}
				if ((num == 11 && (num2 == 22 || num2 == 23)) || (num == 12 && (num2 == 21 || num2 == 23)) || (num == 13 && (num2 == 21 || num2 == 22)))
				{
					break;
				}
				badotri.orient++;
			}
			if (num != 0)
			{
				switch (num)
				{
				case 11:
					if (num2 == 22)
					{
						thirdpoint[0] = vertex3.x;
						thirdpoint[1] = vertex3.y;
					}
					else if (num2 == 23)
					{
						thirdpoint[0] = vertex2.x;
						thirdpoint[1] = vertex2.y;
					}
					else
					{
						flag = true;
					}
					break;
				case 12:
					if (num2 == 21)
					{
						thirdpoint[0] = vertex3.x;
						thirdpoint[1] = vertex3.y;
					}
					else if (num2 == 23)
					{
						thirdpoint[0] = vertex.x;
						thirdpoint[1] = vertex.y;
					}
					else
					{
						flag = true;
					}
					break;
				case 13:
					if (num2 == 21)
					{
						thirdpoint[0] = vertex2.x;
						thirdpoint[1] = vertex2.y;
					}
					else if (num2 == 22)
					{
						thirdpoint[0] = vertex.x;
						thirdpoint[1] = vertex.y;
					}
					else
					{
						flag = true;
					}
					break;
				default:
					if (num2 == 0)
					{
						flag = true;
					}
					break;
				}
			}
			else
			{
				flag = true;
			}
			neighotri = otri;
			return flag;
		}

		// Token: 0x06000044 RID: 68 RVA: 0x000073D4 File Offset: 0x000055D4
		private bool GetWedgeIntersectionWithoutMaxAngle(int numpoints, double[] points, ref double[] newloc)
		{
			if (2 * numpoints > this.petalx.Length)
			{
				this.petalx = new double[2 * numpoints];
				this.petaly = new double[2 * numpoints];
				this.petalr = new double[2 * numpoints];
				this.wedges = new double[2 * numpoints * 16 + 36];
				if (Behavior.Verbose)
				{
					SimpleLog.Instance.Info("NewLocation: resized work arrays (" + 2 * numpoints + ")");
				}
			}
			double[] array = new double[3];
			int num = 0;
			double num2 = points[2 * numpoints - 4];
			double num3 = points[2 * numpoints - 3];
			double num4 = points[2 * numpoints - 2];
			double num5 = points[2 * numpoints - 1];
			double num6 = this.behavior.MinAngle * 3.141592653589793 / 180.0;
			double num7;
			double num8;
			if (this.behavior.goodAngle == 1.0)
			{
				num7 = 0.0;
				num8 = 0.0;
			}
			else
			{
				num7 = 0.5 / Math.Tan(num6);
				num8 = 0.5 / Math.Sin(num6);
			}
			for (int i = 0; i < numpoints * 2; i += 2)
			{
				double num9 = points[i];
				double num10 = points[i + 1];
				double num11 = num4 - num2;
				double num12 = num5 - num3;
				double num13 = Math.Sqrt(num11 * num11 + num12 * num12);
				this.petalx[i / 2] = num2 + 0.5 * num11 - num7 * num12;
				this.petaly[i / 2] = num3 + 0.5 * num12 + num7 * num11;
				this.petalr[i / 2] = num8 * num13;
				this.petalx[numpoints + i / 2] = this.petalx[i / 2];
				this.petaly[numpoints + i / 2] = this.petaly[i / 2];
				this.petalr[numpoints + i / 2] = this.petalr[i / 2];
				double num14 = (num2 + num4) / 2.0;
				double num15 = (num3 + num5) / 2.0;
				double num16 = Math.Sqrt((this.petalx[i / 2] - num14) * (this.petalx[i / 2] - num14) + (this.petaly[i / 2] - num15) * (this.petaly[i / 2] - num15));
				double num17 = (this.petalx[i / 2] - num14) / num16;
				double num18 = (this.petaly[i / 2] - num15) / num16;
				double num19 = this.petalx[i / 2] + num17 * this.petalr[i / 2];
				double num20 = this.petaly[i / 2] + num18 * this.petalr[i / 2];
				num17 = num4 - num2;
				num18 = num5 - num3;
				double num21 = num4 * Math.Cos(num6) - num5 * Math.Sin(num6) + num2 - num2 * Math.Cos(num6) + num3 * Math.Sin(num6);
				double num22 = num4 * Math.Sin(num6) + num5 * Math.Cos(num6) + num3 - num2 * Math.Sin(num6) - num3 * Math.Cos(num6);
				this.wedges[i * 16] = num2;
				this.wedges[i * 16 + 1] = num3;
				this.wedges[i * 16 + 2] = num21;
				this.wedges[i * 16 + 3] = num22;
				num17 = num2 - num4;
				num18 = num3 - num5;
				double num23 = num2 * Math.Cos(num6) + num3 * Math.Sin(num6) + num4 - num4 * Math.Cos(num6) - num5 * Math.Sin(num6);
				double num24 = -num2 * Math.Sin(num6) + num3 * Math.Cos(num6) + num5 + num4 * Math.Sin(num6) - num5 * Math.Cos(num6);
				this.wedges[i * 16 + 4] = num23;
				this.wedges[i * 16 + 5] = num24;
				this.wedges[i * 16 + 6] = num4;
				this.wedges[i * 16 + 7] = num5;
				num17 = num19 - this.petalx[i / 2];
				num18 = num20 - this.petaly[i / 2];
				double num25 = num19;
				double num26 = num20;
				for (int j = 1; j < 4; j++)
				{
					double num27 = num19 * Math.Cos((1.0471975511965976 - num6) * (double)j) + num20 * Math.Sin((1.0471975511965976 - num6) * (double)j) + this.petalx[i / 2] - this.petalx[i / 2] * Math.Cos((1.0471975511965976 - num6) * (double)j) - this.petaly[i / 2] * Math.Sin((1.0471975511965976 - num6) * (double)j);
					double num28 = -num19 * Math.Sin((1.0471975511965976 - num6) * (double)j) + num20 * Math.Cos((1.0471975511965976 - num6) * (double)j) + this.petaly[i / 2] + this.petalx[i / 2] * Math.Sin((1.0471975511965976 - num6) * (double)j) - this.petaly[i / 2] * Math.Cos((1.0471975511965976 - num6) * (double)j);
					this.wedges[i * 16 + 8 + 4 * (j - 1)] = num27;
					this.wedges[i * 16 + 9 + 4 * (j - 1)] = num28;
					this.wedges[i * 16 + 10 + 4 * (j - 1)] = num25;
					this.wedges[i * 16 + 11 + 4 * (j - 1)] = num26;
					num25 = num27;
					num26 = num28;
				}
				num25 = num19;
				num26 = num20;
				for (int j = 1; j < 4; j++)
				{
					double num29 = num19 * Math.Cos((1.0471975511965976 - num6) * (double)j) - num20 * Math.Sin((1.0471975511965976 - num6) * (double)j) + this.petalx[i / 2] - this.petalx[i / 2] * Math.Cos((1.0471975511965976 - num6) * (double)j) + this.petaly[i / 2] * Math.Sin((1.0471975511965976 - num6) * (double)j);
					double num30 = num19 * Math.Sin((1.0471975511965976 - num6) * (double)j) + num20 * Math.Cos((1.0471975511965976 - num6) * (double)j) + this.petaly[i / 2] - this.petalx[i / 2] * Math.Sin((1.0471975511965976 - num6) * (double)j) - this.petaly[i / 2] * Math.Cos((1.0471975511965976 - num6) * (double)j);
					this.wedges[i * 16 + 20 + 4 * (j - 1)] = num25;
					this.wedges[i * 16 + 21 + 4 * (j - 1)] = num26;
					this.wedges[i * 16 + 22 + 4 * (j - 1)] = num29;
					this.wedges[i * 16 + 23 + 4 * (j - 1)] = num30;
					num25 = num29;
					num26 = num30;
				}
				if (i == 0)
				{
					this.LineLineIntersection(num2, num3, num21, num22, num4, num5, num23, num24, ref array);
					if (array[0] == 1.0)
					{
						this.initialConvexPoly[0] = array[1];
						this.initialConvexPoly[1] = array[2];
						this.initialConvexPoly[2] = this.wedges[i * 16 + 16];
						this.initialConvexPoly[3] = this.wedges[i * 16 + 17];
						this.initialConvexPoly[4] = this.wedges[i * 16 + 12];
						this.initialConvexPoly[5] = this.wedges[i * 16 + 13];
						this.initialConvexPoly[6] = this.wedges[i * 16 + 8];
						this.initialConvexPoly[7] = this.wedges[i * 16 + 9];
						this.initialConvexPoly[8] = num19;
						this.initialConvexPoly[9] = num20;
						this.initialConvexPoly[10] = this.wedges[i * 16 + 22];
						this.initialConvexPoly[11] = this.wedges[i * 16 + 23];
						this.initialConvexPoly[12] = this.wedges[i * 16 + 26];
						this.initialConvexPoly[13] = this.wedges[i * 16 + 27];
						this.initialConvexPoly[14] = this.wedges[i * 16 + 30];
						this.initialConvexPoly[15] = this.wedges[i * 16 + 31];
					}
				}
				num2 = num4;
				num3 = num5;
				num4 = num9;
				num5 = num10;
			}
			if (numpoints != 0)
			{
				int num31 = (numpoints - 1) / 2 + 1;
				int num32 = 0;
				int k = 0;
				int i = 1;
				int num33 = 8;
				for (int j = 0; j < 32; j += 4)
				{
					num = this.HalfPlaneIntersection(num33, ref this.initialConvexPoly, this.wedges[32 * num31 + j], this.wedges[32 * num31 + 1 + j], this.wedges[32 * num31 + 2 + j], this.wedges[32 * num31 + 3 + j]);
					if (num == 0)
					{
						return false;
					}
					num33 = num;
				}
				for (k++; k < numpoints - 1; k++)
				{
					for (int j = 0; j < 32; j += 4)
					{
						num = this.HalfPlaneIntersection(num33, ref this.initialConvexPoly, this.wedges[32 * (i + num31 * num32) + j], this.wedges[32 * (i + num31 * num32) + 1 + j], this.wedges[32 * (i + num31 * num32) + 2 + j], this.wedges[32 * (i + num31 * num32) + 3 + j]);
						if (num == 0)
						{
							return false;
						}
						num33 = num;
					}
					i += num32;
					num32 = (num32 + 1) % 2;
				}
				this.FindPolyCentroid(num, this.initialConvexPoly, ref newloc);
				if (!this.behavior.fixedArea)
				{
					return true;
				}
			}
			return false;
		}

		// Token: 0x06000045 RID: 69 RVA: 0x00007DD0 File Offset: 0x00005FD0
		private bool GetWedgeIntersection(int numpoints, double[] points, ref double[] newloc)
		{
			if (2 * numpoints > this.petalx.Length)
			{
				this.petalx = new double[2 * numpoints];
				this.petaly = new double[2 * numpoints];
				this.petalr = new double[2 * numpoints];
				this.wedges = new double[2 * numpoints * 20 + 40];
				if (Behavior.Verbose)
				{
					SimpleLog.Instance.Info("NewLocation: resized work arrays (" + 2 * numpoints + ")");
				}
			}
			double[] array = new double[3];
			double[] array2 = new double[3];
			double[] array3 = new double[3];
			double[] array4 = new double[3];
			int num = 0;
			int num2 = 0;
			double num3 = points[2 * numpoints - 4];
			double num4 = points[2 * numpoints - 3];
			double num5 = points[2 * numpoints - 2];
			double num6 = points[2 * numpoints - 1];
			double num7 = this.behavior.MinAngle * 3.141592653589793 / 180.0;
			double num8 = Math.Sin(num7);
			double num9 = Math.Cos(num7);
			double num10 = this.behavior.MaxAngle * 3.141592653589793 / 180.0;
			double num11 = Math.Sin(num10);
			double num12 = Math.Cos(num10);
			double num13;
			double num14;
			if (this.behavior.goodAngle == 1.0)
			{
				num13 = 0.0;
				num14 = 0.0;
			}
			else
			{
				num13 = 0.5 / Math.Tan(num7);
				num14 = 0.5 / Math.Sin(num7);
			}
			for (int i = 0; i < numpoints * 2; i += 2)
			{
				double num15 = points[i];
				double num16 = points[i + 1];
				double num17 = num5 - num3;
				double num18 = num6 - num4;
				double num19 = Math.Sqrt(num17 * num17 + num18 * num18);
				this.petalx[i / 2] = num3 + 0.5 * num17 - num13 * num18;
				this.petaly[i / 2] = num4 + 0.5 * num18 + num13 * num17;
				this.petalr[i / 2] = num14 * num19;
				this.petalx[numpoints + i / 2] = this.petalx[i / 2];
				this.petaly[numpoints + i / 2] = this.petaly[i / 2];
				this.petalr[numpoints + i / 2] = this.petalr[i / 2];
				double num20 = (num3 + num5) / 2.0;
				double num21 = (num4 + num6) / 2.0;
				double num22 = Math.Sqrt((this.petalx[i / 2] - num20) * (this.petalx[i / 2] - num20) + (this.petaly[i / 2] - num21) * (this.petaly[i / 2] - num21));
				double num23 = (this.petalx[i / 2] - num20) / num22;
				double num24 = (this.petaly[i / 2] - num21) / num22;
				double num25 = this.petalx[i / 2] + num23 * this.petalr[i / 2];
				double num26 = this.petaly[i / 2] + num24 * this.petalr[i / 2];
				num23 = num5 - num3;
				num24 = num6 - num4;
				double num27 = num5 * num9 - num6 * num8 + num3 - num3 * num9 + num4 * num8;
				double num28 = num5 * num8 + num6 * num9 + num4 - num3 * num8 - num4 * num9;
				this.wedges[i * 20] = num3;
				this.wedges[i * 20 + 1] = num4;
				this.wedges[i * 20 + 2] = num27;
				this.wedges[i * 20 + 3] = num28;
				num23 = num3 - num5;
				num24 = num4 - num6;
				double num29 = num3 * num9 + num4 * num8 + num5 - num5 * num9 - num6 * num8;
				double num30 = -num3 * num8 + num4 * num9 + num6 + num5 * num8 - num6 * num9;
				this.wedges[i * 20 + 4] = num29;
				this.wedges[i * 20 + 5] = num30;
				this.wedges[i * 20 + 6] = num5;
				this.wedges[i * 20 + 7] = num6;
				num23 = num25 - this.petalx[i / 2];
				num24 = num26 - this.petaly[i / 2];
				double num31 = num25;
				double num32 = num26;
				num7 = 2.0 * this.behavior.MaxAngle + this.behavior.MinAngle - 180.0;
				double num33;
				double num34;
				if (num7 <= 0.0)
				{
					num2 = 4;
					num33 = 1.0;
					num34 = 1.0;
				}
				else if (num7 <= 5.0)
				{
					num2 = 6;
					num33 = 2.0;
					num34 = 2.0;
				}
				else if (num7 <= 10.0)
				{
					num2 = 8;
					num33 = 3.0;
					num34 = 3.0;
				}
				else
				{
					num2 = 10;
					num33 = 4.0;
					num34 = 4.0;
				}
				num7 = num7 * 3.141592653589793 / 180.0;
				int j = 1;
				while ((double)j < num33)
				{
					if (num33 != 1.0)
					{
						double num35 = num25 * Math.Cos(num7 / (num33 - 1.0) * (double)j) + num26 * Math.Sin(num7 / (num33 - 1.0) * (double)j) + this.petalx[i / 2] - this.petalx[i / 2] * Math.Cos(num7 / (num33 - 1.0) * (double)j) - this.petaly[i / 2] * Math.Sin(num7 / (num33 - 1.0) * (double)j);
						double num36 = -num25 * Math.Sin(num7 / (num33 - 1.0) * (double)j) + num26 * Math.Cos(num7 / (num33 - 1.0) * (double)j) + this.petaly[i / 2] + this.petalx[i / 2] * Math.Sin(num7 / (num33 - 1.0) * (double)j) - this.petaly[i / 2] * Math.Cos(num7 / (num33 - 1.0) * (double)j);
						this.wedges[i * 20 + 8 + 4 * (j - 1)] = num35;
						this.wedges[i * 20 + 9 + 4 * (j - 1)] = num36;
						this.wedges[i * 20 + 10 + 4 * (j - 1)] = num31;
						this.wedges[i * 20 + 11 + 4 * (j - 1)] = num32;
						num31 = num35;
						num32 = num36;
					}
					j++;
				}
				num23 = num3 - num5;
				num24 = num4 - num6;
				double num37 = num3 * num12 + num4 * num11 + num5 - num5 * num12 - num6 * num11;
				double num38 = -num3 * num11 + num4 * num12 + num6 + num5 * num11 - num6 * num12;
				this.wedges[i * 20 + 20] = num5;
				this.wedges[i * 20 + 21] = num6;
				this.wedges[i * 20 + 22] = num37;
				this.wedges[i * 20 + 23] = num38;
				num31 = num25;
				num32 = num26;
				j = 1;
				while ((double)j < num34)
				{
					if (num34 != 1.0)
					{
						double num39 = num25 * Math.Cos(num7 / (num34 - 1.0) * (double)j) - num26 * Math.Sin(num7 / (num34 - 1.0) * (double)j) + this.petalx[i / 2] - this.petalx[i / 2] * Math.Cos(num7 / (num34 - 1.0) * (double)j) + this.petaly[i / 2] * Math.Sin(num7 / (num34 - 1.0) * (double)j);
						double num40 = num25 * Math.Sin(num7 / (num34 - 1.0) * (double)j) + num26 * Math.Cos(num7 / (num34 - 1.0) * (double)j) + this.petaly[i / 2] - this.petalx[i / 2] * Math.Sin(num7 / (num34 - 1.0) * (double)j) - this.petaly[i / 2] * Math.Cos(num7 / (num34 - 1.0) * (double)j);
						this.wedges[i * 20 + 24 + 4 * (j - 1)] = num31;
						this.wedges[i * 20 + 25 + 4 * (j - 1)] = num32;
						this.wedges[i * 20 + 26 + 4 * (j - 1)] = num39;
						this.wedges[i * 20 + 27 + 4 * (j - 1)] = num40;
						num31 = num39;
						num32 = num40;
					}
					j++;
				}
				num23 = num5 - num3;
				num24 = num6 - num4;
				double num41 = num5 * num12 - num6 * num11 + num3 - num3 * num12 + num4 * num11;
				double num42 = num5 * num11 + num6 * num12 + num4 - num3 * num11 - num4 * num12;
				this.wedges[i * 20 + 36] = num41;
				this.wedges[i * 20 + 37] = num42;
				this.wedges[i * 20 + 38] = num3;
				this.wedges[i * 20 + 39] = num4;
				if (i == 0)
				{
					switch (num2)
					{
					case 4:
						this.LineLineIntersection(num3, num4, num27, num28, num5, num6, num29, num30, ref array);
						this.LineLineIntersection(num3, num4, num27, num28, num5, num6, num37, num38, ref array2);
						this.LineLineIntersection(num3, num4, num41, num42, num5, num6, num37, num38, ref array3);
						this.LineLineIntersection(num3, num4, num41, num42, num5, num6, num29, num30, ref array4);
						if (array[0] == 1.0 && array2[0] == 1.0 && array3[0] == 1.0 && array4[0] == 1.0)
						{
							this.initialConvexPoly[0] = array[1];
							this.initialConvexPoly[1] = array[2];
							this.initialConvexPoly[2] = array2[1];
							this.initialConvexPoly[3] = array2[2];
							this.initialConvexPoly[4] = array3[1];
							this.initialConvexPoly[5] = array3[2];
							this.initialConvexPoly[6] = array4[1];
							this.initialConvexPoly[7] = array4[2];
						}
						break;
					case 6:
						this.LineLineIntersection(num3, num4, num27, num28, num5, num6, num29, num30, ref array);
						this.LineLineIntersection(num3, num4, num27, num28, num5, num6, num37, num38, ref array2);
						this.LineLineIntersection(num3, num4, num41, num42, num5, num6, num29, num30, ref array3);
						if (array[0] == 1.0 && array2[0] == 1.0 && array3[0] == 1.0)
						{
							this.initialConvexPoly[0] = array[1];
							this.initialConvexPoly[1] = array[2];
							this.initialConvexPoly[2] = array2[1];
							this.initialConvexPoly[3] = array2[2];
							this.initialConvexPoly[4] = this.wedges[i * 20 + 8];
							this.initialConvexPoly[5] = this.wedges[i * 20 + 9];
							this.initialConvexPoly[6] = num25;
							this.initialConvexPoly[7] = num26;
							this.initialConvexPoly[8] = this.wedges[i * 20 + 26];
							this.initialConvexPoly[9] = this.wedges[i * 20 + 27];
							this.initialConvexPoly[10] = array3[1];
							this.initialConvexPoly[11] = array3[2];
						}
						break;
					case 8:
						this.LineLineIntersection(num3, num4, num27, num28, num5, num6, num29, num30, ref array);
						this.LineLineIntersection(num3, num4, num27, num28, num5, num6, num37, num38, ref array2);
						this.LineLineIntersection(num3, num4, num41, num42, num5, num6, num29, num30, ref array3);
						if (array[0] == 1.0 && array2[0] == 1.0 && array3[0] == 1.0)
						{
							this.initialConvexPoly[0] = array[1];
							this.initialConvexPoly[1] = array[2];
							this.initialConvexPoly[2] = array2[1];
							this.initialConvexPoly[3] = array2[2];
							this.initialConvexPoly[4] = this.wedges[i * 20 + 12];
							this.initialConvexPoly[5] = this.wedges[i * 20 + 13];
							this.initialConvexPoly[6] = this.wedges[i * 20 + 8];
							this.initialConvexPoly[7] = this.wedges[i * 20 + 9];
							this.initialConvexPoly[8] = num25;
							this.initialConvexPoly[9] = num26;
							this.initialConvexPoly[10] = this.wedges[i * 20 + 26];
							this.initialConvexPoly[11] = this.wedges[i * 20 + 27];
							this.initialConvexPoly[12] = this.wedges[i * 20 + 30];
							this.initialConvexPoly[13] = this.wedges[i * 20 + 31];
							this.initialConvexPoly[14] = array3[1];
							this.initialConvexPoly[15] = array3[2];
						}
						break;
					case 10:
						this.LineLineIntersection(num3, num4, num27, num28, num5, num6, num29, num30, ref array);
						this.LineLineIntersection(num3, num4, num27, num28, num5, num6, num37, num38, ref array2);
						this.LineLineIntersection(num3, num4, num41, num42, num5, num6, num29, num30, ref array3);
						if (array[0] == 1.0 && array2[0] == 1.0 && array3[0] == 1.0)
						{
							this.initialConvexPoly[0] = array[1];
							this.initialConvexPoly[1] = array[2];
							this.initialConvexPoly[2] = array2[1];
							this.initialConvexPoly[3] = array2[2];
							this.initialConvexPoly[4] = this.wedges[i * 20 + 16];
							this.initialConvexPoly[5] = this.wedges[i * 20 + 17];
							this.initialConvexPoly[6] = this.wedges[i * 20 + 12];
							this.initialConvexPoly[7] = this.wedges[i * 20 + 13];
							this.initialConvexPoly[8] = this.wedges[i * 20 + 8];
							this.initialConvexPoly[9] = this.wedges[i * 20 + 9];
							this.initialConvexPoly[10] = num25;
							this.initialConvexPoly[11] = num26;
							this.initialConvexPoly[12] = this.wedges[i * 20 + 28];
							this.initialConvexPoly[13] = this.wedges[i * 20 + 29];
							this.initialConvexPoly[14] = this.wedges[i * 20 + 32];
							this.initialConvexPoly[15] = this.wedges[i * 20 + 33];
							this.initialConvexPoly[16] = this.wedges[i * 20 + 34];
							this.initialConvexPoly[17] = this.wedges[i * 20 + 35];
							this.initialConvexPoly[18] = array3[1];
							this.initialConvexPoly[19] = array3[2];
						}
						break;
					}
				}
				num3 = num5;
				num4 = num6;
				num5 = num15;
				num6 = num16;
			}
			if (numpoints != 0)
			{
				int num43 = (numpoints - 1) / 2 + 1;
				int num44 = 0;
				int k = 0;
				int i = 1;
				int num45 = num2;
				for (int j = 0; j < 40; j += 4)
				{
					if ((num2 != 4 || (j != 8 && j != 12 && j != 16 && j != 24 && j != 28 && j != 32)) && (num2 != 6 || (j != 12 && j != 16 && j != 28 && j != 32)) && (num2 != 8 || (j != 16 && j != 32)))
					{
						num = this.HalfPlaneIntersection(num45, ref this.initialConvexPoly, this.wedges[40 * num43 + j], this.wedges[40 * num43 + 1 + j], this.wedges[40 * num43 + 2 + j], this.wedges[40 * num43 + 3 + j]);
						if (num == 0)
						{
							return false;
						}
						num45 = num;
					}
				}
				for (k++; k < numpoints - 1; k++)
				{
					for (int j = 0; j < 40; j += 4)
					{
						if ((num2 != 4 || (j != 8 && j != 12 && j != 16 && j != 24 && j != 28 && j != 32)) && (num2 != 6 || (j != 12 && j != 16 && j != 28 && j != 32)) && (num2 != 8 || (j != 16 && j != 32)))
						{
							num = this.HalfPlaneIntersection(num45, ref this.initialConvexPoly, this.wedges[40 * (i + num43 * num44) + j], this.wedges[40 * (i + num43 * num44) + 1 + j], this.wedges[40 * (i + num43 * num44) + 2 + j], this.wedges[40 * (i + num43 * num44) + 3 + j]);
							if (num == 0)
							{
								return false;
							}
							num45 = num;
						}
					}
					i += num44;
					num44 = (num44 + 1) % 2;
				}
				this.FindPolyCentroid(num, this.initialConvexPoly, ref newloc);
				if (this.behavior.MaxAngle == 0.0)
				{
					return true;
				}
				int num46 = 0;
				for (int j = 0; j < numpoints * 2 - 2; j += 2)
				{
					if (this.IsBadTriangleAngle(newloc[0], newloc[1], points[j], points[j + 1], points[j + 2], points[j + 3]))
					{
						num46++;
					}
				}
				if (this.IsBadTriangleAngle(newloc[0], newloc[1], points[0], points[1], points[numpoints * 2 - 2], points[numpoints * 2 - 1]))
				{
					num46++;
				}
				if (num46 == 0)
				{
					return true;
				}
				int num47 = ((numpoints <= 2) ? 20 : 30);
				for (int l = 0; l < 2 * numpoints; l += 2)
				{
					for (int m = 1; m < num47; m++)
					{
						newloc[0] = 0.0;
						newloc[1] = 0.0;
						for (i = 0; i < 2 * numpoints; i += 2)
						{
							double num48 = 1.0 / (double)numpoints;
							if (i == l)
							{
								newloc[0] = newloc[0] + 0.1 * (double)m * num48 * points[i];
								newloc[1] = newloc[1] + 0.1 * (double)m * num48 * points[i + 1];
							}
							else
							{
								num48 = (1.0 - 0.1 * (double)m * num48) / ((double)numpoints - 1.0);
								newloc[0] = newloc[0] + num48 * points[i];
								newloc[1] = newloc[1] + num48 * points[i + 1];
							}
						}
						num46 = 0;
						for (int j = 0; j < numpoints * 2 - 2; j += 2)
						{
							if (this.IsBadTriangleAngle(newloc[0], newloc[1], points[j], points[j + 1], points[j + 2], points[j + 3]))
							{
								num46++;
							}
						}
						if (this.IsBadTriangleAngle(newloc[0], newloc[1], points[0], points[1], points[numpoints * 2 - 2], points[numpoints * 2 - 1]))
						{
							num46++;
						}
						if (num46 == 0)
						{
							return true;
						}
					}
				}
			}
			return false;
		}

		// Token: 0x06000046 RID: 70 RVA: 0x00009160 File Offset: 0x00007360
		private bool ValidPolygonAngles(int numpoints, double[] points)
		{
			for (int i = 0; i < numpoints; i++)
			{
				if (i == numpoints - 1)
				{
					if (this.IsBadPolygonAngle(points[i * 2], points[i * 2 + 1], points[0], points[1], points[2], points[3]))
					{
						return false;
					}
				}
				else if (i == numpoints - 2)
				{
					if (this.IsBadPolygonAngle(points[i * 2], points[i * 2 + 1], points[(i + 1) * 2], points[(i + 1) * 2 + 1], points[0], points[1]))
					{
						return false;
					}
				}
				else if (this.IsBadPolygonAngle(points[i * 2], points[i * 2 + 1], points[(i + 1) * 2], points[(i + 1) * 2 + 1], points[(i + 2) * 2], points[(i + 2) * 2 + 1]))
				{
					return false;
				}
			}
			return true;
		}

		// Token: 0x06000047 RID: 71 RVA: 0x00009210 File Offset: 0x00007410
		private bool IsBadPolygonAngle(double x1, double y1, double x2, double y2, double x3, double y3)
		{
			double num = x1 - x2;
			double num2 = y1 - y2;
			double num3 = x2 - x3;
			double num4 = y2 - y3;
			double num5 = x3 - x1;
			double num6 = y3 - y1;
			double num7 = num * num + num2 * num2;
			double num8 = num3 * num3 + num4 * num4;
			double num9 = num5 * num5 + num6 * num6;
			return Math.Acos((num7 + num8 - num9) / (2.0 * Math.Sqrt(num7) * Math.Sqrt(num8))) < 2.0 * Math.Acos(Math.Sqrt(this.behavior.goodAngle));
		}

		// Token: 0x06000048 RID: 72 RVA: 0x000092A4 File Offset: 0x000074A4
		private void LineLineIntersection(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4, ref double[] p)
		{
			double num = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1);
			double num2 = (x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3);
			double num3 = (x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3);
			if (Math.Abs(num - 0.0) < 1E-50 && Math.Abs(num3 - 0.0) < 1E-50 && Math.Abs(num2 - 0.0) < 1E-50)
			{
				p[0] = 0.0;
				return;
			}
			if (Math.Abs(num - 0.0) < 1E-50)
			{
				p[0] = 0.0;
				return;
			}
			p[0] = 1.0;
			num2 /= num;
			num3 /= num;
			p[1] = x1 + num2 * (x2 - x1);
			p[2] = y1 + num2 * (y2 - y1);
		}

		// Token: 0x06000049 RID: 73 RVA: 0x000093A8 File Offset: 0x000075A8
		private int HalfPlaneIntersection(int numvertices, ref double[] convexPoly, double x1, double y1, double x2, double y2)
		{
			double[] array = null;
			int num = 0;
			int num2 = 0;
			double num3 = x2 - x1;
			double num4 = y2 - y1;
			int num5 = this.SplitConvexPolygon(numvertices, convexPoly, x1, y1, x2, y2, ref this.polys);
			if (num5 == 3)
			{
				num = numvertices;
			}
			else
			{
				for (int i = 0; i < num5; i++)
				{
					double num6 = 1E+17;
					double num7 = -1E+17;
					int num8 = 1;
					double num9;
					while ((double)num8 <= 2.0 * this.polys[i][0] - 1.0)
					{
						num9 = num3 * (this.polys[i][num8 + 1] - y1) - num4 * (this.polys[i][num8] - x1);
						num6 = ((num9 < num6) ? num9 : num6);
						num7 = ((num9 > num7) ? num9 : num7);
						num8 += 2;
					}
					num9 = ((Math.Abs(num6) > Math.Abs(num7)) ? num6 : num7);
					if (num9 > 0.0)
					{
						array = this.polys[i];
						num2 = 1;
						break;
					}
				}
				if (num2 == 1)
				{
					while ((double)num < array[0])
					{
						convexPoly[2 * num] = array[2 * num + 1];
						convexPoly[2 * num + 1] = array[2 * num + 2];
						num++;
					}
				}
			}
			return num;
		}

		// Token: 0x0600004A RID: 74 RVA: 0x000094F0 File Offset: 0x000076F0
		private int SplitConvexPolygon(int numvertices, double[] convexPoly, double x1, double y1, double x2, double y2, ref double[][] polys)
		{
			int num = 0;
			double[] array = new double[3];
			int num2 = 0;
			int num3 = 0;
			double num4 = 1E-12;
			int num5 = 0;
			int num6 = 0;
			int num7 = 0;
			int num8 = 0;
			int num9 = 0;
			int num10 = 0;
			int num11 = 0;
			int num12 = 0;
			for (int i = 0; i < 2 * numvertices; i += 2)
			{
				int num13 = ((i + 2 >= 2 * numvertices) ? 0 : (i + 2));
				this.LineLineSegmentIntersection(x1, y1, x2, y2, convexPoly[i], convexPoly[i + 1], convexPoly[num13], convexPoly[num13 + 1], ref array);
				if (Math.Abs(array[0] - 0.0) <= num4)
				{
					if (num == 1)
					{
						num3++;
						this.poly2[2 * num3 - 1] = convexPoly[num13];
						this.poly2[2 * num3] = convexPoly[num13 + 1];
					}
					else
					{
						num2++;
						this.poly1[2 * num2 - 1] = convexPoly[num13];
						this.poly1[2 * num2] = convexPoly[num13 + 1];
					}
					num5++;
				}
				else if (Math.Abs(array[0] - 2.0) <= num4)
				{
					num2++;
					this.poly1[2 * num2 - 1] = convexPoly[num13];
					this.poly1[2 * num2] = convexPoly[num13 + 1];
					num6++;
				}
				else
				{
					num7++;
					if (Math.Abs(array[1] - convexPoly[num13]) <= num4 && Math.Abs(array[2] - convexPoly[num13 + 1]) <= num4)
					{
						num8++;
						if (num == 1)
						{
							num3++;
							this.poly2[2 * num3 - 1] = convexPoly[num13];
							this.poly2[2 * num3] = convexPoly[num13 + 1];
							num2++;
							this.poly1[2 * num2 - 1] = convexPoly[num13];
							this.poly1[2 * num2] = convexPoly[num13 + 1];
							num++;
						}
						else if (num == 0)
						{
							num11++;
							num2++;
							this.poly1[2 * num2 - 1] = convexPoly[num13];
							this.poly1[2 * num2] = convexPoly[num13 + 1];
							if (i + 4 < 2 * numvertices)
							{
								int num14 = this.LinePointLocation(x1, y1, x2, y2, convexPoly[i], convexPoly[i + 1]);
								int num15 = this.LinePointLocation(x1, y1, x2, y2, convexPoly[i + 4], convexPoly[i + 5]);
								if (num14 != num15 && num14 != 0 && num15 != 0)
								{
									num12++;
									num3++;
									this.poly2[2 * num3 - 1] = convexPoly[num13];
									this.poly2[2 * num3] = convexPoly[num13 + 1];
									num++;
								}
							}
						}
					}
					else if (Math.Abs(array[1] - convexPoly[i]) > num4 || Math.Abs(array[2] - convexPoly[i + 1]) > num4)
					{
						num9++;
						num2++;
						this.poly1[2 * num2 - 1] = array[1];
						this.poly1[2 * num2] = array[2];
						num3++;
						this.poly2[2 * num3 - 1] = array[1];
						this.poly2[2 * num3] = array[2];
						if (num == 1)
						{
							num2++;
							this.poly1[2 * num2 - 1] = convexPoly[num13];
							this.poly1[2 * num2] = convexPoly[num13 + 1];
						}
						else if (num == 0)
						{
							num3++;
							this.poly2[2 * num3 - 1] = convexPoly[num13];
							this.poly2[2 * num3] = convexPoly[num13 + 1];
						}
						num++;
					}
					else
					{
						num10++;
						if (num == 1)
						{
							num3++;
							this.poly2[2 * num3 - 1] = convexPoly[num13];
							this.poly2[2 * num3] = convexPoly[num13 + 1];
						}
						else
						{
							num2++;
							this.poly1[2 * num2 - 1] = convexPoly[num13];
							this.poly1[2 * num2] = convexPoly[num13 + 1];
						}
					}
				}
			}
			int num16;
			if (num != 0 && num != 2)
			{
				num16 = 3;
			}
			else
			{
				num16 = ((num == 0) ? 1 : 2);
				this.poly1[0] = (double)num2;
				this.poly2[0] = (double)num3;
				polys[0] = this.poly1;
				if (num == 2)
				{
					polys[1] = this.poly2;
				}
			}
			return num16;
		}

		// Token: 0x0600004B RID: 75 RVA: 0x000098D0 File Offset: 0x00007AD0
		private int LinePointLocation(double x1, double y1, double x2, double y2, double x, double y)
		{
			if (Math.Atan((y2 - y1) / (x2 - x1)) * 180.0 / 3.141592653589793 == 90.0)
			{
				if (Math.Abs(x1 - x) <= 1E-11)
				{
					return 0;
				}
			}
			else if (Math.Abs(y1 + (y2 - y1) * (x - x1) / (x2 - x1) - y) <= 1E-50)
			{
				return 0;
			}
			double num = (x2 - x1) * (y - y1) - (y2 - y1) * (x - x1);
			if (Math.Abs(num - 0.0) <= 1E-11)
			{
				return 0;
			}
			if (num > 0.0)
			{
				return 1;
			}
			return 2;
		}

		// Token: 0x0600004C RID: 76 RVA: 0x00009984 File Offset: 0x00007B84
		private void LineLineSegmentIntersection(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4, ref double[] p)
		{
			double num = 1E-13;
			double num2 = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1);
			double num3 = (x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3);
			double num4 = (x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3);
			if (Math.Abs(num2 - 0.0) < num)
			{
				if (Math.Abs(num4 - 0.0) < num && Math.Abs(num3 - 0.0) < num)
				{
					p[0] = 2.0;
					return;
				}
				p[0] = 0.0;
				return;
			}
			else
			{
				num4 /= num2;
				num3 /= num2;
				if (num4 < -num || num4 > 1.0 + num)
				{
					p[0] = 0.0;
					return;
				}
				p[0] = 1.0;
				p[1] = x1 + num3 * (x2 - x1);
				p[2] = y1 + num3 * (y2 - y1);
				return;
			}
		}

		// Token: 0x0600004D RID: 77 RVA: 0x00009A84 File Offset: 0x00007C84
		private void FindPolyCentroid(int numpoints, double[] points, ref double[] centroid)
		{
			centroid[0] = 0.0;
			centroid[1] = 0.0;
			for (int i = 0; i < 2 * numpoints; i += 2)
			{
				centroid[0] = centroid[0] + points[i];
				centroid[1] = centroid[1] + points[i + 1];
			}
			centroid[0] = centroid[0] / (double)numpoints;
			centroid[1] = centroid[1] / (double)numpoints;
		}

		// Token: 0x0600004E RID: 78 RVA: 0x00009AEC File Offset: 0x00007CEC
		private void CircleLineIntersection(double x1, double y1, double x2, double y2, double x3, double y3, double r, ref double[] p)
		{
			double num = (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1);
			double num2 = 2.0 * ((x2 - x1) * (x1 - x3) + (y2 - y1) * (y1 - y3));
			double num3 = x3 * x3 + y3 * y3 + x1 * x1 + y1 * y1 - 2.0 * (x3 * x1 + y3 * y1) - r * r;
			double num4 = num2 * num2 - 4.0 * num * num3;
			if (num4 < 0.0)
			{
				p[0] = 0.0;
				return;
			}
			if (Math.Abs(num4 - 0.0) < 1E-50)
			{
				p[0] = 1.0;
				double num5 = -num2 / (2.0 * num);
				p[1] = x1 + num5 * (x2 - x1);
				p[2] = y1 + num5 * (y2 - y1);
				return;
			}
			if (num4 > 0.0 && Math.Abs(num - 0.0) >= 1E-50)
			{
				p[0] = 2.0;
				double num5 = (-num2 + Math.Sqrt(num4)) / (2.0 * num);
				p[1] = x1 + num5 * (x2 - x1);
				p[2] = y1 + num5 * (y2 - y1);
				num5 = (-num2 - Math.Sqrt(num4)) / (2.0 * num);
				p[3] = x1 + num5 * (x2 - x1);
				p[4] = y1 + num5 * (y2 - y1);
				return;
			}
			p[0] = 0.0;
		}

		// Token: 0x0600004F RID: 79 RVA: 0x00009C80 File Offset: 0x00007E80
		private bool ChooseCorrectPoint(double x1, double y1, double x2, double y2, double x3, double y3, bool isObtuse)
		{
			double num = (x2 - x3) * (x2 - x3) + (y2 - y3) * (y2 - y3);
			double num2 = (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1);
			bool flag;
			if (isObtuse)
			{
				flag = num2 >= num;
			}
			else
			{
				flag = num2 < num;
			}
			return flag;
		}

		// Token: 0x06000050 RID: 80 RVA: 0x00009CD0 File Offset: 0x00007ED0
		private void PointBetweenPoints(double x1, double y1, double x2, double y2, double x, double y, ref double[] p)
		{
			if ((x2 - x) * (x2 - x) + (y2 - y) * (y2 - y) < (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1))
			{
				p[0] = 1.0;
				p[1] = (x - x2) * (x - x2) + (y - y2) * (y - y2);
				p[2] = x;
				p[3] = y;
				return;
			}
			p[0] = 0.0;
			p[1] = 0.0;
			p[2] = 0.0;
			p[3] = 0.0;
		}

		// Token: 0x06000051 RID: 81 RVA: 0x00009D74 File Offset: 0x00007F74
		private bool IsBadTriangleAngle(double x1, double y1, double x2, double y2, double x3, double y3)
		{
			double num = x1 - x2;
			double num2 = y1 - y2;
			double num3 = x2 - x3;
			double num4 = y2 - y3;
			double num5 = x3 - x1;
			double num6 = y3 - y1;
			double num7 = num * num;
			double num8 = num2 * num2;
			double num9 = num3 * num3;
			double num10 = num4 * num4;
			double num11 = num5 * num5;
			double num12 = num6 * num6;
			double num13 = num7 + num8;
			double num14 = num9 + num10;
			double num15 = num11 + num12;
			double num16;
			if (num13 < num14 && num13 < num15)
			{
				num16 = num3 * num5 + num4 * num6;
				num16 = num16 * num16 / (num14 * num15);
			}
			else if (num14 < num15)
			{
				num16 = num * num5 + num2 * num6;
				num16 = num16 * num16 / (num13 * num15);
			}
			else
			{
				num16 = num * num3 + num2 * num4;
				num16 = num16 * num16 / (num13 * num14);
			}
			double num17;
			if (num13 > num14 && num13 > num15)
			{
				num17 = (num14 + num15 - num13) / (2.0 * Math.Sqrt(num14 * num15));
			}
			else if (num14 > num15)
			{
				num17 = (num13 + num15 - num14) / (2.0 * Math.Sqrt(num13 * num15));
			}
			else
			{
				num17 = (num13 + num14 - num15) / (2.0 * Math.Sqrt(num13 * num14));
			}
			return num16 > this.behavior.goodAngle || (this.behavior.MaxAngle != 0.0 && num17 < this.behavior.maxGoodAngle);
		}

		// Token: 0x06000052 RID: 82 RVA: 0x00009EDC File Offset: 0x000080DC
		private double MinDistanceToNeighbor(double newlocX, double newlocY, ref Otri searchtri)
		{
			Otri otri = default(Otri);
			LocateResult locateResult = LocateResult.Outside;
			Point point = new Point(newlocX, newlocY);
			Vertex vertex = searchtri.Org();
			Vertex vertex2 = searchtri.Dest();
			if (vertex.x == point.x && vertex.y == point.y)
			{
				locateResult = LocateResult.OnVertex;
				searchtri.Copy(ref otri);
			}
			else if (vertex2.x == point.x && vertex2.y == point.y)
			{
				searchtri.LnextSelf();
				locateResult = LocateResult.OnVertex;
				searchtri.Copy(ref otri);
			}
			else
			{
				double num = Primitives.CounterClockwise(vertex, vertex2, point);
				if (num < 0.0)
				{
					searchtri.SymSelf();
					searchtri.Copy(ref otri);
					locateResult = this.mesh.locator.PreciseLocate(point, ref otri, false);
				}
				else if (num == 0.0)
				{
					if (vertex.x < point.x == point.x < vertex2.x && vertex.y < point.y == point.y < vertex2.y)
					{
						locateResult = LocateResult.OnEdge;
						searchtri.Copy(ref otri);
					}
				}
				else
				{
					searchtri.Copy(ref otri);
					locateResult = this.mesh.locator.PreciseLocate(point, ref otri, false);
				}
			}
			if (locateResult == LocateResult.OnVertex || locateResult == LocateResult.Outside)
			{
				return 0.0;
			}
			Vertex vertex3 = otri.Org();
			Vertex vertex4 = otri.Dest();
			Vertex vertex5 = otri.Apex();
			double num2 = (vertex3.x - point.x) * (vertex3.x - point.x) + (vertex3.y - point.y) * (vertex3.y - point.y);
			double num3 = (vertex4.x - point.x) * (vertex4.x - point.x) + (vertex4.y - point.y) * (vertex4.y - point.y);
			double num4 = (vertex5.x - point.x) * (vertex5.x - point.x) + (vertex5.y - point.y) * (vertex5.y - point.y);
			if (num2 <= num3 && num2 <= num4)
			{
				return num2;
			}
			if (num3 <= num4)
			{
				return num3;
			}
			return num4;
		}

		// Token: 0x04000023 RID: 35
		private const double EPS = 1E-50;

		// Token: 0x04000024 RID: 36
		private Mesh mesh;

		// Token: 0x04000025 RID: 37
		private Behavior behavior;

		// Token: 0x04000026 RID: 38
		private double[] petalx = new double[20];

		// Token: 0x04000027 RID: 39
		private double[] petaly = new double[20];

		// Token: 0x04000028 RID: 40
		private double[] petalr = new double[20];

		// Token: 0x04000029 RID: 41
		private double[] wedges = new double[500];

		// Token: 0x0400002A RID: 42
		private double[] initialConvexPoly = new double[500];

		// Token: 0x0400002B RID: 43
		private double[] points_p = new double[500];

		// Token: 0x0400002C RID: 44
		private double[] points_q = new double[500];

		// Token: 0x0400002D RID: 45
		private double[] points_r = new double[500];

		// Token: 0x0400002E RID: 46
		private double[] poly1 = new double[100];

		// Token: 0x0400002F RID: 47
		private double[] poly2 = new double[100];

		// Token: 0x04000030 RID: 48
		private double[][] polys = new double[3][];
	}
}