public void Check()
{
MeshUtils.Edge e;
MeshUtils.Face fPrev = _fHead, f;
for (fPrev = _fHead; (f = fPrev._next) != _fHead; fPrev = f)
{
e = f._anEdge;
do
{
Debug.Assert(e._Sym != e);
Debug.Assert(e._Sym._Sym == e);
Debug.Assert(e._Lnext._Onext._Sym == e);
Debug.Assert(e._Onext._Sym._Lnext == e);
Debug.Assert(e._Lface == f);
e = e._Lnext;
} while (e != f._anEdge);
}
Debug.Assert(f._prev == fPrev && f._anEdge == null);
MeshUtils.Vertex vPrev = _vHead, v;
for (vPrev = _vHead; (v = vPrev._next) != _vHead; vPrev = v)
{
Debug.Assert(v._prev == vPrev);
e = v._anEdge;
do
{
Debug.Assert(e._Sym != e);
Debug.Assert(e._Sym._Sym == e);
Debug.Assert(e._Lnext._Onext._Sym == e);
Debug.Assert(e._Onext._Sym._Lnext == e);
Debug.Assert(e._Org == v);
e = e._Onext;
} while (e != v._anEdge);
}
Debug.Assert(v._prev == vPrev && v._anEdge == null);
MeshUtils.Edge ePrev = _eHead;
for (ePrev = _eHead; (e = ePrev._next) != _eHead; ePrev = e)
{
Debug.Assert(e._Sym._next == ePrev._Sym);
Debug.Assert(e._Sym != e);
Debug.Assert(e._Sym._Sym == e);
Debug.Assert(e._Org != null);
Debug.Assert(e._Dst != null);
Debug.Assert(e._Lnext._Onext._Sym == e);
Debug.Assert(e._Onext._Sym._Lnext == e);
}
Debug.Assert(e._Sym._next == ePrev._Sym &&
e._Sym == _eHeadSym &&
e._Sym._Sym == e &&
e._Org == null && e._Dst == null &&
e._Lface == null && e._Rface == null);
}
private void DiscardExterior()
{
MeshUtils.Face next;
for (MeshUtils.Face face = _mesh._fHead._next; face != _mesh._fHead; face = next)
{
next = face._next;
if (!face._inside)
{
_mesh.ZapFace(face);
}
}
}
private void TessellateInterior()
{
MeshUtils.Face next;
for (MeshUtils.Face face = _mesh._fHead._next; face != _mesh._fHead; face = next)
{
next = face._next;
if (face._inside)
{
TessellateMonoRegion(face);
}
}
}
/// <summary>
/// Destroys a face and removes it from the global face list. All edges of
/// fZap will have a NULL pointer as their left face. Any edges which
/// also have a NULL pointer as their right face are deleted entirely
/// (along with any isolated vertices this produces).
/// 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(IPool pool, MeshUtils.Face fZap)
{
var eStart = fZap._anEdge;
// walk around face, deleting edges whose right face is also NULL
var eNext = eStart._Lnext;
MeshUtils.Edge e, eSym;
do
{
e = eNext;
eNext = e._Lnext;
e._Lface = null;
if (e._Rface == null)
{
// delete the edge -- see TESSmeshDelete above
if (e._Onext == e)
{
MeshUtils.KillVertex(pool, e._Org, null);
}
else
{
// Make sure that e._Org points to a valid half-edge
e._Org._anEdge = e._Onext;
MeshUtils.Splice(e, e._Oprev);
}
eSym = e._Sym;
if (eSym._Onext == eSym)
{
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(pool, e);
}
} while (e != eStart);
/* delete from circular doubly-linked list */
var fPrev = fZap._prev;
var fNext = fZap._next;
fNext._prev = fPrev;
fPrev._next = fNext;
pool.Return(fZap);
}
private void RemoveDegenerateFaces()
{
MeshUtils.Face next;
for (MeshUtils.Face face = _mesh._fHead._next; face != _mesh._fHead; face = next)
{
next = face._next;
MeshUtils.Edge anEdge = face._anEdge;
if (anEdge._Lnext._Lnext == anEdge)
{
Geom.AddWinding(anEdge._Onext, anEdge);
_mesh.Delete(anEdge);
}
}
}
private void OutputContours()
{
int num = 0;
int num2 = 0;
_vertexCount = 0;
_elementCount = 0;
for (MeshUtils.Face next = _mesh._fHead._next; next != _mesh._fHead; next = next._next)
{
if (next._inside)
{
MeshUtils.Edge edge;
MeshUtils.Edge edge2 = edge = next._anEdge;
do
{
_vertexCount++;
edge = edge._Lnext;
}while (edge != edge2);
_elementCount++;
}
}
_elements = new int[_elementCount * 2];
_vertices = new ContourVertex[_vertexCount];
int num3 = 0;
int num4 = 0;
num = 0;
for (MeshUtils.Face next = _mesh._fHead._next; next != _mesh._fHead; next = next._next)
{
if (next._inside)
{
num2 = 0;
MeshUtils.Edge edge;
MeshUtils.Edge edge2 = edge = next._anEdge;
do
{
_vertices[num3].Position = edge._Org._coords;
_vertices[num3].Data = edge._Org._data;
num3++;
num2++;
edge = edge._Lnext;
}while (edge != edge2);
_elements[num4++] = num;
_elements[num4++] = num2;
num += num2;
}
}
}
public Mesh()
{
var v = _vHead = new MeshUtils.Vertex();
var f = _fHead = new MeshUtils.Face();
var pair = MeshUtils.EdgePair.Create();
var e = _eHead = pair._e;
var eSym = _eHeadSym = pair._eSym;
v._next = v._prev = v;
f._next = f._prev = f;
e._next = e;
e._Sym = eSym;
eSym._next = eSym;
eSym._Sym = e;
}
public void ZapFace(MeshUtils.Face fZap)
{
MeshUtils.Edge anEdge = fZap._anEdge;
MeshUtils.Edge lnext = anEdge._Lnext;
MeshUtils.Edge edge;
do
{
edge = lnext;
lnext = edge._Lnext;
edge._Lface = null;
if (edge._Rface == null)
{
if (edge._Onext == edge)
{
MeshUtils.KillVertex(edge._Org, null);
}
else
{
edge._Org._anEdge = edge._Onext;
MeshUtils.Edge edge2 = edge;
MeshUtils.Splice(edge2, edge2._Oprev);
}
MeshUtils.Edge sym = edge._Sym;
if (sym._Onext == sym)
{
MeshUtils.KillVertex(sym._Org, null);
}
else
{
sym._Org._anEdge = sym._Onext;
MeshUtils.Edge edge3 = sym;
MeshUtils.Splice(edge3, edge3._Oprev);
}
MeshUtils.KillEdge(edge);
}
}while (edge != anEdge);
MeshUtils.Face prev = fZap._prev;
MeshUtils.Face next = fZap._next;
next._prev = prev;
prev._next = next;
fZap.Free();
}
private void CheckOrientation()
{
float num = 0f;
for (MeshUtils.Face next = _mesh._fHead._next; next != _mesh._fHead; next = next._next)
{
if (next._anEdge._winding > 0)
{
num += MeshUtils.FaceArea(next);
}
}
if (num < 0f)
{
for (MeshUtils.Vertex next2 = _mesh._vHead._next; next2 != _mesh._vHead; next2 = next2._next)
{
MeshUtils.Vertex vertex = next2;
vertex._t = 0f - vertex._t;
}
Vec3.Neg(ref _tUnit);
}
}
private void TessellateMonoRegion(MeshUtils.Face face)
{
MeshUtils.Edge edge = face._anEdge;
while (Geom.VertLeq(edge._Dst, edge._Org))
{
edge = edge._Lprev;
}
while (Geom.VertLeq(edge._Org, edge._Dst))
{
edge = edge._Lnext;
}
MeshUtils.Edge edge2 = edge._Lprev;
while (edge._Lnext != edge2)
{
if (Geom.VertLeq(edge._Dst, edge2._Org))
{
while (edge2._Lnext != edge && (Geom.EdgeGoesLeft(edge2._Lnext) || Geom.EdgeSign(edge2._Org, edge2._Dst, edge2._Lnext._Dst) <= 0f))
{
edge2 = _mesh.Connect(edge2._Lnext, edge2)._Sym;
}
edge2 = edge2._Lprev;
}
else
{
while (edge2._Lnext != edge && (Geom.EdgeGoesRight(edge._Lprev) || Geom.EdgeSign(edge._Dst, edge._Org, edge._Lprev._Org) >= 0f))
{
Mesh mesh = _mesh;
MeshUtils.Edge edge3 = edge;
edge = mesh.Connect(edge3, edge3._Lprev)._Sym;
}
edge = edge._Lnext;
}
}
while (edge2._Lnext._Lnext != edge)
{
edge2 = _mesh.Connect(edge2._Lnext, edge2)._Sym;
}
}
public void Reset(IPool pool)
{
for (MeshUtils.Face f = _fHead, fNext = _fHead; f._next != null; f = fNext)
{
fNext = f._next;
pool.Return(f);
}
for (MeshUtils.Vertex v = _vHead, vNext = _vHead; v._next != null; v = vNext)
{
vNext = v._next;
pool.Return(v);
}
for (MeshUtils.Edge e = _eHead, eNext = _eHead; e._next != null; e = eNext)
{
eNext = e._next;
pool.Return(e._Sym);
pool.Return(e);
}
_vHead = null;
_fHead = null;
_eHead = _eHeadSym = null;
}
public Mesh()
{
var v = _vHead = MeshUtils.Vertex.Create();
var f = _fHead = MeshUtils.Face.Create();
var pair = MeshUtils.EdgePair.Create();
var e = _eHead = pair._e;
var eSym = _eHeadSym = pair._eSym;
v._next = v._prev = v;
v._anEdge = null;
f._next = f._prev = f;
f._anEdge = null;
f._trail = null;
f._marked = false;
f._inside = false;
e._next = e;
e._Sym = eSym;
e._Onext = null;
e._Lnext = null;
e._Org = null;
e._Lface = null;
e._winding = 0;
e._activeRegion = null;
eSym._next = eSym;
eSym._Sym = e;
eSym._Onext = null;
eSym._Lnext = null;
eSym._Org = null;
eSym._Lface = null;
eSym._winding = 0;
eSym._activeRegion = null;
}
public Mesh()
{
var v = _vHead = new MeshUtils.Vertex();
var f = _fHead = new MeshUtils.Face();
var pair = MeshUtils.EdgePair.Create();
var e = _eHead = pair._e;
var eSym = _eHeadSym = pair._eSym;
v._next = v._prev = v;
v._anEdge = null;
f._next = f._prev = f;
f._anEdge = null;
f._trail = null;
f._marked = false;
f._inside = false;
e._next = e;
e._Sym = eSym;
e._Onext = null;
e._Lnext = null;
e._Org = null;
e._Lface = null;
e._winding = 0;
e._activeRegion = null;
eSym._next = eSym;
eSym._Sym = e;
eSym._Onext = null;
eSym._Lnext = null;
eSym._Org = null;
eSym._Lface = null;
eSym._winding = 0;
eSym._activeRegion = null;
}
public Mesh()
{
MeshUtils.Vertex vertex = _vHead = MeshUtils.Pooled <MeshUtils.Vertex> .Create();
MeshUtils.Face face = _fHead = MeshUtils.Pooled <MeshUtils.Face> .Create();
MeshUtils.EdgePair edgePair = MeshUtils.EdgePair.Create();
MeshUtils.Edge edge = _eHead = edgePair._e;
MeshUtils.Edge edge2 = _eHeadSym = edgePair._eSym;
vertex._next = (vertex._prev = vertex);
vertex._anEdge = null;
MeshUtils.Face face2 = face;
face2._next = (face2._prev = face2);
face._anEdge = null;
face._trail = null;
face._marked = false;
face._inside = false;
MeshUtils.Edge edge3 = edge;
edge3._next = edge3;
edge._Sym = edge2;
edge._Onext = null;
edge._Lnext = null;
edge._Org = null;
edge._Lface = null;
edge._winding = 0;
edge._activeRegion = null;
MeshUtils.Edge edge4 = edge2;
edge4._next = edge4;
edge2._Sym = edge;
edge2._Onext = null;
edge2._Lnext = null;
edge2._Org = null;
edge2._Lface = null;
edge2._winding = 0;
edge2._activeRegion = null;
}
private void OutputPolymesh(ElementType elementType, int polySize)
{
int num = 0;
int num2 = 0;
if (polySize < 3)
{
polySize = 3;
}
if (polySize > 3)
{
_mesh.MergeConvexFaces(polySize);
}
for (MeshUtils.Vertex next = _mesh._vHead._next; next != _mesh._vHead; next = next._next)
{
next._n = -1;
}
for (MeshUtils.Face next2 = _mesh._fHead._next; next2 != _mesh._fHead; next2 = next2._next)
{
next2._n = -1;
if (next2._inside && (!NoEmptyPolygons || !(Math.Abs(MeshUtils.FaceArea(next2)) < 1.401298E-45f)))
{
MeshUtils.Edge edge = next2._anEdge;
int num3 = 0;
do
{
MeshUtils.Vertex next = edge._Org;
if (next._n == -1)
{
next._n = num2;
num2++;
}
num3++;
edge = edge._Lnext;
}while (edge != next2._anEdge);
next2._n = num;
num++;
}
}
_elementCount = num;
if (elementType == ElementType.ConnectedPolygons)
{
num *= 2;
}
_elements = new int[num * polySize];
_vertexCount = num2;
_vertices = new ContourVertex[_vertexCount];
for (MeshUtils.Vertex next = _mesh._vHead._next; next != _mesh._vHead; next = next._next)
{
if (next._n != -1)
{
_vertices[next._n].Position = next._coords;
_vertices[next._n].Data = next._data;
}
}
int num4 = 0;
for (MeshUtils.Face next2 = _mesh._fHead._next; next2 != _mesh._fHead; next2 = next2._next)
{
if (next2._inside && (!NoEmptyPolygons || !(Math.Abs(MeshUtils.FaceArea(next2)) < 1.401298E-45f)))
{
MeshUtils.Edge edge = next2._anEdge;
int num3 = 0;
do
{
MeshUtils.Vertex next = edge._Org;
_elements[num4++] = next._n;
num3++;
edge = edge._Lnext;
}while (edge != next2._anEdge);
for (int i = num3; i < polySize; i++)
{
_elements[num4++] = -1;
}
if (elementType == ElementType.ConnectedPolygons)
{
edge = next2._anEdge;
do
{
_elements[num4++] = GetNeighbourFace(edge);
edge = edge._Lnext;
}while (edge != next2._anEdge);
for (int i = num3; i < polySize; i++)
{
_elements[num4++] = -1;
}
}
}
}
}
public override void Reset()
{
_vHead = null;
_fHead = null;
_eHead = (_eHeadSym = null);
}
