/// <summary>
/// insert object after 'node' returning an iterator to the inserted object.
/// </summary>
public CxFastListNode <T> Insert(CxFastListNode <T> node, T value)
{
if (node == null)
{
return(Add(value));
}
CxFastListNode <T> newNode = new CxFastListNode <T>(value);
CxFastListNode <T> nextNode = node._next;
newNode._next = nextNode;
node._next = newNode;
_count++;
return(newNode);
}
public List <T> GetListOfElements()
{
List <T> list = new List <T>();
CxFastListNode <T> iter = Begin();
if (iter != null)
{
do
{
list.Add(iter._elt);
iter = iter._next;
} while (iter != null);
}
return(list);
}
/// <summary>
/// add object to list (O(1))
/// </summary>
public CxFastListNode <T> Add(T value)
{
CxFastListNode <T> newNode = new CxFastListNode <T>(value);
if (_head == null)
{
newNode._next = null;
_head = newNode;
return(newNode);
}
newNode._next = _head;
_head = newNode;
return(newNode);
}
/// <summary>add object to list (O(1))</summary>
public CxFastListNode <T> Add(T value)
{
CxFastListNode <T> newNode = new CxFastListNode <T>(value);
if (head == null)
{
newNode.Next = null;
head = newNode;
return(newNode);
}
newNode.Next = head;
head = newNode;
return(newNode);
}
/** Look-up table to relate polygon key with the vertices that should be used for
the sub polygon in marching squares
**/
/** Perform a single celled marching square for for the given cell defined by (x0,y0) (x1,y1)
using the function f for recursive interpolation, given the look-up table 'fs' of
the values of 'f' at cell vertices with the result to be stored in 'poly' given the actual
coordinates of 'ax' 'ay' in the marching squares mesh.
**/
private static int MarchSquare(sbyte[,] f, sbyte[,] fs, ref GeomPoly poly, int ax, int ay, float x0, float y0,
float x1, float y1, int bin)
{
//key lookup
int key = 0;
sbyte v0 = fs[ax, ay];
if (v0 < 0) key |= 8;
sbyte v1 = fs[ax + 1, ay];
if (v1 < 0) key |= 4;
sbyte v2 = fs[ax + 1, ay + 1];
if (v2 < 0) key |= 2;
sbyte v3 = fs[ax, ay + 1];
if (v3 < 0) key |= 1;
int val = _lookMarch[key];
if (val != 0)
{
CxFastListNode<Vector2> pi = null;
for (int i = 0; i < 8; i++)
{
Vector2 p;
if ((val & (1 << i)) != 0)
{
if (i == 7 && (val & 1) == 0)
poly.Points.Add(p = new Vector2(x0, Ylerp(y0, y1, x0, v0, v3, f, bin)));
else
{
if (i == 0) p = new Vector2(x0, y0);
else if (i == 2) p = new Vector2(x1, y0);
else if (i == 4) p = new Vector2(x1, y1);
else if (i == 6) p = new Vector2(x0, y1);
else if (i == 1) p = new Vector2(Xlerp(x0, x1, y0, v0, v1, f, bin), y0);
else if (i == 5) p = new Vector2(Xlerp(x0, x1, y1, v3, v2, f, bin), y1);
else if (i == 3) p = new Vector2(x1, Ylerp(y0, y1, x1, v1, v2, f, bin));
else p = new Vector2(x0, Ylerp(y0, y1, x0, v0, v3, f, bin));
pi = poly.Points.Insert(pi, p);
}
poly.Length++;
}
}
//poly.simplify(float.Epsilon,float.Epsilon);
}
return key;
}
/// <summary>
/// add object to list (O(1))
/// </summary>
public CxFastListNode <T> Add(T value)
{
CxFastListNode <T> newNode = new CxFastListNode <T>(value);
if (this._head == null)
{
newNode._next = null;
this._head = newNode;
this._count++;
return(newNode);
}
newNode._next = this._head;
this._head = newNode;
this._count++;
return(newNode);
}
/// <summary>
/// remove object from list, returns true if an element was removed (O(n))
/// </summary>
public bool Remove(T value)
{
CxFastListNode <T> head = _head;
CxFastListNode <T> prev = _head;
EqualityComparer <T> comparer = EqualityComparer <T> .Default;
if (head != null)
{
if (value != null)
{
do
{
// if we are on the value to be removed
if (comparer.Equals(head._elt, value))
{
// then we need to patch the list
// check to see if we are removing the _head
if (head == _head)
{
_head = head._next;
_count--;
return(true);
}
else
{
// were not at the head
prev._next = head._next;
_count--;
return(true);
}
}
// cache the current as the previous for the next go around
prev = head;
head = head._next;
} while (head != null);
}
}
return(false);
}
/// <summary>
/// removes the element pointed to by 'node' with 'prev' being the previous iterator, returning an iterator to the
/// element following that of 'node' (O(1))
/// </summary>
public CxFastListNode <T> Erase(CxFastListNode <T> prev, CxFastListNode <T> node)
{
// cache the node after the node to be removed
CxFastListNode <T> nextNode = node._next;
if (prev != null)
{
prev._next = nextNode;
}
else if (_head != null)
{
_head = _head._next;
}
else
{
return(null);
}
return(nextNode);
}
// Non CxFastList Methods
public CxFastListNode <T> Find(T value)
{
// start at head
CxFastListNode <T> head = _head;
EqualityComparer <T> comparer = EqualityComparer <T> .Default;
if (head != null)
{
if (value != null)
{
do
{
if (comparer.Equals(head._elt, value))
{
return(head);
}
head = head._next;
} while (head != _head);
}
else
{
do
{
if (head._elt == null)
{
return(head);
}
head = head._next;
} while (head != _head);
}
}
return(null);
}
/** Used in polygon composition to composit polygons into scan lines
* Combining polya and polyb into one super-polygon stored in polya.
**/
private static void CombLeft(ref GeomPoly polya, ref GeomPoly polyb)
{
CxFastList <Vector2> ap = polya.Points;
CxFastList <Vector2> bp = polyb.Points;
CxFastListNode <Vector2> ai = ap.Begin();
CxFastListNode <Vector2> bi = bp.Begin();
Vector2 b = bi.Elem();
CxFastListNode <Vector2> prea = null;
while (ai != ap.End())
{
Vector2 a = ai.Elem();
if (VecDsq(a, b) < Settings.Epsilon)
{
//ignore shared vertex if parallel
if (prea != null)
{
Vector2 a0 = prea.Elem();
b = bi.Next().Elem();
Vector2 u = a - a0;
//vec_new(u); vec_sub(a.p.p, a0.p.p, u);
Vector2 v = b - a;
//vec_new(v); vec_sub(b.p.p, a.p.p, v);
float dot = VecCross(u, v);
if (dot * dot < Settings.Epsilon)
{
ap.Erase(prea, ai);
polya.Length--;
ai = prea;
}
}
//insert polyb into polya
bool fst = true;
CxFastListNode <Vector2> preb = null;
while (!bp.Empty())
{
Vector2 bb = bp.Front();
bp.Pop();
if (!fst && !bp.Empty())
{
ai = ap.Insert(ai, bb);
polya.Length++;
preb = ai;
}
fst = false;
}
//ignore shared vertex if parallel
ai = ai.Next();
Vector2 a1 = ai.Elem();
ai = ai.Next();
if (ai == ap.End())
{
ai = ap.Begin();
}
Vector2 a2 = ai.Elem();
Vector2 a00 = preb.Elem();
Vector2 uu = a1 - a00;
//vec_new(u); vec_sub(a1.p, a0.p, u);
Vector2 vv = a2 - a1;
//vec_new(v); vec_sub(a2.p, a1.p, v);
float dot1 = VecCross(uu, vv);
if (dot1 * dot1 < Settings.Epsilon)
{
ap.Erase(preb, preb.Next());
polya.Length--;
}
return;
}
prea = ai;
ai = ai.Next();
}
}
/// <summary>
/// Marching squares over the given domain using the mesh defined via the dimensions
/// (wid,hei) to build a set of polygons such that f(x,y) less than 0, using the given number
/// 'bin' for recursive linear inteprolation along cell boundaries.
///
/// if 'comb' is true, then the polygons will also be composited into larger possible concave
/// polygons.
/// </summary>
/// <param name="domain"></param>
/// <param name="cellWidth"></param>
/// <param name="cellHeight"></param>
/// <param name="f"></param>
/// <param name="lerpCount"></param>
/// <param name="combine"></param>
/// <returns></returns>
public static List <Vertices> DetectSquares(AABB domain, float cellWidth, float cellHeight, sbyte[,] f,
int lerpCount, bool combine)
{
CxFastList <GeomPoly> ret = new CxFastList <GeomPoly>();
List <Vertices> verticesList = new List <Vertices>();
//NOTE: removed assignments as they were not used.
List <GeomPoly> polyList;
GeomPoly gp;
int xn = (int)(domain.Extents.X * 2 / cellWidth);
bool xp = xn == (domain.Extents.X * 2 / cellWidth);
int yn = (int)(domain.Extents.Y * 2 / cellHeight);
bool yp = yn == (domain.Extents.Y * 2 / cellHeight);
if (!xp)
{
xn++;
}
if (!yp)
{
yn++;
}
sbyte[,] fs = new sbyte[xn + 1, yn + 1];
GeomPolyVal[,] ps = new GeomPolyVal[xn + 1, yn + 1];
//populate shared function lookups.
for (int x = 0; x < xn + 1; x++)
{
int x0;
if (x == xn)
{
x0 = (int)domain.UpperBound.X;
}
else
{
x0 = (int)(x * cellWidth + domain.LowerBound.X);
}
for (int y = 0; y < yn + 1; y++)
{
int y0;
if (y == yn)
{
y0 = (int)domain.UpperBound.Y;
}
else
{
y0 = (int)(y * cellHeight + domain.LowerBound.Y);
}
fs[x, y] = f[x0, y0];
}
}
//generate sub-polys and combine to scan lines
for (int y = 0; y < yn; y++)
{
float y0 = y * cellHeight + domain.LowerBound.Y;
float y1;
if (y == yn - 1)
{
y1 = domain.UpperBound.Y;
}
else
{
y1 = y0 + cellHeight;
}
GeomPoly pre = null;
for (int x = 0; x < xn; x++)
{
float x0 = x * cellWidth + domain.LowerBound.X;
float x1;
if (x == xn - 1)
{
x1 = domain.UpperBound.X;
}
else
{
x1 = x0 + cellWidth;
}
gp = new GeomPoly();
int key = MarchSquare(f, fs, ref gp, x, y, x0, y0, x1, y1, lerpCount);
if (gp.Length != 0)
{
if (combine && pre != null && (key & 9) != 0)
{
CombLeft(ref pre, ref gp);
gp = pre;
}
else
{
ret.Add(gp);
}
ps[x, y] = new GeomPolyVal(gp, key);
}
else
{
gp = null;
}
pre = gp;
}
}
if (!combine)
{
polyList = ret.GetListOfElements();
foreach (GeomPoly poly in polyList)
{
verticesList.Add(new Vertices(poly.Points.GetListOfElements()));
}
return(verticesList);
}
//combine scan lines together
for (int y = 1; y < yn; y++)
{
int x = 0;
while (x < xn)
{
GeomPolyVal p = ps[x, y];
//skip along scan line if no polygon exists at this point
if (p == null)
{
x++;
continue;
}
//skip along if current polygon cannot be combined above.
if ((p.Key & 12) == 0)
{
x++;
continue;
}
//skip along if no polygon exists above.
GeomPolyVal u = ps[x, y - 1];
if (u == null)
{
x++;
continue;
}
//skip along if polygon above cannot be combined with.
if ((u.Key & 3) == 0)
{
x++;
continue;
}
float ax = x * cellWidth + domain.LowerBound.X;
float ay = y * cellHeight + domain.LowerBound.Y;
CxFastList <Vector2> bp = p.GeomP.Points;
CxFastList <Vector2> ap = u.GeomP.Points;
//skip if it's already been combined with above polygon
if (u.GeomP == p.GeomP)
{
x++;
continue;
}
//combine above (but disallow the hole thingies
CxFastListNode <Vector2> bi = bp.Begin();
while (Square(bi.Elem().Y - ay) > Settings.Epsilon || bi.Elem().X < ax)
{
bi = bi.Next();
}
//NOTE: Unused
//Vector2 b0 = bi.elem();
Vector2 b1 = bi.Next().Elem();
if (Square(b1.Y - ay) > Settings.Epsilon)
{
x++;
continue;
}
bool brk = true;
CxFastListNode <Vector2> ai = ap.Begin();
while (ai != ap.End())
{
if (VecDsq(ai.Elem(), b1) < Settings.Epsilon)
{
brk = false;
break;
}
ai = ai.Next();
}
if (brk)
{
x++;
continue;
}
CxFastListNode <Vector2> bj = bi.Next().Next();
if (bj == bp.End())
{
bj = bp.Begin();
}
while (bj != bi)
{
ai = ap.Insert(ai, bj.Elem()); // .clone()
bj = bj.Next();
if (bj == bp.End())
{
bj = bp.Begin();
}
u.GeomP.Length++;
}
//u.p.simplify(float.Epsilon,float.Epsilon);
//
ax = x + 1;
while (ax < xn)
{
GeomPolyVal p2 = ps[(int)ax, y];
if (p2 == null || p2.GeomP != p.GeomP)
{
ax++;
continue;
}
p2.GeomP = u.GeomP;
ax++;
}
ax = x - 1;
while (ax >= 0)
{
GeomPolyVal p2 = ps[(int)ax, y];
if (p2 == null || p2.GeomP != p.GeomP)
{
ax--;
continue;
}
p2.GeomP = u.GeomP;
ax--;
}
ret.Remove(p.GeomP);
p.GeomP = u.GeomP;
x = (int)((bi.Next().Elem().X - domain.LowerBound.X) / cellWidth) + 1;
//x++; this was already commented out!
}
}
polyList = ret.GetListOfElements();
foreach (GeomPoly poly in polyList)
{
verticesList.Add(new Vertices(poly.Points.GetListOfElements()));
}
return(verticesList);
}
/** Look-up table to relate polygon key with the vertices that should be used for
* the sub polygon in marching squares
**/
/** Perform a single celled marching square for for the given cell defined by (x0,y0) (x1,y1)
* using the function f for recursive interpolation, given the look-up table 'fs' of
* the values of 'f' at cell vertices with the result to be stored in 'poly' given the actual
* coordinates of 'ax' 'ay' in the marching squares mesh.
**/
private static int MarchSquare(sbyte[,] f, sbyte[,] fs, ref GeomPoly poly, int ax, int ay, GGame.Math.Fix64 x0, GGame.Math.Fix64 y0,
GGame.Math.Fix64 x1, GGame.Math.Fix64 y1, int bin)
{
//key lookup
int key = 0;
sbyte v0 = fs[ax, ay];
if (v0 < 0)
{
key |= 8;
}
sbyte v1 = fs[ax + 1, ay];
if (v1 < 0)
{
key |= 4;
}
sbyte v2 = fs[ax + 1, ay + 1];
if (v2 < 0)
{
key |= 2;
}
sbyte v3 = fs[ax, ay + 1];
if (v3 < 0)
{
key |= 1;
}
int val = _lookMarch[key];
if (val != 0)
{
CxFastListNode <Vector2> pi = null;
for (int i = 0; i < 8; i++)
{
Vector2 p;
if ((val & (1 << i)) != 0)
{
if (i == 7 && (val & 1) == 0)
{
poly.Points.Add(p = new Vector2(x0, Ylerp(y0, y1, x0, v0, v3, f, bin)));
}
else
{
if (i == 0)
{
p = new Vector2(x0, y0);
}
else if (i == 2)
{
p = new Vector2(x1, y0);
}
else if (i == 4)
{
p = new Vector2(x1, y1);
}
else if (i == 6)
{
p = new Vector2(x0, y1);
}
else if (i == 1)
{
p = new Vector2(Xlerp(x0, x1, y0, v0, v1, f, bin), y0);
}
else if (i == 5)
{
p = new Vector2(Xlerp(x0, x1, y1, v3, v2, f, bin), y1);
}
else if (i == 3)
{
p = new Vector2(x1, Ylerp(y0, y1, x1, v1, v2, f, bin));
}
else
{
p = new Vector2(x0, Ylerp(y0, y1, x0, v0, v3, f, bin));
}
pi = poly.Points.Insert(pi, p);
}
poly.Length++;
}
}
//poly.simplify(GGame.Math.Fix64.Epsilon,GGame.Math.Fix64.Epsilon);
}
return(key);
}
/// <summary>
/// removes 'cnt' elements starting at 'cur' with 'pre' being the previous iterator,
/// returning an iterator to the element following those deleted. (O(cnt)).
/// </summary>
public CxFastListNode <T> splice(CxFastListNode <T> pre, CxFastListNode <T> curr, int cnt)
{
throw new NotImplementedException();
}
/** Used in polygon composition to composit polygons into scan lines
* Combining polya and polyb into one super-polygon stored in polya.
**/
private static void combLeft(ref GeomPoly polya, ref GeomPoly polyb)
{
var ap = polya.points;
var bp = polyb.points;
var ai = ap.begin();
var bi = bp.begin();
var b = bi.elem();
CxFastListNode <Vector2> prea = null;
while (ai != ap.end())
{
var a = ai.elem();
if (vec_dsq(a, b) < float.Epsilon)
{
//ignore shared vertex if parallel
if (prea != null)
{
var a0 = prea.elem();
b = bi.next().elem();
Vector2 u = a - a0;
//vec_new(u); vec_sub(a.p.p, a0.p.p, u);
Vector2 v = b - a;
//vec_new(v); vec_sub(b.p.p, a.p.p, v);
var dot = vec_cross(u, v);
if (dot * dot < float.Epsilon)
{
ap.erase(prea, ai);
polya.length--;
ai = prea;
}
}
//insert polyb into polya
var fst = true;
CxFastListNode <Vector2> preb = null;
while (!bp.empty())
{
var bb = bp.front();
bp.pop();
if (!fst && !bp.empty())
{
ai = ap.insert(ai, bb);
polya.length++;
preb = ai;
}
fst = false;
}
//ignore shared vertex if parallel
ai = ai.next();
var a1 = ai.elem();
ai = ai.next(); if (ai == ap.end())
{
ai = ap.begin();
}
var a2 = ai.elem();
var a00 = preb.elem();
Vector2 uu = a1 - a00;
//vec_new(u); vec_sub(a1.p, a0.p, u);
Vector2 vv = a2 - a1;
//vec_new(v); vec_sub(a2.p, a1.p, v);
var dot1 = vec_cross(uu, vv);
if (dot1 * dot1 < float.Epsilon)
{
ap.erase(preb, preb.next());
polya.length--;
}
return;
}
prea = ai;
ai = ai.next();
}
}
/** Perform a single celled marching square for for the given cell defined by (x0,y0) (x1,y1)
* using the function f for recursive interpolation, given the look-up table 'fs' of
* the values of 'f' at cell vertices with the result to be stored in 'poly' given the actual
* coordinates of 'ax' 'ay' in the marching squares mesh.
**/
private static int marchSquare(sbyte[,] f, sbyte[,] fs, ref GeomPoly poly, int ax, int ay, float x0, float y0, float x1, float y1, int bin)
{
//key lookup
var key = 0;
var v0 = fs[ax, ay]; if (v0 < 0)
{
key |= 8;
}
var v1 = fs[ax + 1, ay]; if (v1 < 0)
{
key |= 4;
}
var v2 = fs[ax + 1, ay + 1]; if (v2 < 0)
{
key |= 2;
}
var v3 = fs[ax, ay + 1]; if (v3 < 0)
{
key |= 1;
}
var val = look_march[key];
if (val != 0)
{
CxFastListNode <Vector2> pi = null;
for (int i = 0; i < 8; i++)
{
Vector2 p;
if ((val & (1 << i)) != 0)
{
if (i == 7 && (val & 1) == 0)
{
poly.points.add(p = new Vector2(x0, ylerp(y0, y1, x0, v0, v3, f, bin)));
}
else
{
if (i == 0)
{
p = new Vector2(x0, y0);
}
else if (i == 2)
{
p = new Vector2(x1, y0);
}
else if (i == 4)
{
p = new Vector2(x1, y1);
}
else if (i == 6)
{
p = new Vector2(x0, y1);
}
else if (i == 1)
{
p = new Vector2(xlerp(x0, x1, y0, v0, v1, f, bin), y0);
}
else if (i == 5)
{
p = new Vector2(xlerp(x0, x1, y1, v3, v2, f, bin), y1);
}
else if (i == 3)
{
p = new Vector2(x1, ylerp(y0, y1, x1, v1, v2, f, bin));
}
else
{
p = new Vector2(x0, ylerp(y0, y1, x0, v0, v3, f, bin));
}
pi = poly.points.insert(pi, p);
}
poly.length++;
}
}
//poly.simplify(float.Epsilon,float.Epsilon);
}
return(key);
}
