niko
339 lines
9.6 KiB
C#
339 lines
9.6 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
|
|
namespace Poly2Tri
|
|
{
|
|
// Token: 0x02000006 RID: 6
|
|
public class DelaunayTriangle
|
|
{
|
|
// Token: 0x17000008 RID: 8
|
|
// (get) Token: 0x06000026 RID: 38 RVA: 0x000025DD File Offset: 0x000007DD
|
|
// (set) Token: 0x06000027 RID: 39 RVA: 0x000025E5 File Offset: 0x000007E5
|
|
public bool IsInterior { get; set; }
|
|
|
|
// Token: 0x06000028 RID: 40 RVA: 0x000025EE File Offset: 0x000007EE
|
|
public DelaunayTriangle(TriangulationPoint p1, TriangulationPoint p2, TriangulationPoint p3)
|
|
{
|
|
this.Points[0] = p1;
|
|
this.Points[1] = p2;
|
|
this.Points[2] = p3;
|
|
}
|
|
|
|
// Token: 0x06000029 RID: 41 RVA: 0x0000261D File Offset: 0x0000081D
|
|
public int IndexOf(TriangulationPoint p)
|
|
{
|
|
int num = this.Points.IndexOf(p);
|
|
if (num == -1)
|
|
{
|
|
throw new Exception("Calling index with a point that doesn't exist in triangle");
|
|
}
|
|
return num;
|
|
}
|
|
|
|
// Token: 0x0600002A RID: 42 RVA: 0x0000263A File Offset: 0x0000083A
|
|
public int IndexCWFrom(TriangulationPoint p)
|
|
{
|
|
return (this.IndexOf(p) + 2) % 3;
|
|
}
|
|
|
|
// Token: 0x0600002B RID: 43 RVA: 0x00002647 File Offset: 0x00000847
|
|
public int IndexCCWFrom(TriangulationPoint p)
|
|
{
|
|
return (this.IndexOf(p) + 1) % 3;
|
|
}
|
|
|
|
// Token: 0x0600002C RID: 44 RVA: 0x00002654 File Offset: 0x00000854
|
|
public bool Contains(TriangulationPoint p)
|
|
{
|
|
return this.Points.Contains(p);
|
|
}
|
|
|
|
// Token: 0x0600002D RID: 45 RVA: 0x00002664 File Offset: 0x00000864
|
|
private void MarkNeighbor(TriangulationPoint p1, TriangulationPoint p2, DelaunayTriangle t)
|
|
{
|
|
int num = this.EdgeIndex(p1, p2);
|
|
if (num == -1)
|
|
{
|
|
throw new Exception("Error marking neighbors -- t doesn't contain edge p1-p2!");
|
|
}
|
|
this.Neighbors[num] = t;
|
|
}
|
|
|
|
// Token: 0x0600002E RID: 46 RVA: 0x00002698 File Offset: 0x00000898
|
|
public void MarkNeighbor(DelaunayTriangle t)
|
|
{
|
|
bool flag = t.Contains(this.Points[0]);
|
|
bool flag2 = t.Contains(this.Points[1]);
|
|
bool flag3 = t.Contains(this.Points[2]);
|
|
if (flag2 && flag3)
|
|
{
|
|
this.Neighbors[0] = t;
|
|
t.MarkNeighbor(this.Points[1], this.Points[2], this);
|
|
return;
|
|
}
|
|
if (flag && flag3)
|
|
{
|
|
this.Neighbors[1] = t;
|
|
t.MarkNeighbor(this.Points[0], this.Points[2], this);
|
|
return;
|
|
}
|
|
if (flag && flag2)
|
|
{
|
|
this.Neighbors[2] = t;
|
|
t.MarkNeighbor(this.Points[0], this.Points[1], this);
|
|
return;
|
|
}
|
|
throw new Exception("Failed to mark neighbor, doesn't share an edge!");
|
|
}
|
|
|
|
// Token: 0x0600002F RID: 47 RVA: 0x0000277E File Offset: 0x0000097E
|
|
public TriangulationPoint OppositePoint(DelaunayTriangle t, TriangulationPoint p)
|
|
{
|
|
return this.PointCWFrom(t.PointCWFrom(p));
|
|
}
|
|
|
|
// Token: 0x06000030 RID: 48 RVA: 0x0000278D File Offset: 0x0000098D
|
|
public DelaunayTriangle NeighborCWFrom(TriangulationPoint point)
|
|
{
|
|
return this.Neighbors[(this.Points.IndexOf(point) + 1) % 3];
|
|
}
|
|
|
|
// Token: 0x06000031 RID: 49 RVA: 0x000027AA File Offset: 0x000009AA
|
|
public DelaunayTriangle NeighborCCWFrom(TriangulationPoint point)
|
|
{
|
|
return this.Neighbors[(this.Points.IndexOf(point) + 2) % 3];
|
|
}
|
|
|
|
// Token: 0x06000032 RID: 50 RVA: 0x000027C7 File Offset: 0x000009C7
|
|
public DelaunayTriangle NeighborAcrossFrom(TriangulationPoint point)
|
|
{
|
|
return this.Neighbors[this.Points.IndexOf(point)];
|
|
}
|
|
|
|
// Token: 0x06000033 RID: 51 RVA: 0x000027E0 File Offset: 0x000009E0
|
|
public TriangulationPoint PointCCWFrom(TriangulationPoint point)
|
|
{
|
|
return this.Points[(this.IndexOf(point) + 1) % 3];
|
|
}
|
|
|
|
// Token: 0x06000034 RID: 52 RVA: 0x000027F8 File Offset: 0x000009F8
|
|
public TriangulationPoint PointCWFrom(TriangulationPoint point)
|
|
{
|
|
return this.Points[(this.IndexOf(point) + 2) % 3];
|
|
}
|
|
|
|
// Token: 0x06000035 RID: 53 RVA: 0x00002810 File Offset: 0x00000A10
|
|
private void RotateCW()
|
|
{
|
|
TriangulationPoint triangulationPoint = this.Points[2];
|
|
this.Points[2] = this.Points[1];
|
|
this.Points[1] = this.Points[0];
|
|
this.Points[0] = triangulationPoint;
|
|
}
|
|
|
|
// Token: 0x06000036 RID: 54 RVA: 0x00002867 File Offset: 0x00000A67
|
|
public void Legalize(TriangulationPoint oPoint, TriangulationPoint nPoint)
|
|
{
|
|
this.RotateCW();
|
|
this.Points[this.IndexCCWFrom(oPoint)] = nPoint;
|
|
}
|
|
|
|
// Token: 0x06000037 RID: 55 RVA: 0x00002884 File Offset: 0x00000A84
|
|
public override string ToString()
|
|
{
|
|
return string.Concat(new object[]
|
|
{
|
|
this.Points[0],
|
|
",",
|
|
this.Points[1],
|
|
",",
|
|
this.Points[2]
|
|
});
|
|
}
|
|
|
|
// Token: 0x06000038 RID: 56 RVA: 0x000028DC File Offset: 0x00000ADC
|
|
public void MarkNeighborEdges()
|
|
{
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
if (this.EdgeIsConstrained[i] && this.Neighbors[i] != null)
|
|
{
|
|
this.Neighbors[i].MarkConstrainedEdge(this.Points[(i + 1) % 3], this.Points[(i + 2) % 3]);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000039 RID: 57 RVA: 0x00002944 File Offset: 0x00000B44
|
|
public void MarkEdge(DelaunayTriangle triangle)
|
|
{
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
if (this.EdgeIsConstrained[i])
|
|
{
|
|
triangle.MarkConstrainedEdge(this.Points[(i + 1) % 3], this.Points[(i + 2) % 3]);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600003A RID: 58 RVA: 0x00002994 File Offset: 0x00000B94
|
|
public void MarkEdge(List<DelaunayTriangle> tList)
|
|
{
|
|
foreach (DelaunayTriangle delaunayTriangle in tList)
|
|
{
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
if (delaunayTriangle.EdgeIsConstrained[i])
|
|
{
|
|
this.MarkConstrainedEdge(delaunayTriangle.Points[(i + 1) % 3], delaunayTriangle.Points[(i + 2) % 3]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600003B RID: 59 RVA: 0x00002A1C File Offset: 0x00000C1C
|
|
public void MarkConstrainedEdge(int index)
|
|
{
|
|
this.EdgeIsConstrained[index] = true;
|
|
}
|
|
|
|
// Token: 0x0600003C RID: 60 RVA: 0x00002A2B File Offset: 0x00000C2B
|
|
public void MarkConstrainedEdge(DTSweepConstraint edge)
|
|
{
|
|
this.MarkConstrainedEdge(edge.P, edge.Q);
|
|
}
|
|
|
|
// Token: 0x0600003D RID: 61 RVA: 0x00002A40 File Offset: 0x00000C40
|
|
public void MarkConstrainedEdge(TriangulationPoint p, TriangulationPoint q)
|
|
{
|
|
int num = this.EdgeIndex(p, q);
|
|
if (num != -1)
|
|
{
|
|
this.EdgeIsConstrained[num] = true;
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600003E RID: 62 RVA: 0x00002A68 File Offset: 0x00000C68
|
|
public double Area()
|
|
{
|
|
double num = this.Points[0].X - this.Points[1].X;
|
|
double num2 = this.Points[2].Y - this.Points[1].Y;
|
|
return Math.Abs(num * num2 * 0.5);
|
|
}
|
|
|
|
// Token: 0x0600003F RID: 63 RVA: 0x00002AD0 File Offset: 0x00000CD0
|
|
public TriangulationPoint Centroid()
|
|
{
|
|
double num = (this.Points[0].X + this.Points[1].X + this.Points[2].X) / 3.0;
|
|
double num2 = (this.Points[0].Y + this.Points[1].Y + this.Points[2].Y) / 3.0;
|
|
return new TriangulationPoint(num, num2, -1);
|
|
}
|
|
|
|
// Token: 0x06000040 RID: 64 RVA: 0x00002B64 File Offset: 0x00000D64
|
|
public int EdgeIndex(TriangulationPoint p1, TriangulationPoint p2)
|
|
{
|
|
int num = this.Points.IndexOf(p1);
|
|
int num2 = this.Points.IndexOf(p2);
|
|
bool flag = num == 0 || num2 == 0;
|
|
bool flag2 = num == 1 || num2 == 1;
|
|
bool flag3 = num == 2 || num2 == 2;
|
|
if (flag2 && flag3)
|
|
{
|
|
return 0;
|
|
}
|
|
if (flag && flag3)
|
|
{
|
|
return 1;
|
|
}
|
|
if (flag && flag2)
|
|
{
|
|
return 2;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
// Token: 0x06000041 RID: 65 RVA: 0x00002BC2 File Offset: 0x00000DC2
|
|
public bool GetConstrainedEdgeCCW(TriangulationPoint p)
|
|
{
|
|
return this.EdgeIsConstrained[(this.IndexOf(p) + 2) % 3];
|
|
}
|
|
|
|
// Token: 0x06000042 RID: 66 RVA: 0x00002BDA File Offset: 0x00000DDA
|
|
public bool GetConstrainedEdgeCW(TriangulationPoint p)
|
|
{
|
|
return this.EdgeIsConstrained[(this.IndexOf(p) + 1) % 3];
|
|
}
|
|
|
|
// Token: 0x06000043 RID: 67 RVA: 0x00002BF2 File Offset: 0x00000DF2
|
|
public bool GetConstrainedEdgeAcross(TriangulationPoint p)
|
|
{
|
|
return this.EdgeIsConstrained[this.IndexOf(p)];
|
|
}
|
|
|
|
// Token: 0x06000044 RID: 68 RVA: 0x00002C06 File Offset: 0x00000E06
|
|
public void SetConstrainedEdgeCCW(TriangulationPoint p, bool ce)
|
|
{
|
|
this.EdgeIsConstrained[(this.IndexOf(p) + 2) % 3] = ce;
|
|
}
|
|
|
|
// Token: 0x06000045 RID: 69 RVA: 0x00002C1F File Offset: 0x00000E1F
|
|
public void SetConstrainedEdgeCW(TriangulationPoint p, bool ce)
|
|
{
|
|
this.EdgeIsConstrained[(this.IndexOf(p) + 1) % 3] = ce;
|
|
}
|
|
|
|
// Token: 0x06000046 RID: 70 RVA: 0x00002C38 File Offset: 0x00000E38
|
|
public void SetConstrainedEdgeAcross(TriangulationPoint p, bool ce)
|
|
{
|
|
this.EdgeIsConstrained[this.IndexOf(p)] = ce;
|
|
}
|
|
|
|
// Token: 0x06000047 RID: 71 RVA: 0x00002C4D File Offset: 0x00000E4D
|
|
public bool GetDelaunayEdgeCCW(TriangulationPoint p)
|
|
{
|
|
return this.EdgeIsDelaunay[(this.IndexOf(p) + 2) % 3];
|
|
}
|
|
|
|
// Token: 0x06000048 RID: 72 RVA: 0x00002C65 File Offset: 0x00000E65
|
|
public bool GetDelaunayEdgeCW(TriangulationPoint p)
|
|
{
|
|
return this.EdgeIsDelaunay[(this.IndexOf(p) + 1) % 3];
|
|
}
|
|
|
|
// Token: 0x06000049 RID: 73 RVA: 0x00002C7D File Offset: 0x00000E7D
|
|
public bool GetDelaunayEdgeAcross(TriangulationPoint p)
|
|
{
|
|
return this.EdgeIsDelaunay[this.IndexOf(p)];
|
|
}
|
|
|
|
// Token: 0x0600004A RID: 74 RVA: 0x00002C91 File Offset: 0x00000E91
|
|
public void SetDelaunayEdgeCCW(TriangulationPoint p, bool ce)
|
|
{
|
|
this.EdgeIsDelaunay[(this.IndexOf(p) + 2) % 3] = ce;
|
|
}
|
|
|
|
// Token: 0x0600004B RID: 75 RVA: 0x00002CAA File Offset: 0x00000EAA
|
|
public void SetDelaunayEdgeCW(TriangulationPoint p, bool ce)
|
|
{
|
|
this.EdgeIsDelaunay[(this.IndexOf(p) + 1) % 3] = ce;
|
|
}
|
|
|
|
// Token: 0x0600004C RID: 76 RVA: 0x00002CC3 File Offset: 0x00000EC3
|
|
public void SetDelaunayEdgeAcross(TriangulationPoint p, bool ce)
|
|
{
|
|
this.EdgeIsDelaunay[this.IndexOf(p)] = ce;
|
|
}
|
|
|
|
// Token: 0x0400000A RID: 10
|
|
public FixedArray3<TriangulationPoint> Points;
|
|
|
|
// Token: 0x0400000B RID: 11
|
|
public FixedArray3<DelaunayTriangle> Neighbors;
|
|
|
|
// Token: 0x0400000C RID: 12
|
|
public FixedBitArray3 EdgeIsConstrained;
|
|
|
|
// Token: 0x0400000D RID: 13
|
|
public FixedBitArray3 EdgeIsDelaunay;
|
|
}
|
|
}
|