static public void DrawSlice(List <Vector2f> slice, float z = 0f)
{
foreach (Pair2f p in Pair2f.GetList(slice, false))
{
DrawLine(p.A, p.B, z);
}
}
private void ComplexSlice(List <Vector2f> slice)
{
List <Slice2D> results = Slicer2D.ComplexSliceAll(slice, sliceLayer);
if (addForce == true)
{
foreach (Slice2D id in results)
{
foreach (GameObject gameObject in id.gameObjects)
{
Rigidbody2D rigidBody2D = gameObject.GetComponent <Rigidbody2D> ();
if (rigidBody2D)
{
List <Pair2f> list = Pair2f.GetList(id.collisions);
float forceVal = 1.0f / list.Count;
foreach (Pair2f p in list)
{
float sliceRotation = -Vector2f.Atan2(p.B, p.A);
Vector2 force = new Vector2(Mathf.Cos(sliceRotation) * addForceAmount, Mathf.Sin(sliceRotation) * addForceAmount);
rigidBody2D.AddForceAtPosition(forceVal * force, (p.A.Get() + p.B.Get()) / 2f);
}
}
}
}
}
}
private static void DrawSlice_Smooth_Matrix(List <Vector2f> list, float z)
{
foreach (Pair2f p in Pair2f.GetList(list))
{
DrawLine_Smooth_Matrix(p, z);
}
}
static private Slice2D SlicePolygonInside(Polygon polygon, List <Vector2f> slice) // Create Polygon Inside?
{
Slice2D result = Slice2D.Create();
Polygon newPoly = new Polygon();
bool createPoly = false;
foreach (Pair2f pairA in Pair2f.GetList(slice, false))
{
foreach (Pair2f pairB in Pair2f.GetList(slice, false))
{
Vector2f intersection = MathHelper.GetPointLineIntersectLine(pairA, pairB);
if (intersection != null && (pairA.A != pairB.A && pairA.B != pairB.B && pairA.A != pairB.B && pairA.B != pairB.A))
{
createPoly = !createPoly;
newPoly.AddPoint(intersection);
}
}
if (createPoly == true)
{
newPoly.AddPoint(pairA.B);
}
}
bool inHoles = false;
foreach (Polygon hole in polygon.holesList)
{
if (hole.PolyInPoly(newPoly) == true)
{
inHoles = true;
}
}
if (inHoles == false && newPoly.pointsList.Count > 2 && polygon.PolyInPoly(newPoly) == true)
{
polygon.AddHole(newPoly);
List <Polygon> polys = new List <Polygon> (polygon.holesList);
foreach (Polygon hole in polys)
{
if (newPoly.PolyInPoly(hole) == true)
{
polygon.holesList.Remove(hole);
newPoly.AddHole(hole);
}
}
result.AddPolygon(polygon);
if (Slicer2D.complexSliceType == Slicer2D.SliceType.FillSlicedHole)
{
result.AddPolygon(newPoly);
}
return(result);
}
return(result);
}
static private Slice2D SliceWithoutHoles(Polygon polygon, Pair2f slice)
{
Slice2D result = Slice2D.Create();
if (polygon.LineIntersectHoles(slice).Count > 0)
{
Debug.LogError("Slicer2D: Slice Intersect Holes (Point Slicer?)"); // When does this happen? - Only when simple slicer is set - point slicer!!!
return(result);
}
Polygon polyA = new Polygon();
Polygon polyB = new Polygon();
Polygon currentPoly = polyA;
int collisionCount = 0;
foreach (Pair2f p in Pair2f.GetList(polygon.pointsList))
{
Vector2f intersection = MathHelper.GetPointLineIntersectLine(p, slice);
if (intersection != null)
{
polyA.AddPoint(intersection);
polyB.AddPoint(intersection);
currentPoly = (currentPoly == polyA) ? polyB : polyA;
collisionCount++;
}
currentPoly.AddPoint(p.B);
}
if (collisionCount == 2) // ' Is it concave split?
{
if (polyA.pointsList.Count() >= 3)
{
result.AddPolygon(polyA);
}
if (polyB.pointsList.Count() >= 3)
{
result.AddPolygon(polyB);
}
foreach (Polygon poly in result.polygons)
{
foreach (Polygon hole in polygon.holesList)
{
if (poly.PolyInPoly(hole) == true)
{
poly.AddHole(hole);
}
}
}
return(result);
}
return(result);
}
private static void DrawSlice_Matrix(List <Vector2f> list, float z)
{
foreach (Pair2f p in Pair2f.GetList(list))
{
GL.Vertex3(p.A.GetX(), p.A.GetY(), z);
GL.Vertex3(p.B.GetX(), p.B.GetY(), z);
}
}
public bool IsClockwise()
{
double sum = 0;
foreach (Pair2f id in Pair2f.GetList(pointsList))
{
sum += (id.B.GetX() - id.A.GetX()) * (id.B.GetY() + id.A.GetY());
}
return(sum > 0);
}
public static bool LineIntersectPoly(Pair2f line, List <Vector2f> poly)
{
foreach (Pair2f b in Pair2f.GetList(poly))
{
if (LineIntersectLine(line, b))
{
return(true);
}
}
return(false);
}
public static List <Vector2f> GetListLineIntersectSlice(Pair2f pair, List <Vector2f> slice)
{
List <Vector2f> resultList = new List <Vector2f> ();
foreach (Pair2f id in Pair2f.GetList(slice, false))
{
Vector2f result = GetPointLineIntersectLine(id, pair);
if (result != null)
{
resultList.Add(result);
}
}
return(resultList);
}
public static List <Vector2f> GetListPolyIntersectSlice(List <Vector2f> pointsList, Pair2f slice)
{
List <Vector2f> resultList = new List <Vector2f> ();
foreach (Pair2f id in Pair2f.GetList(pointsList))
{
Vector2f result = GetPointLineIntersectLine(id, slice);
if (result != null)
{
resultList.Add(result);
}
}
return(resultList);
}
// Getting List is Slower
public static List <Vector2f> GetListLineIntersectPoly(Pair2f line, List <Vector2f> poly)
{
List <Vector2f> result = new List <Vector2f>();
foreach (Pair2f b in Pair2f.GetList(poly))
{
Vector2f intersection = GetPointLineIntersectLine(line, b);
if (intersection != null)
{
result.Add(intersection);
}
}
return(result);
}
public static bool SliceIntersectPoly(List <Vector2f> slice, List <Vector2f> polyB)
{
foreach (Pair2f a in Pair2f.GetList(slice, false))
{
foreach (Pair2f b in Pair2f.GetList(polyB))
{
if (LineIntersectLine(a, b))
{
return(true);
}
}
}
return(false);
}
public float GetArea()
{
float area = 0f;
foreach (Pair2f id in Pair2f.GetList(pointsList))
{
area += ((id.B.GetX() - id.A.GetX()) * (id.B.GetY() + id.A.GetY())) / 2.0f;
}
foreach (Polygon p in holesList)
{
area -= p.GetArea();
}
return(Mathf.Abs(area));
}
public static bool PolyInPoly(List <Vector2f> polyIn, List <Vector2f> poly)
{
foreach (Pair2f p in Pair2f.GetList(poly))
{
if (PointInPoly(p.A, polyIn) == false)
{
return(false);
}
}
if (PolyIntersectPoly(polyIn, poly) == true)
{
return(false);
}
return(true);
}
public static bool SliceIntersectItself(List <Vector2f> slice)
{
foreach (Pair2f pairA in Pair2f.GetList(slice, true))
{
foreach (Pair2f pairB in Pair2f.GetList(slice, true))
{
if (MathHelper.GetPointLineIntersectLine(pairA, pairB) != null)
{
if (pairA.A != pairB.A && pairA.B != pairB.B && pairA.A != pairB.B && pairA.B != pairB.A)
{
return(true);
}
}
}
}
return(false);
}
static public void DrawPolygon(Polygon poly, float z = 0f)
{
Check();
if (smooth)
{
GL.PushMatrix();
lineMaterial.SetPass(0);
GL.Begin(GL.QUADS);
DrawSlice_Smooth_Matrix(poly.pointsList, z);
GL.End();
GL.PopMatrix();
GL.PushMatrix();
lineEndMaterial.SetPass(0);
GL.Begin(GL.QUADS);
foreach (Pair2f p in Pair2f.GetList(poly.pointsList))
{
DrawLineEnd_Smooth_Matrix(p, z);
}
GL.End();
GL.PopMatrix();
}
else
{
GL.PushMatrix();
defaultMaterial.SetPass(0);
GL.Begin(GL.LINES);
GL.Color(setColor);
DrawSlice_Matrix(poly.pointsList, z);
GL.End();
GL.PopMatrix();
}
foreach (Polygon p in poly.holesList)
{
DrawPolygon(p, z);
}
}
public static bool PointInPoly(Vector2f point, List <Vector2f> xy)
{
if (xy.Count < 3)
{
return(false);
}
int total = 0;
int diff = 0;
foreach (Pair2f id in Pair2f.GetList(xy))
{
diff = (GetQuad(point, id.A) - GetQuad(point, id.B));
switch (diff)
{
case -2:
case 2:
if ((id.B.GetX() - (((id.B.GetY() - point.GetY()) * (id.A.GetX() - id.B.GetX())) / (id.A.GetY() - id.B.GetY()))) < point.GetX())
{
diff = -diff;
}
break;
case 3:
diff = -1;
break;
case -3:
diff = 1;
break;
default:
break;
}
total += diff;
}
return(Mathf.Abs(total) == 4);
}
private void ComplexSlice(List <Vector2f> slice)
{
List <Slice2D> results = Slicer2D.ComplexSliceAll(slice, null);
if (addForce == true)
{
foreach (Slice2D id in results)
{
foreach (GameObject gameObject in id.gameObjects)
{
Rigidbody2D rigidBody2D = gameObject.GetComponent <Rigidbody2D> ();
if (rigidBody2D)
{
foreach (Pair2f p in Pair2f.GetList(id.collisions))
{
float sliceRotation = Vector2f.Atan2(p.B, p.A);
rigidBody2D.AddForceAtPosition(new Vector2(Mathf.Cos(sliceRotation) * addForceAmount, Mathf.Sin(sliceRotation) * addForceAmount), (p.A.Get() + p.B.Get()) / 2f);
}
}
}
}
}
}
/// <summary>
/// Return a list which starts with first interesction with given line
/// </summary>
public static List <Vector2f> GetListStartingIntersectLine(List <Vector2f> pointsList, Pair2f line)
{
List <Vector2f> result = new List <Vector2f> ();
bool start = false;
foreach (Pair2f p in Pair2f.GetList(pointsList))
{
Vector2f r = MathHelper.GetPointLineIntersectLine(p, line);
if (start == true)
{
result.Add(p.A);
}
if (r != null)
{
result.Add(r);
start = true;
}
}
foreach (Pair2f p in Pair2f.GetList(pointsList))
{
Vector2f r = MathHelper.GetPointLineIntersectLine(p, line);
if (start == true)
{
result.Add(p.A);
}
if (r != null)
{
result.Add(r);
start = false;
}
}
return(result);
}
// Might Break (Only for 2 collisions)
/// <summary>
/// Return a list which starts with first interesction with given slice
/// </summary>
public static List <Vector2f> GetListStartingIntersectSlice(List <Vector2f> pointsList, List <Vector2f> slice)
{
List <Vector2f> result = new List <Vector2f> ();
bool start = false;
foreach (Pair2f p in Pair2f.GetList(pointsList))
{
List <Vector2f> r = MathHelper.GetListLineIntersectSlice(p, slice);
if (start == true)
{
result.Add(p.A);
}
if (r.Count > 0)
{
result.Add(r.First());
start = true;
}
}
foreach (Pair2f p in Pair2f.GetList(pointsList))
{
List <Vector2f> r = MathHelper.GetListLineIntersectSlice(p, slice);
if (start == true)
{
result.Add(p.A);
}
if (r.Count > 0)
{
result.Add(r.First());
start = false;
}
}
return(result);
}
//if (slice.Count == 2) return(PolygonSimpleSlicer.SplitLineConcave (polygon, new Pair2f (slice.First (), slice.Last ())));
static private Slice2D SingleSlice(Polygon polygon, List <Vector2f> slice)
{
Slice2D result = Slice2D.Create();
if (polygon.PointInPoly(slice.First()) == true || polygon.PointInPoly(slice.Last()) == true)
{
return(result);
}
slice = new List <Vector2f> (slice);
List <Vector2f> collisionSlice = new List <Vector2f> ();
int collisionCount = 0;
bool enterCollision = false;
// Generate correct intersected slice
foreach (Pair2f pair in Pair2f.GetList(slice, false))
{
List <Vector2f> intersections = polygon.GetListSliceIntersectPoly(pair);
if (intersections.Count > 0)
{
if (intersections.Count == 1)
{
collisionCount += 1;
enterCollision = !enterCollision;
}
if (intersections.Count == 2)
{
collisionCount += intersections.Count; // Check if it's okay
}
if (intersections.Count > 2)
{
//Debug.LogError ("Slicer2D: Unexpected Error 2"); // When this happens?
return(result);
}
}
if (enterCollision == true)
{
collisionSlice.Add(pair.B);
}
}
List <Polygon> intersectHoles = polygon.SliceIntersectHoles(slice);
switch (intersectHoles.Count)
{
case 0:
if (collisionCount == 2)
{
return(SliceWithoutHoles(polygon, slice, collisionSlice));
}
break;
case 1:
return(SliceWithOneHole(polygon, slice, collisionSlice));
case 2:
return(SliceWithTwoHoles(polygon, slice, collisionSlice));
default:
break;
}
return(result);
}
static public void DrawStrippedLine(List <Vector2f> pointsList, float minVertsDistance, float z = 0f, bool full = false, Vector2f offset = null)
{
if (offset == null)
{
offset = new Vector2f(0, 0);
}
Vector2f vA = null, vB = null;
if (setBorder == true)
{
Color tmcColor = setColor;
float tmpWidth = lineWidth;
GL.PushMatrix();
SetColor(Color.black);
lineMaterial.SetPass(0);
GL.Begin(GL.QUADS);
lineWidth = 2f * tmpWidth;
foreach (Pair2f id in Pair2f.GetList(pointsList, full))
{
vA = new Vector2f(id.A.Get() + offset.Get());
vB = new Vector2f(id.B.Get() + offset.Get());
vA.Push(Vector2f.Atan2(id.A, id.B), -minVertsDistance / 4);
vB.Push(Vector2f.Atan2(id.A, id.B), minVertsDistance / 4);
DrawLine_Smooth_Matrix(new Pair2f(vA, vB), z);
}
GL.End();
GL.PopMatrix();
GL.PushMatrix();
SetColor(Color.black);
lineEndMaterial.SetPass(0);
GL.Begin(GL.QUADS);
lineWidth = 2f * tmpWidth;
foreach (Pair2f id in Pair2f.GetList(pointsList, full))
{
vA = new Vector2f(id.A.Get() + offset.Get());
vB = new Vector2f(id.B.Get() + offset.Get());
vA.Push(Vector2f.Atan2(id.A, id.B), -minVertsDistance / 4);
vB.Push(Vector2f.Atan2(id.A, id.B), minVertsDistance / 4);
DrawLineEnd_Smooth_Matrix(new Pair2f(vA, vB), z);
}
GL.End();
GL.PopMatrix();
SetColor(tmcColor);
lineWidth = tmpWidth;
}
GL.PushMatrix();
lineMaterial.SetPass(0);
GL.Begin(GL.QUADS);
foreach (Pair2f id in Pair2f.GetList(pointsList, full))
{
vA = new Vector2f(id.A.Get() + offset.Get());
vB = new Vector2f(id.B.Get() + offset.Get());
vA.Push(Vector2f.Atan2(id.A, id.B), -minVertsDistance / 4);
vB.Push(Vector2f.Atan2(id.A, id.B), minVertsDistance / 4);
DrawLine_Smooth_Matrix(new Pair2f(vA, vB), z);
}
GL.End();
GL.PopMatrix();
}
static private Slice2D SliceWithOneHole(Polygon polygon, List <Vector2f> slice, List <Vector2f> collisionSlice)
{
Slice2D result = Slice2D.Create();
Polygon holeA = polygon.PointInHole(slice.First());
Polygon holeB = polygon.PointInHole(slice.Last());
Polygon holePoly = (holeA != null) ? holeA : holeB;
if (polygon.PointInPoly(slice.First()) == false || polygon.PointInPoly(slice.Last()) == false)
{
if (holeA == holeB)
{
if (Slicer2D.complexSliceType == Slicer2D.SliceType.Regular)
{
return(result);
}
if (holeA == null)
{
Debug.LogError("Slicer2D: This happened when collider had a lot of paths but they were not holes");
return(result);
}
List <Vector2f> slice2 = new List <Vector2f> (slice);
Polygon polyA = new Polygon(polygon.pointsList);
Polygon polyB = new Polygon(slice);
Polygon polyC = new Polygon(slice2);
// Get First Point - NOT FINISHED WITH INTERSECTION
int Add;
List <Vector2f> list;
List <Pair2f> iterateList = Pair2f.GetList(holeA.pointsList);
Add = 0;
list = new List <Vector2f> ();
foreach (Pair2f pair in iterateList)
{
List <Vector2f> intersect = MathHelper.GetListLineIntersectSlice(pair, slice);
if (intersect.Count > 0)
{
Add += intersect.Count;
}
if (Add == 1)
{
list.Add(pair.B);
}
}
if (list.Count > 0)
{
if (Vector2f.Distance(list.First(), slice.First()) < Vector2f.Distance(list.First(), slice.Last()))
{
slice.Reverse();
}
polyB.AddPoints(list);
}
Add = 0;
list = new List <Vector2f> ();
foreach (Pair2f pair in iterateList)
{
List <Vector2f> intersect = MathHelper.GetListLineIntersectSlice(pair, slice2);
if (intersect.Count > 0)
{
Add += intersect.Count;
}
if (Add == 2)
{
list.Add(pair.B);
}
}
foreach (Pair2f pair in iterateList)
{
List <Vector2f> intersect = MathHelper.GetListLineIntersectSlice(pair, slice2);
if (intersect.Count > 0)
{
Add += intersect.Count;
}
if (Add == 2)
{
list.Add(pair.B);
}
}
if (list.Count > 0)
{
if (Vector2f.Distance(list.First(), slice2.First()) < Vector2f.Distance(list.First(), slice2.Last()))
{
slice2.Reverse();
}
polyC.AddPoints(list);
}
if (polyB.GetArea() > polyC.GetArea())
{
Polygon swap = polyB;
polyB = polyC;
polyC = swap;
}
// Add holes to new created polygon
foreach (Polygon poly in polygon.holesList)
{
if (poly != holeA && polyB.PolyInPoly(poly) == true)
{
polyB.AddHole(poly);
}
}
if (Slicer2D.complexSliceType == Slicer2D.SliceType.FillSlicedHole)
{
result.AddPolygon(polyB);
}
polyA.AddHole(polyC);
// Adds polygons if they are not in the hole
foreach (Polygon poly in polygon.holesList) // Check for errors?
{
if (poly != holeA && polyC.PolyInPoly(poly) == false)
{
polyA.AddHole(poly);
}
}
result.AddPolygon(polyA);
return(result);
}
else if (holePoly != null)
{
Polygon polyA = new Polygon();
Polygon polyB = new Polygon(holePoly.pointsList);
polyB.pointsList.Reverse();
List <Vector2f> pointsA = VectorList2f.GetListStartingIntersectSlice(polygon.pointsList, slice);
List <Vector2f> pointsB = VectorList2f.GetListStartingIntersectSlice(polyB.pointsList, slice);
if (pointsA.Count < 1)
{
Debug.LogError("Slicer2D: " + pointsA.Count + " " + polygon.pointsList.Count);
}
polyA.AddPoints(pointsA);
if (collisionSlice.Count > 0)
{
// pointsA empty
if (Vector2f.Distance(pointsA.Last(), collisionSlice.Last()) < Vector2f.Distance(pointsA.Last(), collisionSlice.First()))
{
collisionSlice.Reverse();
}
polyA.AddPoints(collisionSlice);
}
polyA.AddPoints(pointsB);
if (collisionSlice.Count > 0)
{
collisionSlice.Reverse();
polyA.AddPoints(collisionSlice);
}
foreach (Polygon poly in polygon.holesList) // Check for errors?
{
if (poly != holePoly)
{
polyA.AddHole(poly);
}
}
result.AddPolygon(polyA);
return(result);
}
}
return(result);
}
// Linear Slice
static public Slice2D Slice(Polygon polygon, Pair2f slice)
{
Slice2D result = Slice2D.Create();
// Normalize into clockwise
polygon.Normalize();
// Getting the list of intersections
List <Vector2f> intersections = polygon.GetListSliceIntersectPoly(slice);
// Sorting intersections from one point
intersections = VectorList2f.GetListSortedToPoint(intersections, slice.A);
if (intersections.Count < 2)
{
return(result);
}
List <Pair2f> collisionList = new List <Pair2f>();
// Dividing intersections into single slices - This method doesn't look like very reliable!!!
// Optimize this (polygon.PointInPoly) line // Fix this nonsense!!!
foreach (Pair2f p in Pair2f.GetList(intersections, false))
{
if (polygon.PointInPoly(new Vector2f((p.B.GetX() + p.A.GetX()) / 2, (p.B.GetY() + p.A.GetY()) / 2)) == true)
{
collisionList.Add(p);
intersections.Remove(p.A);
intersections.Remove(p.B);
}
}
result.AddPolygon(polygon);
// Slice line points generated from intersections list
foreach (Pair2f id in collisionList)
{
result.AddCollision(id.A);
result.AddCollision(id.B);
Vector2f vec0 = new Vector2f(id.A);
Vector2f vec1 = new Vector2f(id.B);
float rot = Vector2f.Atan2(vec0, vec1);
// Slightly pushing slice line so it intersect in all cases
vec0.Push(rot, precision);
vec1.Push(rot, -precision);
// For each in polygons list attempt convex split
foreach (Polygon poly in (new List <Polygon>(result.polygons)))
{
Slice2D resultList = SingleSlice(poly, new Pair2f(vec0, vec1));
if (resultList.polygons.Count > 0)
{
foreach (Polygon i in resultList.polygons)
{
result.AddPolygon(i);
}
// If it's possible to perform splice, remove currently sliced polygon from result list
result.RemovePolygon(poly);
}
}
}
result.RemovePolygon(polygon);
return(result);
}
static private Slice2D SliceWithOneHole(Polygon polygon, Pair2f slice, Polygon holeA, Polygon holeB)
{
Slice2D result = Slice2D.Create();
if (holeA == holeB)
{
Polygon polyA = new Polygon(polygon.pointsList);
Polygon polyB = new Polygon();
Polygon polyC = new Polygon();
Polygon currentPoly = polyB;
foreach (Pair2f pair in Pair2f.GetList(holeA.pointsList))
{
Vector2f point = MathHelper.GetPointLineIntersectLine(slice, pair);
if (point != null)
{
polyB.AddPoint(point);
polyC.AddPoint(point);
currentPoly = (currentPoly == polyB) ? polyC : polyB;
}
currentPoly.AddPoint(pair.B);
}
if (polyB.pointsList.Count > 2 && polyC.pointsList.Count > 2)
{
if (polyB.GetArea() > polyC.GetArea())
{
polyA.AddHole(polyB);
result.AddPolygon(polyC);
}
else
{
result.AddPolygon(polyB);
polyA.AddHole(polyC);
}
result.AddPolygon(polyA);
}
return(result);
// Cross From Side To Polygon
}
else if (polygon.PointInPoly(slice.A) == false || polygon.PointInPoly(slice.B) == false)
{
Polygon holePoly = (holeA != null) ? holeA : holeB;
if (holePoly != null)
{
Polygon polyA = new Polygon();
Polygon polyB = new Polygon(holePoly.pointsList);
polyB.pointsList.Reverse();
polyA.AddPoints(VectorList2f.GetListStartingIntersectLine(polygon.pointsList, slice));
polyA.AddPoints(VectorList2f.GetListStartingIntersectLine(polyB.pointsList, slice));
foreach (Polygon poly in polygon.holesList)
{
if (poly != holePoly)
{
polyA.AddHole(poly);
}
}
result.AddPolygon(polyA);
return(result);
}
}
return(result);
}
static private Slice2D SliceWithoutHoles(Polygon polygon, List <Vector2f> slice, List <Vector2f> collisionSlice)
{
Slice2D result = Slice2D.Create();
// Simple non-hole slice
Polygon polyA = new Polygon();
Polygon polyB = new Polygon();
Polygon currentPoly = polyA;
foreach (Pair2f p in Pair2f.GetList(polygon.pointsList))
{
List <Vector2f> intersections = MathHelper.GetListLineIntersectSlice(p, slice);
Vector2f intersection = null;
if (intersections.Count() > 0)
{
intersection = intersections.First();
}
if (intersections.Count > 0) // Only if 1 or 2
{
if (intersections.Count == 2)
{
Vector2f first = intersections.First();
Vector2f last = intersections.Last();
if (Vector2f.Distance(last, p.A) < Vector2f.Distance(first, p.A))
{
first = intersections.Last();
last = intersections.First();
}
currentPoly.AddPoint(first);
if (collisionSlice.Count > 0)
{
if (Vector2f.Distance(first, collisionSlice.Last()) < Vector2f.Distance(first, collisionSlice.First()))
{
collisionSlice.Reverse();
}
currentPoly.AddPoints(collisionSlice);
}
currentPoly.AddPoint(last);
currentPoly.AddPoint(p.B);
currentPoly = polyB;
if (collisionSlice.Count > 0)
{
currentPoly.AddPoints(collisionSlice);
}
currentPoly.AddPoint(last);
currentPoly.AddPoint(first);
currentPoly = polyA;
}
if (intersections.Count == 1)
{
currentPoly.AddPoint(intersection);
if (collisionSlice.Count > 0)
{
if (Vector2f.Distance(intersection, collisionSlice.Last()) < Vector2f.Distance(intersection, collisionSlice.First()))
{
collisionSlice.Reverse();
}
currentPoly.AddPoints(collisionSlice);
}
currentPoly = (currentPoly == polyA) ? polyB : polyA;
currentPoly.AddPoint(intersection);
}
}
currentPoly.AddPoint(p.B);
}
result.AddPolygon(polyA);
result.AddPolygon(polyB);
foreach (Polygon poly in result.polygons)
{
foreach (Polygon hole in polygon.holesList)
{
if (poly.PolyInPoly(hole) == true)
{
poly.AddHole(hole);
}
}
}
return(result);
}
static public Slice2D Slice(Polygon polygon, List <Vector2f> slice)
{
Slice2D result = Slice2D.Create();
if (slice.Count < 2)
{
return(result);
}
// Normalize into clockwise
polygon.Normalize();
if (Slicer2D.complexSliceType != Slicer2D.SliceType.Regular)
{
result = SlicePolygonInside(polygon, slice);
if (result.polygons.Count > 0)
{
return(result);
}
}
// Optimization (holes?)
// if (polygon.SliceIntersectPoly (slice) == false)
// return(result);
List <List <Vector2f> > slices = new List <List <Vector2f> >();
bool entered = polygon.PointInPoly(slice.First());
List <Vector2f> currentSlice = new List <Vector2f> ();
foreach (Pair2f pair in Pair2f.GetList(slice, false))
{
List <Vector2f> stackList = polygon.GetListSliceIntersectPoly(pair);
stackList = VectorList2f.GetListSortedToPoint(stackList, pair.A);
foreach (Vector2f id in stackList)
{
if (entered == true)
{
currentSlice.Add(id);
slices.Add(currentSlice);
}
else
{
currentSlice = new List <Vector2f> ();
currentSlice.Add(id);
}
entered = !entered;
}
if (entered == true)
{
currentSlice.Add(pair.B);
}
}
// Adjusting split lines before performing convex split
result.AddPolygon(polygon);
foreach (List <Vector2f> id in slices)
{
if (id.Count > 1)
{
foreach (Vector2f p in id)
{
result.AddCollision(p);
}
// Sclice line points generated from intersections list
Vector2f vec0 = id.First();
vec0.Push(Vector2f.Atan2(vec0, id[1]), precision);
Vector2f vec1 = id.Last();
vec1.Push(Vector2f.Atan2(vec1, id[id.Count - 2]), precision);
// For each in polygons list attempt convex split
List <Polygon> temp = new List <Polygon>(result.polygons); // necessary?
foreach (Polygon poly in temp)
{
Slice2D resultList = SingleSlice(poly, id);
if (resultList.polygons.Count > 0)
{
foreach (Polygon i in resultList.polygons)
{
result.AddPolygon(i);
}
// If it's possible to perform convex split, remove parent polygon from result list
result.RemovePolygon(poly);
}
}
}
}
result.RemovePolygon(polygon);
return(result);
}