1118 lines
36 KiB
C#
1118 lines
36 KiB
C#
|
using System;
|
|||
|
|
using System.Collections.Generic;
|
|||
|
|
using Unity.Collections;
|
|||
|
|
using Unity.Mathematics;
|
|||
|
|
using Unity.Collections.LowLevel.Unsafe;
|
|||
|
|
|
|||
|
|
namespace UnityEngine.U2D
|
|||
|
|
{
|
|||
|
|
|
|||
|
|
namespace UTess
|
|||
|
|
{
|
|||
|
|
|
|||
|
|
enum TessEventType
|
|||
|
|
{
|
|||
|
|
EVENT_POINT = 0,
|
|||
|
|
EVENT_END = 1,
|
|||
|
|
EVENT_START = 2,
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
struct TessEdge
|
|||
|
|
{
|
|||
|
|
public int a;
|
|||
|
|
public int b;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
struct TessEvent
|
|||
|
|
{
|
|||
|
|
public float2 a;
|
|||
|
|
public float2 b;
|
|||
|
|
public int idx;
|
|||
|
|
public int type;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
struct TessHull
|
|||
|
|
{
|
|||
|
|
public float2 a;
|
|||
|
|
public float2 b;
|
|||
|
|
public int idx;
|
|||
|
|
|
|||
|
|
public ArraySlice<int> ilarray;
|
|||
|
|
public int ilcount;
|
|||
|
|
public ArraySlice<int> iuarray;
|
|||
|
|
public int iucount;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
struct TessCell
|
|||
|
|
{
|
|||
|
|
public int a;
|
|||
|
|
public int b;
|
|||
|
|
public int c;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
struct TessStar
|
|||
|
|
{
|
|||
|
|
public ArraySlice<int> points;
|
|||
|
|
public int pointCount;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
internal struct TessUtils
|
|||
|
|
{
|
|||
|
|
|
|||
|
|
// From https://www.cs.cmu.edu/afs/cs/project/quake/public/code/predicates.c and is public domain. Can't find one within Unity.
|
|||
|
|
public static float OrientFast(float2 a, float2 b, float2 c)
|
|||
|
|
{
|
|||
|
|
float epsilon = 1.1102230246251565e-16f;
|
|||
|
|
float errbound3 = (3.0f + 16.0f * epsilon) * epsilon;
|
|||
|
|
float l = (a.y - c.y) * (b.x - c.x);
|
|||
|
|
float r = (a.x - c.x) * (b.y - c.y);
|
|||
|
|
float det = l - r;
|
|||
|
|
float s = 0;
|
|||
|
|
if (l > 0)
|
|||
|
|
{
|
|||
|
|
if (r <= 0)
|
|||
|
|
{
|
|||
|
|
return det;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
s = l + r;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else if (l < 0)
|
|||
|
|
{
|
|||
|
|
if (r >= 0)
|
|||
|
|
{
|
|||
|
|
return det;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
s = -(l + r);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
return det;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
float tol = errbound3 * s;
|
|||
|
|
if (det >= tol || det <= -tol)
|
|||
|
|
{
|
|||
|
|
return det;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return epsilon;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public static float Norm(float2 cV)
|
|||
|
|
{
|
|||
|
|
return cV.x * cV.x + cV.y * cV.y;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public static float Dist(float2 cV1, float2 cV2)
|
|||
|
|
{
|
|||
|
|
return (cV1.x - cV2.x) * (cV1.x - cV2.x) + (cV1.y - cV2.y) * (cV1.y - cV2.y);
|
|||
|
|
}
|
|||
|
|
public static bool IsInsideCircle(float2 a, float2 b, float2 c, float2 p)
|
|||
|
|
{
|
|||
|
|
float ab = Norm(a);
|
|||
|
|
float cd = Norm(b);
|
|||
|
|
float ef = Norm(c);
|
|||
|
|
|
|||
|
|
float ax = a.x;
|
|||
|
|
float ay = a.y;
|
|||
|
|
float bx = b.x;
|
|||
|
|
float by = b.y;
|
|||
|
|
float cx = c.x;
|
|||
|
|
float cy = c.y;
|
|||
|
|
|
|||
|
|
float circum_x = (ab * (cy - by) + cd * (ay - cy) + ef * (by - ay)) /
|
|||
|
|
(ax * (cy - by) + bx * (ay - cy) + cx * (by - ay));
|
|||
|
|
float circum_y = (ab * (cx - bx) + cd * (ax - cx) + ef * (bx - ax)) /
|
|||
|
|
(ay * (cx - bx) + by * (ax - cx) + cy * (bx - ax));
|
|||
|
|
|
|||
|
|
float2 circum = new float2();
|
|||
|
|
circum.x = circum_x / 2;
|
|||
|
|
circum.y = circum_y / 2;
|
|||
|
|
float circum_radius = Dist(a, circum);
|
|||
|
|
float dist = Dist(p, circum);
|
|||
|
|
return circum_radius - dist > 0.00001f;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public unsafe static void InsertionSort<T, U>(void* array, int lo, int hi, U comp)
|
|||
|
|
where T : struct where U : IComparer<T>
|
|||
|
|
{
|
|||
|
|
int i, j;
|
|||
|
|
T t;
|
|||
|
|
for (i = lo; i < hi; i++)
|
|||
|
|
{
|
|||
|
|
j = i;
|
|||
|
|
t = UnsafeUtility.ReadArrayElement<T>(array, i + 1);
|
|||
|
|
while (j >= lo && comp.Compare(t, UnsafeUtility.ReadArrayElement<T>(array, j)) < 0)
|
|||
|
|
{
|
|||
|
|
UnsafeUtility.WriteArrayElement<T>(array, j + 1, UnsafeUtility.ReadArrayElement<T>(array, j));
|
|||
|
|
j--;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
UnsafeUtility.WriteArrayElement<T>(array, j + 1, t);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
struct TessEventCompare : IComparer<TessEvent>
|
|||
|
|
{
|
|||
|
|
public int Compare(TessEvent a, TessEvent b)
|
|||
|
|
{
|
|||
|
|
float f = (a.a.x - b.a.x);
|
|||
|
|
if (0 != f)
|
|||
|
|
return (f > 0) ? 1 : -1;
|
|||
|
|
|
|||
|
|
f = (a.a.y - b.a.y);
|
|||
|
|
if (0 != f)
|
|||
|
|
return (f > 0) ? 1 : -1;
|
|||
|
|
|
|||
|
|
int i = a.type - b.type;
|
|||
|
|
if (0 != i)
|
|||
|
|
return i;
|
|||
|
|
|
|||
|
|
if (a.type != (int) TessEventType.EVENT_POINT)
|
|||
|
|
{
|
|||
|
|
float o = TessUtils.OrientFast(a.a, a.b, b.b);
|
|||
|
|
if (0 != o)
|
|||
|
|
{
|
|||
|
|
return (o > 0) ? 1 : -1;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return a.idx - b.idx;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
struct TessEdgeCompare : IComparer<TessEdge>
|
|||
|
|
{
|
|||
|
|
public int Compare(TessEdge a, TessEdge b)
|
|||
|
|
{
|
|||
|
|
int i = a.a - b.a;
|
|||
|
|
if (0 != i)
|
|||
|
|
return i;
|
|||
|
|
i = a.b - b.b;
|
|||
|
|
return i;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
struct TessCellCompare : IComparer<TessCell>
|
|||
|
|
{
|
|||
|
|
public int Compare(TessCell a, TessCell b)
|
|||
|
|
{
|
|||
|
|
int i = a.a - b.a;
|
|||
|
|
if (0 != i)
|
|||
|
|
return i;
|
|||
|
|
i = a.b - b.b;
|
|||
|
|
if (0 != i)
|
|||
|
|
return i;
|
|||
|
|
i = a.c - b.c;
|
|||
|
|
return i;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
internal struct Tessellator
|
|||
|
|
{
|
|||
|
|
// For Processing.
|
|||
|
|
NativeArray<TessEdge> m_Edges;
|
|||
|
|
NativeArray<TessStar> m_Stars;
|
|||
|
|
NativeArray<TessCell> m_Cells;
|
|||
|
|
int m_CellCount;
|
|||
|
|
|
|||
|
|
// For Storage.
|
|||
|
|
NativeArray<int> m_ILArray;
|
|||
|
|
NativeArray<int> m_IUArray;
|
|||
|
|
NativeArray<int> m_SPArray;
|
|||
|
|
int m_NumPoints;
|
|||
|
|
int m_StarCount;
|
|||
|
|
|
|||
|
|
// Intermediates.
|
|||
|
|
NativeArray<int> m_Flags;
|
|||
|
|
NativeArray<int> m_Neighbors;
|
|||
|
|
NativeArray<int> m_Constraints;
|
|||
|
|
|
|||
|
|
static float TestPoint(TessHull hull, float2 point)
|
|||
|
|
{
|
|||
|
|
return TessUtils.OrientFast(hull.a, hull.b, point);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static int GetLowerHullForVector(NativeArray<TessHull> hulls, int hullCount, float2 p)
|
|||
|
|
{
|
|||
|
|
int i;
|
|||
|
|
int l = 0;
|
|||
|
|
int h = hullCount - 1;
|
|||
|
|
i = l - 1;
|
|||
|
|
while (l <= h)
|
|||
|
|
{
|
|||
|
|
int m;
|
|||
|
|
m = ((int) (l + h)) >> 1;
|
|||
|
|
if (TestPoint(hulls[m], p) < 0)
|
|||
|
|
{
|
|||
|
|
i = m;
|
|||
|
|
l = m + 1;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
h = m - 1;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return i;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static int GetUpperHullForVector(NativeArray<TessHull> hulls, int hullCount, float2 p)
|
|||
|
|
{
|
|||
|
|
int i;
|
|||
|
|
int l = 0;
|
|||
|
|
int h = hullCount - 1;
|
|||
|
|
i = h + 1;
|
|||
|
|
while (l <= h)
|
|||
|
|
{
|
|||
|
|
int m;
|
|||
|
|
m = ((int) (l + h)) >> 1;
|
|||
|
|
if (TestPoint(hulls[m], p) > 0)
|
|||
|
|
{
|
|||
|
|
i = m;
|
|||
|
|
h = m - 1;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
l = m + 1;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return i;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static float FindSplit(TessHull hull, TessEvent edge)
|
|||
|
|
{
|
|||
|
|
float d = 0;
|
|||
|
|
if (hull.a.x < edge.a.x)
|
|||
|
|
{
|
|||
|
|
d = TessUtils.OrientFast(hull.a, hull.b, edge.a);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
d = TessUtils.OrientFast(edge.b, edge.a, hull.a);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (0 != d)
|
|||
|
|
{
|
|||
|
|
return d;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (edge.b.x < hull.b.x)
|
|||
|
|
{
|
|||
|
|
d = TessUtils.OrientFast(hull.a, hull.b, edge.b);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
d = TessUtils.OrientFast(edge.b, edge.a, hull.b);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (0 != d)
|
|||
|
|
{
|
|||
|
|
return d;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return hull.idx - edge.idx;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static int GetLowerEqualHullForEvent(NativeArray<TessHull> hulls, int hullCount, TessEvent p)
|
|||
|
|
{
|
|||
|
|
int i;
|
|||
|
|
int l = 0;
|
|||
|
|
int h = hullCount - 1;
|
|||
|
|
i = l - 1;
|
|||
|
|
while (l <= h)
|
|||
|
|
{
|
|||
|
|
int m;
|
|||
|
|
m = ((int) (l + h)) >> 1;
|
|||
|
|
if (FindSplit(hulls[m], p) <= 0)
|
|||
|
|
{
|
|||
|
|
i = m;
|
|||
|
|
l = m + 1;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
h = m - 1;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return i;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static int GetEqualHullForEvent(NativeArray<TessHull> hulls, int hullCount, TessEvent p)
|
|||
|
|
{
|
|||
|
|
int l = 0;
|
|||
|
|
int h = hullCount - 1;
|
|||
|
|
while (l <= h)
|
|||
|
|
{
|
|||
|
|
int m;
|
|||
|
|
m = ((int) (l + h)) >> 1;
|
|||
|
|
float f = FindSplit(hulls[m], p);
|
|||
|
|
if (f == 0)
|
|||
|
|
{
|
|||
|
|
return m;
|
|||
|
|
}
|
|||
|
|
else if (f <= 0)
|
|||
|
|
{
|
|||
|
|
l = m + 1;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
h = m - 1;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void AddPoint(NativeArray<TessHull> hulls, int hullCount, NativeArray<float2> points, float2 p,
|
|||
|
|
int idx)
|
|||
|
|
{
|
|||
|
|
int l = GetLowerHullForVector(hulls, hullCount, p);
|
|||
|
|
int u = GetUpperHullForVector(hulls, hullCount, p);
|
|||
|
|
for (int i = l; i < u; ++i)
|
|||
|
|
{
|
|||
|
|
TessHull hull = hulls[i];
|
|||
|
|
|
|||
|
|
int m = hull.ilcount;
|
|||
|
|
while (m > 1 && TessUtils.OrientFast(points[hull.ilarray[m - 2]], points[hull.ilarray[m - 1]], p) >
|
|||
|
|
0)
|
|||
|
|
{
|
|||
|
|
TessCell c = new TessCell();
|
|||
|
|
c.a = hull.ilarray[m - 1];
|
|||
|
|
c.b = hull.ilarray[m - 2];
|
|||
|
|
c.c = idx;
|
|||
|
|
m_Cells[m_CellCount++] = c;
|
|||
|
|
m -= 1;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
hull.ilcount = m + 1;
|
|||
|
|
hull.ilarray[m] = idx;
|
|||
|
|
|
|||
|
|
m = hull.iucount;
|
|||
|
|
while (m > 1 && TessUtils.OrientFast(points[hull.iuarray[m - 2]], points[hull.iuarray[m - 1]], p) <
|
|||
|
|
0)
|
|||
|
|
{
|
|||
|
|
TessCell c = new TessCell();
|
|||
|
|
c.a = hull.iuarray[m - 2];
|
|||
|
|
c.b = hull.iuarray[m - 1];
|
|||
|
|
c.c = idx;
|
|||
|
|
m_Cells[m_CellCount++] = c;
|
|||
|
|
m -= 1;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
hull.iucount = m + 1;
|
|||
|
|
hull.iuarray[m] = idx;
|
|||
|
|
|
|||
|
|
hulls[i] = hull;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static void InsertHull(NativeArray<TessHull> Hulls, int Pos, ref int Count, TessHull Value)
|
|||
|
|
{
|
|||
|
|
if (Count < Hulls.Length - 1)
|
|||
|
|
{
|
|||
|
|
for (int i = Count; i > Pos; --i)
|
|||
|
|
Hulls[i] = Hulls[i - 1];
|
|||
|
|
Hulls[Pos] = Value;
|
|||
|
|
Count++;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static void EraseHull(NativeArray<TessHull> Hulls, int Pos, ref int Count)
|
|||
|
|
{
|
|||
|
|
if (Count < Hulls.Length)
|
|||
|
|
{
|
|||
|
|
for (int i = Pos; i < Count - 1; ++i)
|
|||
|
|
Hulls[i] = Hulls[i + 1];
|
|||
|
|
Count--;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void SplitHulls(NativeArray<TessHull> hulls, ref int hullCount, NativeArray<float2> points,
|
|||
|
|
TessEvent evt)
|
|||
|
|
{
|
|||
|
|
int index = GetLowerEqualHullForEvent(hulls, hullCount, evt);
|
|||
|
|
TessHull hull = hulls[index];
|
|||
|
|
|
|||
|
|
TessHull newHull;
|
|||
|
|
newHull.a = evt.a;
|
|||
|
|
newHull.b = evt.b;
|
|||
|
|
newHull.idx = evt.idx;
|
|||
|
|
|
|||
|
|
int y = hull.iuarray[hull.iucount - 1];
|
|||
|
|
newHull.iuarray = new ArraySlice<int>(m_IUArray, newHull.idx * m_NumPoints, m_NumPoints);
|
|||
|
|
newHull.iucount = hull.iucount;
|
|||
|
|
for (int i = 0; i < newHull.iucount; ++i)
|
|||
|
|
newHull.iuarray[i] = hull.iuarray[i];
|
|||
|
|
hull.iuarray[0] = y;
|
|||
|
|
hull.iucount = 1;
|
|||
|
|
hulls[index] = hull;
|
|||
|
|
|
|||
|
|
newHull.ilarray = new ArraySlice<int>(m_ILArray, newHull.idx * m_NumPoints, m_NumPoints);
|
|||
|
|
newHull.ilarray[0] = y;
|
|||
|
|
newHull.ilcount = 1;
|
|||
|
|
|
|||
|
|
InsertHull(hulls, index + 1, ref hullCount, newHull);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void MergeHulls(NativeArray<TessHull> hulls, ref int hullCount, NativeArray<float2> points,
|
|||
|
|
TessEvent evt)
|
|||
|
|
{
|
|||
|
|
float2 temp = evt.a;
|
|||
|
|
evt.a = evt.b;
|
|||
|
|
evt.b = temp;
|
|||
|
|
int index = GetEqualHullForEvent(hulls, hullCount, evt);
|
|||
|
|
|
|||
|
|
TessHull upper = hulls[index];
|
|||
|
|
TessHull lower = hulls[index - 1];
|
|||
|
|
|
|||
|
|
lower.iucount = upper.iucount;
|
|||
|
|
for (int i = 0; i < lower.iucount; ++i)
|
|||
|
|
lower.iuarray[i] = upper.iuarray[i];
|
|||
|
|
|
|||
|
|
hulls[index - 1] = lower;
|
|||
|
|
EraseHull(hulls, index, ref hullCount);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
internal void Triangulate(NativeArray<float2> points, NativeArray<TessEdge> edgesIn)
|
|||
|
|
{
|
|||
|
|
int numEdges = edgesIn.Length;
|
|||
|
|
const int kStarEdges = 16;
|
|||
|
|
|
|||
|
|
m_NumPoints = points.Length;
|
|||
|
|
m_StarCount = m_NumPoints > kStarEdges ? m_NumPoints : kStarEdges;
|
|||
|
|
m_StarCount = m_StarCount * 2;
|
|||
|
|
m_CellCount = 0;
|
|||
|
|
m_Cells = new NativeArray<TessCell>(m_NumPoints * (m_NumPoints + 1), Allocator.Temp);
|
|||
|
|
m_ILArray = new NativeArray<int>(m_NumPoints * (m_NumPoints + 1), Allocator.Temp); // Make room for -1 node.
|
|||
|
|
m_IUArray = new NativeArray<int>(m_NumPoints * (m_NumPoints + 1), Allocator.Temp); // Make room for -1 node.
|
|||
|
|
m_SPArray = new NativeArray<int>(m_NumPoints * (m_StarCount), Allocator.Temp); // Make room for -1 node.
|
|||
|
|
|
|||
|
|
NativeArray<TessHull> hulls = new NativeArray<TessHull>(m_NumPoints * 8, Allocator.Temp);
|
|||
|
|
int hullCount = 0;
|
|||
|
|
|
|||
|
|
NativeArray<TessEvent> events = new NativeArray<TessEvent>(m_NumPoints + (numEdges * 2), Allocator.Temp);
|
|||
|
|
int eventCount = 0;
|
|||
|
|
|
|||
|
|
for (int i = 0; i < m_NumPoints; ++i)
|
|||
|
|
{
|
|||
|
|
TessEvent evt = new TessEvent();
|
|||
|
|
evt.a = points[i];
|
|||
|
|
evt.b = new float2();
|
|||
|
|
evt.idx = i;
|
|||
|
|
evt.type = (int) TessEventType.EVENT_POINT;
|
|||
|
|
events[eventCount++] = evt;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
for (int i = 0; i < numEdges; ++i)
|
|||
|
|
{
|
|||
|
|
TessEdge e = edgesIn[i];
|
|||
|
|
float2 a = points[e.a];
|
|||
|
|
float2 b = points[e.b];
|
|||
|
|
if (a.x < b.x)
|
|||
|
|
{
|
|||
|
|
TessEvent _s = new TessEvent();
|
|||
|
|
_s.a = a;
|
|||
|
|
_s.b = b;
|
|||
|
|
_s.idx = i;
|
|||
|
|
_s.type = (int) TessEventType.EVENT_START;
|
|||
|
|
|
|||
|
|
TessEvent _e = new TessEvent();
|
|||
|
|
_e.a = b;
|
|||
|
|
_e.b = a;
|
|||
|
|
_e.idx = i;
|
|||
|
|
_e.type = (int) TessEventType.EVENT_END;
|
|||
|
|
|
|||
|
|
events[eventCount++] = _s;
|
|||
|
|
events[eventCount++] = _e;
|
|||
|
|
}
|
|||
|
|
else if (a.x > b.x)
|
|||
|
|
{
|
|||
|
|
TessEvent _s = new TessEvent();
|
|||
|
|
_s.a = b;
|
|||
|
|
_s.b = a;
|
|||
|
|
_s.idx = i;
|
|||
|
|
_s.type = (int) TessEventType.EVENT_START;
|
|||
|
|
|
|||
|
|
TessEvent _e = new TessEvent();
|
|||
|
|
_e.a = a;
|
|||
|
|
_e.b = b;
|
|||
|
|
_e.idx = i;
|
|||
|
|
_e.type = (int) TessEventType.EVENT_END;
|
|||
|
|
|
|||
|
|
events[eventCount++] = _s;
|
|||
|
|
events[eventCount++] = _e;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
unsafe
|
|||
|
|
{
|
|||
|
|
TessUtils.InsertionSort<TessEvent, TessEventCompare>(
|
|||
|
|
NativeArrayUnsafeUtility.GetUnsafeBufferPointerWithoutChecks(events), 0, eventCount - 1,
|
|||
|
|
new TessEventCompare());
|
|||
|
|
;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
float minX = events[0].a.x - (1 + math.abs(events[0].a.x)) * math.pow(2.0f, -16.0f);
|
|||
|
|
TessHull hull;
|
|||
|
|
hull.a.x = minX;
|
|||
|
|
hull.a.y = 1;
|
|||
|
|
hull.b.x = minX;
|
|||
|
|
hull.b.y = 0;
|
|||
|
|
hull.idx = -1;
|
|||
|
|
hull.ilarray = new ArraySlice<int>(m_ILArray, m_NumPoints * m_NumPoints, m_NumPoints); // Last element
|
|||
|
|
hull.iuarray = new ArraySlice<int>(m_IUArray, m_NumPoints * m_NumPoints, m_NumPoints);
|
|||
|
|
hull.ilcount = 0;
|
|||
|
|
hull.iucount = 0;
|
|||
|
|
hulls[hullCount++] = hull;
|
|||
|
|
|
|||
|
|
for (int i = 0, numEvents = eventCount; i < numEvents; ++i)
|
|||
|
|
{
|
|||
|
|
switch (events[i].type)
|
|||
|
|
{
|
|||
|
|
case (int) TessEventType.EVENT_POINT:
|
|||
|
|
{
|
|||
|
|
AddPoint(hulls, hullCount, points, events[i].a, events[i].idx);
|
|||
|
|
}
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
case (int) TessEventType.EVENT_START:
|
|||
|
|
{
|
|||
|
|
SplitHulls(hulls, ref hullCount, points, events[i]);
|
|||
|
|
}
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
default:
|
|||
|
|
{
|
|||
|
|
MergeHulls(hulls, ref hullCount, points, events[i]);
|
|||
|
|
}
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
hulls.Dispose();
|
|||
|
|
events.Dispose();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
void Prepare(NativeArray<TessEdge> edgesIn)
|
|||
|
|
{
|
|||
|
|
m_Stars = new NativeArray<TessStar>(edgesIn.Length, Allocator.Temp);
|
|||
|
|
|
|||
|
|
for (int i = 0; i < edgesIn.Length; ++i)
|
|||
|
|
{
|
|||
|
|
TessEdge e = edgesIn[i];
|
|||
|
|
e.a = (edgesIn[i].a < edgesIn[i].b) ? edgesIn[i].a : edgesIn[i].b;
|
|||
|
|
e.b = (edgesIn[i].a > edgesIn[i].b) ? edgesIn[i].a : edgesIn[i].b;
|
|||
|
|
edgesIn[i] = e;
|
|||
|
|
TessStar s = m_Stars[i];
|
|||
|
|
s.points = new ArraySlice<int>(m_SPArray, i * m_StarCount, m_StarCount);
|
|||
|
|
s.pointCount = 0;
|
|||
|
|
m_Stars[i] = s;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
unsafe
|
|||
|
|
{
|
|||
|
|
TessUtils.InsertionSort<TessEdge, TessEdgeCompare>(
|
|||
|
|
NativeArrayUnsafeUtility.GetUnsafeBufferPointerWithoutChecks(edgesIn), 0, edgesIn.Length - 1,
|
|||
|
|
new TessEdgeCompare());
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
m_Edges = new NativeArray<TessEdge>(edgesIn.Length, Allocator.Temp);
|
|||
|
|
m_Edges.CopyFrom(edgesIn);
|
|||
|
|
|
|||
|
|
// Fill stars.
|
|||
|
|
for (int i = 0; i < m_CellCount; ++i)
|
|||
|
|
{
|
|||
|
|
int a = m_Cells[i].a;
|
|||
|
|
int b = m_Cells[i].b;
|
|||
|
|
int c = m_Cells[i].c;
|
|||
|
|
TessStar sa = m_Stars[a];
|
|||
|
|
TessStar sb = m_Stars[b];
|
|||
|
|
TessStar sc = m_Stars[c];
|
|||
|
|
sa.points[sa.pointCount++] = b;
|
|||
|
|
sa.points[sa.pointCount++] = c;
|
|||
|
|
sb.points[sb.pointCount++] = c;
|
|||
|
|
sb.points[sb.pointCount++] = a;
|
|||
|
|
sc.points[sc.pointCount++] = a;
|
|||
|
|
sc.points[sc.pointCount++] = b;
|
|||
|
|
m_Stars[a] = sa;
|
|||
|
|
m_Stars[b] = sb;
|
|||
|
|
m_Stars[c] = sc;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
int OppositeOf(int a, int b)
|
|||
|
|
{
|
|||
|
|
ArraySlice<int> points = m_Stars[b].points;
|
|||
|
|
for (int k = 1, n = m_Stars[b].pointCount; k < n; k += 2)
|
|||
|
|
{
|
|||
|
|
if (points[k] == a)
|
|||
|
|
{
|
|||
|
|
return points[k - 1];
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static int GetEqualHullForEdges(NativeArray<TessEdge> edges, TessEdge p)
|
|||
|
|
{
|
|||
|
|
int l = 0;
|
|||
|
|
int h = edges.Length - 1;
|
|||
|
|
TessEdgeCompare tec = new TessEdgeCompare();
|
|||
|
|
while (l <= h)
|
|||
|
|
{
|
|||
|
|
int m;
|
|||
|
|
m = ((int) (l + h)) >> 1;
|
|||
|
|
int f = tec.Compare(edges[m], p);
|
|||
|
|
if (f == 0)
|
|||
|
|
{
|
|||
|
|
return m;
|
|||
|
|
}
|
|||
|
|
else if (f <= 0)
|
|||
|
|
{
|
|||
|
|
l = m + 1;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
h = m - 1;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
int FindConstraint(int a, int b)
|
|||
|
|
{
|
|||
|
|
TessEdge e;
|
|||
|
|
e.a = a < b ? a : b;
|
|||
|
|
e.b = a > b ? a : b;
|
|||
|
|
return GetEqualHullForEdges(m_Edges, e);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void AddTriangle(int i, int j, int k)
|
|||
|
|
{
|
|||
|
|
TessStar si = m_Stars[i];
|
|||
|
|
TessStar sj = m_Stars[j];
|
|||
|
|
TessStar sk = m_Stars[k];
|
|||
|
|
si.points[si.pointCount++] = j;
|
|||
|
|
si.points[si.pointCount++] = k;
|
|||
|
|
sj.points[sj.pointCount++] = k;
|
|||
|
|
sj.points[sj.pointCount++] = i;
|
|||
|
|
sk.points[sk.pointCount++] = i;
|
|||
|
|
sk.points[sk.pointCount++] = j;
|
|||
|
|
m_Stars[i] = si;
|
|||
|
|
m_Stars[j] = sj;
|
|||
|
|
m_Stars[k] = sk;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void RemovePair(int r, int j, int k)
|
|||
|
|
{
|
|||
|
|
TessStar s = m_Stars[r];
|
|||
|
|
ArraySlice<int> points = s.points;
|
|||
|
|
for (int i = 1, n = s.pointCount; i < n; i += 2)
|
|||
|
|
{
|
|||
|
|
if (points[i - 1] == j && points[i] == k)
|
|||
|
|
{
|
|||
|
|
points[i - 1] = points[n - 2];
|
|||
|
|
points[i] = points[n - 1];
|
|||
|
|
s.points = points;
|
|||
|
|
s.pointCount = s.pointCount - 2;
|
|||
|
|
m_Stars[r] = s;
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void RemoveTriangle(int i, int j, int k)
|
|||
|
|
{
|
|||
|
|
RemovePair(i, j, k);
|
|||
|
|
RemovePair(j, k, i);
|
|||
|
|
RemovePair(k, i, j);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void EdgeFlip(int i, int j)
|
|||
|
|
{
|
|||
|
|
int a = OppositeOf(i, j);
|
|||
|
|
int b = OppositeOf(j, i);
|
|||
|
|
RemoveTriangle(i, j, a);
|
|||
|
|
RemoveTriangle(j, i, b);
|
|||
|
|
AddTriangle(i, b, a);
|
|||
|
|
AddTriangle(j, a, b);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void Flip(NativeArray<float2> points, ref NativeArray<int> stack, ref int stackCount,
|
|||
|
|
int a, int b, int x)
|
|||
|
|
{
|
|||
|
|
int y = OppositeOf(a, b);
|
|||
|
|
|
|||
|
|
if (y < 0)
|
|||
|
|
{
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (b < a)
|
|||
|
|
{
|
|||
|
|
int tmp = a;
|
|||
|
|
a = b;
|
|||
|
|
b = tmp;
|
|||
|
|
tmp = x;
|
|||
|
|
x = y;
|
|||
|
|
y = tmp;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (FindConstraint(a, b) != -1)
|
|||
|
|
{
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (TessUtils.IsInsideCircle(points[a], points[b], points[x], points[y]))
|
|||
|
|
{
|
|||
|
|
stack[stackCount++] = a;
|
|||
|
|
stack[stackCount++] = b;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
NativeArray<TessCell> GetCells(ref int count)
|
|||
|
|
{
|
|||
|
|
NativeArray<TessCell> cellsOut = new NativeArray<TessCell>(m_NumPoints * (m_NumPoints + 1), Allocator.Temp);
|
|||
|
|
count = 0;
|
|||
|
|
for (int i = 0, n = m_Stars.Length; i < n; ++i)
|
|||
|
|
{
|
|||
|
|
ArraySlice<int> points = m_Stars[i].points;
|
|||
|
|
for (int j = 0, m = m_Stars[i].pointCount; j < m; j += 2)
|
|||
|
|
{
|
|||
|
|
int s = points[j];
|
|||
|
|
int t = points[j + 1];
|
|||
|
|
if (i < math.min(s, t))
|
|||
|
|
{
|
|||
|
|
TessCell c = new TessCell();
|
|||
|
|
c.a = i;
|
|||
|
|
c.b = s;
|
|||
|
|
c.c = t;
|
|||
|
|
cellsOut[count++] = c;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return cellsOut;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
internal void ApplyDelaunay(NativeArray<float2> points, NativeArray<TessEdge> edgesIn)
|
|||
|
|
{
|
|||
|
|
|
|||
|
|
NativeArray<int> stack = new NativeArray<int>(m_NumPoints * (m_NumPoints + 1), Allocator.Temp);
|
|||
|
|
int stackCount = 0;
|
|||
|
|
|
|||
|
|
Prepare(edgesIn);
|
|||
|
|
for (int a = 0; a < m_NumPoints; ++a)
|
|||
|
|
{
|
|||
|
|
TessStar star = m_Stars[a];
|
|||
|
|
for (int j = 1; j < star.pointCount; j += 2)
|
|||
|
|
{
|
|||
|
|
int b = star.points[j];
|
|||
|
|
|
|||
|
|
if (b < a)
|
|||
|
|
{
|
|||
|
|
continue;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (FindConstraint(a, b) >= 0)
|
|||
|
|
{
|
|||
|
|
continue;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
int x = star.points[j - 1], y = -1;
|
|||
|
|
for (int k = 1; k < star.pointCount; k += 2)
|
|||
|
|
{
|
|||
|
|
if (star.points[k - 1] == b)
|
|||
|
|
{
|
|||
|
|
y = star.points[k];
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (y < 0)
|
|||
|
|
{
|
|||
|
|
continue;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (TessUtils.IsInsideCircle(points[a], points[b], points[x], points[y]))
|
|||
|
|
{
|
|||
|
|
stack[stackCount++] = a;
|
|||
|
|
stack[stackCount++] = b;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
while (stackCount > 0)
|
|||
|
|
{
|
|||
|
|
int b = stack[stackCount - 1];
|
|||
|
|
stackCount--;
|
|||
|
|
int a = stack[stackCount - 1];
|
|||
|
|
stackCount--;
|
|||
|
|
|
|||
|
|
int x = -1, y = -1;
|
|||
|
|
TessStar star = m_Stars[a];
|
|||
|
|
for (int i = 1; i < star.pointCount; i += 2)
|
|||
|
|
{
|
|||
|
|
int s = star.points[i - 1];
|
|||
|
|
int t = star.points[i];
|
|||
|
|
if (s == b)
|
|||
|
|
{
|
|||
|
|
y = t;
|
|||
|
|
}
|
|||
|
|
else if (t == b)
|
|||
|
|
{
|
|||
|
|
x = s;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (x < 0 || y < 0)
|
|||
|
|
{
|
|||
|
|
continue;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (!TessUtils.IsInsideCircle(points[a], points[b], points[x], points[y]))
|
|||
|
|
{
|
|||
|
|
continue;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
EdgeFlip(a, b);
|
|||
|
|
|
|||
|
|
Flip(points, ref stack, ref stackCount, x, a, y);
|
|||
|
|
Flip(points, ref stack, ref stackCount, a, y, x);
|
|||
|
|
Flip(points, ref stack, ref stackCount, y, b, x);
|
|||
|
|
Flip(points, ref stack, ref stackCount, b, x, y);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
stack.Dispose();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
int GetEqualCellForCells(NativeArray<TessCell> cells, int count, TessCell p)
|
|||
|
|
{
|
|||
|
|
int l = 0;
|
|||
|
|
int h = count - 1;
|
|||
|
|
TessCellCompare tcc = new TessCellCompare();
|
|||
|
|
while (l <= h)
|
|||
|
|
{
|
|||
|
|
int m;
|
|||
|
|
m = ((int) (l + h)) >> 1;
|
|||
|
|
int f = tcc.Compare(cells[m], p);
|
|||
|
|
if (f == 0)
|
|||
|
|
{
|
|||
|
|
return m;
|
|||
|
|
}
|
|||
|
|
else if (f <= 0)
|
|||
|
|
{
|
|||
|
|
l = m + 1;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
h = m - 1;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
int FindNeighbor(NativeArray<TessCell> cells, int count, int a, int b, int c)
|
|||
|
|
{
|
|||
|
|
int x = a, y = b, z = c;
|
|||
|
|
if (b < c)
|
|||
|
|
{
|
|||
|
|
if (b < a)
|
|||
|
|
{
|
|||
|
|
x = b;
|
|||
|
|
y = c;
|
|||
|
|
z = a;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else if (c < a)
|
|||
|
|
{
|
|||
|
|
x = c;
|
|||
|
|
y = a;
|
|||
|
|
z = b;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (x < 0)
|
|||
|
|
{
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
TessCell key;
|
|||
|
|
key.a = x;
|
|||
|
|
key.b = y;
|
|||
|
|
key.c = z;
|
|||
|
|
return GetEqualCellForCells(cells, count, key);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
NativeArray<TessCell> Constrain(ref int count)
|
|||
|
|
{
|
|||
|
|
var cells = GetCells(ref count);
|
|||
|
|
int nc = count;
|
|||
|
|
for (int i = 0; i < nc; ++i)
|
|||
|
|
{
|
|||
|
|
TessCell c = cells[i];
|
|||
|
|
int x = c.a, y = c.b, z = c.c;
|
|||
|
|
if (y < z)
|
|||
|
|
{
|
|||
|
|
if (y < x)
|
|||
|
|
{
|
|||
|
|
c.a = y;
|
|||
|
|
c.b = z;
|
|||
|
|
c.c = x;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else if (z < x)
|
|||
|
|
{
|
|||
|
|
c.a = z;
|
|||
|
|
c.b = x;
|
|||
|
|
c.c = y;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
cells[i] = c;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
unsafe
|
|||
|
|
{
|
|||
|
|
TessUtils.InsertionSort<TessCell, TessCellCompare>(
|
|||
|
|
NativeArrayUnsafeUtility.GetUnsafeBufferPointerWithoutChecks(cells), 0, m_CellCount - 1,
|
|||
|
|
new TessCellCompare());
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Out
|
|||
|
|
m_Flags = new NativeArray<int>(nc, Allocator.Temp);
|
|||
|
|
m_Neighbors = new NativeArray<int>(nc * 3, Allocator.Temp);
|
|||
|
|
m_Constraints = new NativeArray<int>(nc * 3, Allocator.Temp);
|
|||
|
|
var next = new NativeArray<int>(nc * 3, Allocator.Temp);
|
|||
|
|
var active = new NativeArray<int>(nc * 3, Allocator.Temp);
|
|||
|
|
|
|||
|
|
int side = 1, nextCount = 0, activeCount = 0;
|
|||
|
|
|
|||
|
|
for (int i = 0; i < nc; ++i)
|
|||
|
|
{
|
|||
|
|
TessCell c = cells[i];
|
|||
|
|
for (int j = 0; j < 3; ++j)
|
|||
|
|
{
|
|||
|
|
int x = j, y = (j + 1) % 3;
|
|||
|
|
x = (x == 0) ? c.a : (j == 1) ? c.b : c.c;
|
|||
|
|
y = (y == 0) ? c.a : (y == 1) ? c.b : c.c;
|
|||
|
|
|
|||
|
|
int o = OppositeOf(y, x);
|
|||
|
|
int a = m_Neighbors[3 * i + j] = FindNeighbor(cells, count, y, x, o);
|
|||
|
|
int b = m_Constraints[3 * i + j] = (-1 != FindConstraint(x, y)) ? 1 : 0;
|
|||
|
|
if (a < 0)
|
|||
|
|
{
|
|||
|
|
if (0 != b)
|
|||
|
|
{
|
|||
|
|
next[nextCount++] = i;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
active[activeCount++] = i;
|
|||
|
|
m_Flags[i] = 1;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
while (activeCount > 0 || nextCount > 0)
|
|||
|
|
{
|
|||
|
|
while (activeCount > 0)
|
|||
|
|
{
|
|||
|
|
int t = active[activeCount - 1];
|
|||
|
|
activeCount--;
|
|||
|
|
if (m_Flags[t] == -side)
|
|||
|
|
{
|
|||
|
|
continue;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
m_Flags[t] = side;
|
|||
|
|
TessCell c = cells[t];
|
|||
|
|
for (int j = 0; j < 3; ++j)
|
|||
|
|
{
|
|||
|
|
int f = m_Neighbors[3 * t + j];
|
|||
|
|
if (f >= 0 && m_Flags[f] == 0)
|
|||
|
|
{
|
|||
|
|
if (0 != m_Constraints[3 * t + j])
|
|||
|
|
{
|
|||
|
|
next[nextCount++] = f;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
active[activeCount++] = f;
|
|||
|
|
m_Flags[f] = side;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
for (int e = 0; e < nextCount; e++)
|
|||
|
|
active[e] = next[e];
|
|||
|
|
activeCount = nextCount;
|
|||
|
|
nextCount = 0;
|
|||
|
|
side = -side;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
active.Dispose();
|
|||
|
|
next.Dispose();
|
|||
|
|
return cells;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
internal NativeArray<TessCell> RemoveExterior(ref int cellCount)
|
|||
|
|
{
|
|||
|
|
int constrainedCount = 0;
|
|||
|
|
NativeArray<TessCell> constrained = Constrain(ref constrainedCount);
|
|||
|
|
|
|||
|
|
NativeArray<TessCell> cellsOut = new NativeArray<TessCell>(constrainedCount, Allocator.Temp);
|
|||
|
|
cellCount = 0;
|
|||
|
|
for (int i = 0; i < constrainedCount; ++i)
|
|||
|
|
{
|
|||
|
|
if (m_Flags[i] == -1)
|
|||
|
|
{
|
|||
|
|
cellsOut[cellCount++] = constrained[i];
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
constrained.Dispose();
|
|||
|
|
return cellsOut;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
internal NativeArray<TessCell> RemoveInterior(int cellCount)
|
|||
|
|
{
|
|||
|
|
int constrainedCount = 0;
|
|||
|
|
NativeArray<TessCell> constrained = Constrain(ref constrainedCount);
|
|||
|
|
|
|||
|
|
NativeArray<TessCell> cellsOut = new NativeArray<TessCell>(constrainedCount, Allocator.Temp);
|
|||
|
|
cellCount = 0;
|
|||
|
|
for (int i = 0; i < constrainedCount; ++i)
|
|||
|
|
{
|
|||
|
|
if (m_Flags[i] == 1)
|
|||
|
|
{
|
|||
|
|
cellsOut[cellCount++] = constrained[i];
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
constrained.Dispose();
|
|||
|
|
return cellsOut;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
internal void Cleanup()
|
|||
|
|
{
|
|||
|
|
m_Edges.Dispose();
|
|||
|
|
m_Stars.Dispose();
|
|||
|
|
m_ILArray.Dispose();
|
|||
|
|
m_IUArray.Dispose();
|
|||
|
|
m_SPArray.Dispose();
|
|||
|
|
m_Cells.Dispose();
|
|||
|
|
|
|||
|
|
m_Flags.Dispose();
|
|||
|
|
m_Neighbors.Dispose();
|
|||
|
|
m_Constraints.Dispose();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|