RPG-FIGHT/Library/PackageCache/com.unity.2d.spriteshape@5.1.4/Runtime/UTess2D/Tessellator.cs

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();
            }

        }

    }
    
}