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