Fix pooling and allow it to be extended externally.

Author: speps

LibTessDotNet/Sources/Mesh.cs

@@ -41,20 +41,18 @@ namespace LibTessDotNet.Double
 namespace LibTessDotNet
 #endif
 {
-    internal class Mesh : MeshUtils.Pooled<Mesh>
+    internal class Mesh : Pooled<Mesh>
     {
         internal MeshUtils.Vertex _vHead;
         internal MeshUtils.Face _fHead;
         internal MeshUtils.Edge _eHead, _eHeadSym;
 
-        private readonly List<MeshUtils.EdgePair> _allEdgePairs = new List<MeshUtils.EdgePair>(20000);
-
-        public void Init()
+        public void Init(IPool pool)
         {
-            var v = _vHead = MeshUtils.Vertex.Create();
-            var f = _fHead = MeshUtils.Face.Create();
+            var v = _vHead = pool.Get<MeshUtils.Vertex>();
+            var f = _fHead = pool.Get<MeshUtils.Face>();
 
-            var pair = CreateEdgePair();
+            var pair = MeshUtils.EdgePair.Create(pool);
             var e = _eHead = pair._e;
             var eSym = _eHeadSym = pair._eSym;
 
@@ -86,116 +84,40 @@ public void Init()
             eSym._activeRegion = null;
         }
 
-        public override void Reset()
+        public void Reset(IPool pool)
         {
-            MeshUtils.Face f = _fHead._next;
-            while (true)
+            for (MeshUtils.Face f = _fHead, fNext = _fHead; f._next != null; f = fNext)
             {
-                MeshUtils.Face fNext = f._next;
-                f.Free();
-                if (f == _fHead) break;
-                f = fNext;
+                fNext = f._next;
+                pool.Return(f);
             }
-
-            MeshUtils.Vertex v = _vHead._next;
-            while (true)
+            for (MeshUtils.Vertex v = _vHead, vNext = _vHead; v._next != null; v = vNext)
             {
-                MeshUtils.Vertex vNext = v._next;
-                v.Free();
-                if (v == _vHead) break;
-                v = vNext;
+                vNext = v._next;
+                pool.Return(v);
             }
-
-            for (int i = 0; i < _allEdgePairs.Count; i++)
+            for (MeshUtils.Edge e = _eHead, eNext = _eHead; e._next != null; e = eNext)
             {
-                MeshUtils.EdgePair pair = _allEdgePairs[i];
-
-                MeshUtils.Edge e = pair._e;
-                if (!e.IsReturnedToPool()) // (can be Free in KillEdge)
-                {
-                    e.Free();
-                }
-
-                MeshUtils.Edge eSym = pair._eSym;
-                if (!eSym.IsReturnedToPool()) // (can be Free in KillEdge)
-                {
-                    eSym.Free();
-                }
-
-                pair.Free();
-            }
-            _allEdgePairs.Clear();
-
+                eNext = e._next;
+                pool.Return(e._Sym);
+                pool.Return(e);
+            }
             _vHead = null;
             _fHead = null;
             _eHead = _eHeadSym = null;
         }
 
-        private MeshUtils.EdgePair CreateEdgePair()
-        {
-            var pair = MeshUtils.EdgePair.Create();
-            pair._e = MeshUtils.Edge.Create();
-            pair._e._pair = pair;
-            pair._eSym = MeshUtils.Edge.Create();
-            pair._eSym._pair = pair;
-            _allEdgePairs.Add(pair);
-            return pair;
-        }
-
         /// <summary>
         /// Creates one edge, two vertices and a loop (face).
         /// The loop consists of the two new half-edges.
         /// </summary>
-        public MeshUtils.Edge MakeEdge()
+        public MeshUtils.Edge MakeEdge(IPool pool)
         {
-            var e = MakeEdge(_eHead);
-
-            MeshUtils.MakeVertex(e, _vHead);
-            MeshUtils.MakeVertex(e._Sym, _vHead);
-            MeshUtils.MakeFace(e, _fHead);
-
-            return e;
-        }
+            var e = MeshUtils.MakeEdge(pool, _eHead);
 
-        /// <summary>
-        /// MakeEdge creates a new pair of half-edges which form their own loop.
-        /// No vertex or face structures are allocated, but these must be assigned
-        /// before the current edge operation is completed.
-        /// </summary>
-        private MeshUtils.Edge MakeEdge(MeshUtils.Edge eNext)
-        {
-            Debug.Assert(eNext != null);
-
-            var pair = CreateEdgePair();
-            var e = pair._e;
-            var eSym = pair._eSym;
-
-            // Make sure eNext points to the first edge of the edge pair
-            MeshUtils.Edge.EnsureFirst(ref eNext);
-
-            // Insert in circular doubly-linked list before eNext.
-            // Note that the prev pointer is stored in Sym->next.
-            var ePrev = eNext._Sym._next;
-            eSym._next = ePrev;
-            ePrev._Sym._next = e;
-            e._next = eNext;
-            eNext._Sym._next = eSym;
-
-            e._Sym = eSym;
-            e._Onext = e;
-            e._Lnext = eSym;
-            e._Org = null;
-            e._Lface = null;
-            e._winding = 0;
-            e._activeRegion = null;
-
-            eSym._Sym = e;
-            eSym._Onext = eSym;
-            eSym._Lnext = e;
-            eSym._Org = null;
-            eSym._Lface = null;
-            eSym._winding = 0;
-            eSym._activeRegion = null;
+            MeshUtils.MakeVertex(pool, e, _vHead);
+            MeshUtils.MakeVertex(pool, e._Sym, _vHead);
+            MeshUtils.MakeFace(pool, e, _fHead);
 
             return e;
         }
@@ -224,7 +146,7 @@ private MeshUtils.Edge MakeEdge(MeshUtils.Edge eNext)
         /// If eDst == eOrg->Onext, the new vertex will have a single edge.
         /// If eDst == eOrg->Oprev, the old vertex will have a single edge.
         /// </summary>
-        public void Splice(MeshUtils.Edge eOrg, MeshUtils.Edge eDst)
+        public void Splice(IPool pool, MeshUtils.Edge eOrg, MeshUtils.Edge eDst)
         {
             if (eOrg == eDst)
             {
@@ -236,14 +158,14 @@ public void Splice(MeshUtils.Edge eOrg, MeshUtils.Edge eDst)
             {
                 // We are merging two disjoint vertices -- destroy eDst->Org
                 joiningVertices = true;
-                MeshUtils.KillVertex(eDst._Org, eOrg._Org);
+                MeshUtils.KillVertex(pool, eDst._Org, eOrg._Org);
             }
             bool joiningLoops = false;
             if (eDst._Lface != eOrg._Lface)
             {
                 // We are connecting two disjoint loops -- destroy eDst->Lface
                 joiningLoops = true;
-                MeshUtils.KillFace(eDst._Lface, eOrg._Lface);
+                MeshUtils.KillFace(pool, eDst._Lface, eOrg._Lface);
             }
 
             // Change the edge structure
@@ -253,14 +175,14 @@ public void Splice(MeshUtils.Edge eOrg, MeshUtils.Edge eDst)
             {
                 // We split one vertex into two -- the new vertex is eDst->Org.
                 // Make sure the old vertex points to a valid half-edge.
-                MeshUtils.MakeVertex(eDst, eOrg._Org);
+                MeshUtils.MakeVertex(pool, eDst, eOrg._Org);
                 eOrg._Org._anEdge = eOrg;
             }
             if (!joiningLoops)
             {
                 // We split one loop into two -- the new loop is eDst->Lface.
                 // Make sure the old face points to a valid half-edge.
-                MeshUtils.MakeFace(eDst, eOrg._Lface);
+                MeshUtils.MakeFace(pool, eDst, eOrg._Lface);
                 eOrg._Lface._anEdge = eOrg;
             }
         }
@@ -272,7 +194,7 @@ public void Splice(MeshUtils.Edge eOrg, MeshUtils.Edge eDst)
         /// the newly created loop will contain eDel->Dst. If the deletion of eDel
         /// would create isolated vertices, those are deleted as well.
         /// </summary>
-        public void Delete(MeshUtils.Edge eDel)
+        public void Delete(IPool pool, MeshUtils.Edge eDel)
         {
             var eDelSym = eDel._Sym;
 
@@ -284,12 +206,12 @@ public void Delete(MeshUtils.Edge eDel)
             {
                 // We are joining two loops into one -- remove the left face
                 joiningLoops = true;
-                MeshUtils.KillFace(eDel._Lface, eDel._Rface);
+                MeshUtils.KillFace(pool, eDel._Lface, eDel._Rface);
             }
 
             if (eDel._Onext == eDel)
             {
-                MeshUtils.KillVertex(eDel._Org, null);
+                MeshUtils.KillVertex(pool, eDel._Org, null);
             }
             else
             {
@@ -302,7 +224,7 @@ public void Delete(MeshUtils.Edge eDel)
                 if (!joiningLoops)
                 {
                     // We are splitting one loop into two -- create a new loop for eDel.
-                    MeshUtils.MakeFace(eDel, eDel._Lface);
+                    MeshUtils.MakeFace(pool, eDel, eDel._Lface);
                 }
             }
 
@@ -311,8 +233,8 @@ public void Delete(MeshUtils.Edge eDel)
 
             if (eDelSym._Onext == eDelSym)
             {
-                MeshUtils.KillVertex(eDelSym._Org, null);
-                MeshUtils.KillFace(eDelSym._Lface, null);
+                MeshUtils.KillVertex(pool, eDelSym._Org, null);
+                MeshUtils.KillFace(pool, eDelSym._Lface, null);
             }
             else
             {
@@ -323,24 +245,24 @@ public void Delete(MeshUtils.Edge eDel)
             }
 
             // Any isolated vertices or faces have already been freed.
-            MeshUtils.KillEdge(eDel);
+            MeshUtils.KillEdge(pool, eDel);
         }
 
         /// <summary>
         /// Creates a new edge such that eNew == eOrg.Lnext and eNew.Dst is a newly created vertex.
         /// eOrg and eNew will have the same left face.
         /// </summary>
-        public MeshUtils.Edge AddEdgeVertex(MeshUtils.Edge eOrg)
+        public MeshUtils.Edge AddEdgeVertex(IPool pool, MeshUtils.Edge eOrg)
         {
-            var eNew = MakeEdge(eOrg);
+            var eNew = MeshUtils.MakeEdge(pool, eOrg);
             var eNewSym = eNew._Sym;
 
             // Connect the new edge appropriately
             MeshUtils.Splice(eNew, eOrg._Lnext);
 
             // Set vertex and face information
             eNew._Org = eOrg._Dst;
-            MeshUtils.MakeVertex(eNewSym, eNew._Org);
+            MeshUtils.MakeVertex(pool, eNewSym, eNew._Org);
             eNew._Lface = eNewSym._Lface = eOrg._Lface;
 
             return eNew;
@@ -351,9 +273,9 @@ public MeshUtils.Edge AddEdgeVertex(MeshUtils.Edge eOrg)
         /// The new vertex is eOrg.Dst == eNew.Org.
         /// eOrg and eNew will have the same left face.
         /// </summary>
-        public MeshUtils.Edge SplitEdge(MeshUtils.Edge eOrg)
+        public MeshUtils.Edge SplitEdge(IPool pool, MeshUtils.Edge eOrg)
         {
-            var eTmp = AddEdgeVertex(eOrg);
+            var eTmp = AddEdgeVertex(pool, eOrg);
             var eNew = eTmp._Sym;
 
             // Disconnect eOrg from eOrg->Dst and connect it to eNew->Org
@@ -380,17 +302,17 @@ public MeshUtils.Edge SplitEdge(MeshUtils.Edge eOrg)
         /// If (eOrg->Lnext == eDst), the old face is reduced to a single edge.
         /// If (eOrg->Lnext->Lnext == eDst), the old face is reduced to two edges.
         /// </summary>
-        public MeshUtils.Edge Connect(MeshUtils.Edge eOrg, MeshUtils.Edge eDst)
+        public MeshUtils.Edge Connect(IPool pool, MeshUtils.Edge eOrg, MeshUtils.Edge eDst)
         {
-            var eNew = MakeEdge(eOrg);
+            var eNew = MeshUtils.MakeEdge(pool, eOrg);
             var eNewSym = eNew._Sym;
 
             bool joiningLoops = false;
             if (eDst._Lface != eOrg._Lface)
             {
                 // We are connecting two disjoint loops -- destroy eDst->Lface
                 joiningLoops = true;
-                MeshUtils.KillFace(eDst._Lface, eOrg._Lface);
+                MeshUtils.KillFace(pool, eDst._Lface, eOrg._Lface);
             }
 
             // Connect the new edge appropriately
@@ -407,7 +329,7 @@ public MeshUtils.Edge Connect(MeshUtils.Edge eOrg, MeshUtils.Edge eDst)
 
             if (!joiningLoops)
             {
-                MeshUtils.MakeFace(eNew, eOrg._Lface);
+                MeshUtils.MakeFace(pool, eNew, eOrg._Lface);
             }
 
             return eNew;
@@ -421,7 +343,7 @@ public MeshUtils.Edge Connect(MeshUtils.Edge eOrg, MeshUtils.Edge eDst)
         /// An entire mesh can be deleted by zapping its faces, one at a time,
         /// in any order. Zapped faces cannot be used in further mesh operations!
         /// </summary>
-        public void ZapFace(MeshUtils.Face fZap)
+        public void ZapFace(IPool pool, MeshUtils.Face fZap)
         {
             var eStart = fZap._anEdge;
 
@@ -439,7 +361,7 @@ public void ZapFace(MeshUtils.Face fZap)
 
                     if (e._Onext == e)
                     {
-                        MeshUtils.KillVertex(e._Org, null);
+                        MeshUtils.KillVertex(pool, e._Org, null);
                     }
                     else
                     {
@@ -450,15 +372,15 @@ public void ZapFace(MeshUtils.Face fZap)
                     eSym = e._Sym;
                     if (eSym._Onext == eSym)
                     {
-                        MeshUtils.KillVertex(eSym._Org, null);
+                        MeshUtils.KillVertex(pool, eSym._Org, null);
                     }
                     else
                     {
                         // Make sure that eSym._Org points to a valid half-edge
                         eSym._Org._anEdge = eSym._Onext;
                         MeshUtils.Splice(eSym, eSym._Oprev);
                     }
-                    MeshUtils.KillEdge(e);
+                    MeshUtils.KillEdge(pool, e);
                 }
             } while (e != eStart);
 
@@ -468,10 +390,10 @@ public void ZapFace(MeshUtils.Face fZap)
             fNext._prev = fPrev;
             fPrev._next = fNext;
 
-            fZap.Free();
+            pool.Return(fZap);
         }
 
-        public void MergeConvexFaces(int maxVertsPerFace)
+        public void MergeConvexFaces(IPool pool, int maxVertsPerFace)
         {
             for (var f = _fHead._next; f != _fHead; f = f._next)
             {
@@ -502,7 +424,7 @@ public void MergeConvexFaces(int maxVertsPerFace)
                                 Geom.VertCCW(eSym._Lprev._Org, eSym._Org, eCur._Lnext._Lnext._Org))
                             {
                                 eNext = eSym._Lnext;
-                                Delete(eSym);
+                                Delete(pool, eSym);
                                 eCur = null;
                             }
                         }