static private Slice2D SliceWithTwoHoles(Polygon2D polygon, Pair2D slice, Polygon2D holeA, Polygon2D holeB) { Slice2D result = Slice2D.Create(null, slice); if (holeA == holeB) { if (Slicer2D.Debug.enabled) { Debug.LogWarning("Slicer2D: Incorrect Split 2: Cannot Split Into Same Hole"); } return(result); } Polygon2D polyA = new Polygon2D(); Polygon2D polyB = new Polygon2D(polygon.pointsList); polyA.AddPoints(Vector2DList.GetListStartingIntersectLine(holeA.pointsList, slice)); polyA.AddPoints(Vector2DList.GetListStartingIntersectLine(holeB.pointsList, slice)); foreach (Polygon2D poly in polygon.holesList) { if (poly != holeA && poly != holeB) { polyB.AddHole(poly); } } polyB.AddHole(polyA); result.AddPolygon(polyB); return(result); }
static private Slice2D SliceWithTwoHoles(Polygon2D polygon, List <Vector2D> slice, List <Vector2D> collisionSlice) { Slice2D result = Slice2D.Create(slice); Polygon2D polyA = new Polygon2D(); Polygon2D polyB = new Polygon2D(polygon.pointsList); Polygon2D holeA = polygon.PointInHole(slice.First()); Polygon2D holeB = polygon.PointInHole(slice.Last()); if (holeA == null || holeB == null) { Slicer2D.Debug.LogError("ERROR Split"); // Shouldn't really happen return(result); } List <Vector2D> pointsA = Vector2DList.GetListStartingIntersectSlice(holeA.pointsList, slice); List <Vector2D> pointsB = Vector2DList.GetListStartingIntersectSlice(holeB.pointsList, slice); polyA.AddPoints(pointsA); if (collisionSlice.Count > 0) { if (Vector2D.Distance(pointsA.Last(), collisionSlice.Last()) < Vector2D.Distance(pointsA.Last(), collisionSlice.First())) { collisionSlice.Reverse(); } polyA.AddPoints(collisionSlice); } polyA.AddPoints(pointsB); if (collisionSlice.Count > 0) { collisionSlice.Reverse(); polyA.AddPoints(collisionSlice); } foreach (Polygon2D poly in polygon.holesList) { if (poly != holeA && poly != holeB) { polyB.AddHole(poly); } } polyB.AddHole(polyA); result.AddPolygon(polyB); result.AddSlice(collisionSlice); return(result); }
static public Slice2D SliceFromOutsideToHole(Polygon2D polygon, Polygon2D holePoly, List <Vector2D> slice, ComplexCollision collisionSlice) { Slice2D result = Slice2D.Create(null, slice); Polygon2D polyA = new Polygon2D(); Polygon2D polyB = new Polygon2D(holePoly.pointsList); polyB.pointsList.Reverse(); List <Vector2D> pointsA = Vector2DList.GetListStartingIntersectSlice(polygon.pointsList, slice); List <Vector2D> pointsB = Vector2DList.GetListStartingIntersectSlice(polyB.pointsList, slice); if (pointsA.Count < 1) { if (Slicer2D.Debug.enabled) { Debug.LogWarning("Slicer2D: Not enough of slice intersections with polygon (SliceWithOneHole)"); } } polyA.AddPoints(pointsA); // pointsA empty if (collisionSlice.GetPointsInside().Count > 0) { if (Vector2D.Distance(pointsA.Last(), collisionSlice.Last()) < Vector2D.Distance(pointsA.Last(), collisionSlice.First())) { collisionSlice.Reverse(); } polyA.AddPoints(collisionSlice.GetPointsInside()); } polyA.AddPoints(pointsB); if (collisionSlice.GetPointsInside().Count > 0) { collisionSlice.Reverse(); polyA.AddPoints(collisionSlice.GetPointsInside()); } foreach (Polygon2D poly in polygon.holesList) // Check for errors? { if (poly != holePoly && polyA.PolyInPoly(poly) == true) { polyA.AddHole(poly); } } result.AddPolygon(polyA); return(result); }
static private Slice2D SliceWithOneHole(Polygon2D polygon, Pair2D slice, Polygon2D holeA, Polygon2D holeB) { Slice2D result = Slice2D.Create(null, slice); if (holeA == holeB) { Polygon2D polyA = new Polygon2D(polygon.pointsList); Polygon2D polyB = new Polygon2D(); Polygon2D polyC = new Polygon2D(); Polygon2D currentPoly = polyB; foreach (Pair2D pair in Pair2D.GetList(holeA.pointsList)) { Vector2D point = Math2D.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) { Polygon2D holePoly = (holeA != null) ? holeA : holeB; if (holePoly != null) { Polygon2D polyA = new Polygon2D(); Polygon2D polyB = new Polygon2D(holePoly.pointsList); polyB.pointsList.Reverse(); polyA.AddPoints(Vector2DList.GetListStartingIntersectLine(polygon.pointsList, slice)); polyA.AddPoints(Vector2DList.GetListStartingIntersectLine(polyB.pointsList, slice)); foreach (Polygon2D poly in polygon.holesList) { if (poly != holePoly) { polyA.AddHole(poly); } } result.AddPolygon(polyA); return(result); } } return(result); }
static private Slice2D SliceWithoutHoles(Polygon2D polygon, List <Vector2D> slice, ComplexCollision collisionSlice) { Slice2D result = Slice2D.Create(null, slice); // Simple non-hole slice Polygon2D polyA = new Polygon2D(); Polygon2D polyB = new Polygon2D(); Polygon2D currentPoly = polyA; List <Vector2D> slices = new List <Vector2D>(collisionSlice.GetPointsInsidePlus()); foreach (Pair2D p in Pair2D.GetList(polygon.pointsList)) { List <Vector2D> intersections = Math2D.GetListLineIntersectSlice(p, slice); if (intersections.Count() > 0) { if (intersections.Count == 2) { Vector2D first = intersections.First(); Vector2D last = intersections.Last(); if (Vector2D.Distance(last, p.A) < Vector2D.Distance(first, p.A)) { first = intersections.Last(); last = intersections.First(); } //currentPoly.AddPoint (first); // Add Inside Points if (collisionSlice.GetPointsInsidePlus().Count > 0) { if (Vector2D.Distance(first, collisionSlice.Last()) < Vector2D.Distance(first, collisionSlice.First())) { collisionSlice.Reverse(); } currentPoly.AddPoints(collisionSlice.GetPointsInsidePlus()); } ///// //currentPoly.AddPoint (last); currentPoly = polyB; if (collisionSlice.GetPointsInsidePlus().Count > 0) { currentPoly.AddPoints(collisionSlice.GetPointsInsidePlus()); } //currentPoly.AddPoint (last); //currentPoly.AddPoint (first); currentPoly = polyA; } if (intersections.Count == 1) { Vector2D intersection = intersections.First(); //currentPoly.AddPoint (intersection); ///// Add Inside Points if (collisionSlice.GetPointsInsidePlus().Count > 0) { if (Vector2D.Distance(intersection, collisionSlice.Last()) < Vector2D.Distance(intersection, collisionSlice.First())) { collisionSlice.Reverse(); } currentPoly.AddPoints(collisionSlice.GetPointsInsidePlus()); } ///// currentPoly = (currentPoly == polyA) ? polyB : polyA; //currentPoly.AddPoint (intersection); } } currentPoly.AddPoint(p.B); } result.AddPolygon(polyA); result.AddPolygon(polyB); foreach (Polygon2D poly in result.GetPolygons()) { foreach (Polygon2D hole in polygon.holesList) { if (poly.PolyInPoly(hole) == true) { poly.AddHole(hole); } } } result.AddSlice(slices); return(result); }
static private Slice2D SliceWithTwoHoles(Polygon2D polygon, List <Vector2D> slice, ComplexCollision collisionSlice) { Slice2D result = Slice2D.Create(null, slice); if (Slicer2D.complexSliceType == Slicer2D.SliceType.Regular) { return(result); } Polygon2D polyA = new Polygon2D(); Polygon2D polyB = new Polygon2D(polygon.pointsList); Polygon2D holeA = polygon.PointInHole(slice.First()); Polygon2D holeB = polygon.PointInHole(slice.Last()); if (holeA == null || holeB == null) { // Shouldn't really happen no more if (Slicer2D.Debug.enabled) { Debug.LogWarning("Slicer: ERROR Split"); } return(result); } List <Vector2D> slices = new List <Vector2D>(collisionSlice.GetPointsInsidePlus()); List <Vector2D> pointsA = Vector2DList.GetListStartingIntersectSlice(holeA.pointsList, slice); List <Vector2D> pointsB = Vector2DList.GetListStartingIntersectSlice(holeB.pointsList, slice); polyA.AddPoints(pointsA); if (collisionSlice.GetPointsInside().Count > 0) { if (Vector2D.Distance(pointsA.Last(), collisionSlice.Last()) < Vector2D.Distance(pointsA.Last(), collisionSlice.First())) { collisionSlice.Reverse(); } polyA.AddPoints(collisionSlice.GetPointsInside()); } polyA.AddPoints(pointsB); if (collisionSlice.GetPointsInside().Count > 0) { collisionSlice.Reverse(); polyA.AddPoints(collisionSlice.GetPointsInside()); } foreach (Polygon2D poly in polygon.holesList) { if (poly != holeA && poly != holeB) { polyB.AddHole(poly); } } polyB.AddHole(polyA); result.AddPolygon(polyB); result.AddSlice(slices); return(result); }
static private Slice2D SliceWithOneHole(Polygon2D polygon, List <Vector2D> slice, ComplexCollision collisionSlice) { Slice2D result = Slice2D.Create(null, slice); Polygon2D holeA = polygon.PointInHole(slice.First()); Polygon2D holeB = polygon.PointInHole(slice.Last()); Polygon2D holePoly = (holeA != null) ? holeA : holeB; if (holePoly == null) { if (Slicer2D.Debug.enabled) { Debug.LogWarning("Slicer2D: This happened when collider had a lot of paths but they were not holes"); } return(result); } List <Vector2D> slices = new List <Vector2D>(collisionSlice.GetPointsInsidePlus()); if (polygon.PointInPoly(slice.First()) == false || polygon.PointInPoly(slice.Last()) == false) { // Slicing Into The Same Hole if (holeA == holeB) { if (Slicer2D.complexSliceType == Slicer2D.SliceType.Regular) { return(result); } if (collisionSlice.polygonCollisionPairs.Count == 1) { Polygon2D slicePoly = new Polygon2D(collisionSlice.GetPointsInsidePlus()); Polygon2D newHole = new Polygon2D(); if (slicePoly.PolyInPoly(holePoly)) { newHole = slicePoly; } else { foreach (Pair2D pair in Pair2D.GetList(holePoly.pointsList)) { newHole.AddPoint(pair.A); if (Vector2D.Distance(pair.A, collisionSlice.Last()) < Vector2D.Distance(pair.A, collisionSlice.First())) { collisionSlice.Reverse(); } if (Math2D.LineIntersectSlice(pair, slice)) { newHole.AddPoints(collisionSlice.GetPoints()); } } } Polygon2D polygonA = new Polygon2D(polygon.pointsList); polygonA.AddHole(newHole); // Adds polygons if they are not in the hole foreach (Polygon2D poly in polygon.holesList) // Check for errors? { if (poly != holePoly && polygonA.PolyInPoly(poly) == true) { polygonA.AddHole(poly); } } if (Slicer2D.complexSliceType == Slicer2D.SliceType.FillSlicedHole) { result.AddPolygon(slicePoly); } result.AddPolygon(polygonA); result.AddSlice(slices); return(result); } else { Polygon2D polyA = new Polygon2D(polygon.pointsList); Polygon2D newHoleA = new Polygon2D(); Polygon2D newHoleB = new Polygon2D(); List <Pair2D> iterateList = Pair2D.GetList(holePoly.pointsList); bool addPoints = false; foreach (Pair2D pair in iterateList) { List <Vector2D> intersect = Math2D.GetListLineIntersectSlice(pair, slice); switch (addPoints) { case false: if (intersect.Count > 0) { addPoints = true; } break; case true: newHoleA.AddPoint(pair.A); if (intersect.Count > 0) { addPoints = false; if (Vector2D.Distance(intersect[0], collisionSlice.Last()) < Vector2D.Distance(intersect[0], collisionSlice.First())) { collisionSlice.Reverse(); } newHoleA.AddPoints(collisionSlice.GetPointsInsidePlus()); } break; } } addPoints = true; foreach (Pair2D pair in iterateList) { List <Vector2D> intersect = Math2D.GetListLineIntersectSlice(pair, slice); switch (addPoints) { case false: if (intersect.Count > 0) { addPoints = true; } break; case true: newHoleB.AddPoint(pair.A); if (intersect.Count > 0) { addPoints = false; if (Vector2D.Distance(intersect[0], collisionSlice.Last()) < Vector2D.Distance(intersect[0], collisionSlice.First())) { collisionSlice.Reverse(); } newHoleB.AddPoints(collisionSlice.GetPointsInsidePlus()); } break; } } if (newHoleB.GetArea() > newHoleA.GetArea()) { Polygon2D tempPolygon = newHoleA; newHoleA = newHoleB; newHoleB = tempPolygon; } polyA.AddHole(newHoleA); if (Slicer2D.complexSliceType == Slicer2D.SliceType.FillSlicedHole) { result.AddPolygon(newHoleB); } // Adds polygons if they are not in the hole foreach (Polygon2D poly in polygon.holesList) // Check for errors? { if (poly != holePoly && polyA.PolyInPoly(poly) == true) { polyA.AddHole(poly); } } result.AddPolygon(polyA); result.AddSlice(slices); return(result); } // Slicing From Outside To Hole } else if (holePoly != null) { Polygon2D polyA = new Polygon2D(); Polygon2D polyB = new Polygon2D(holePoly.pointsList); polyB.pointsList.Reverse(); List <Vector2D> pointsA = Vector2DList.GetListStartingIntersectSlice(polygon.pointsList, slice); List <Vector2D> pointsB = Vector2DList.GetListStartingIntersectSlice(polyB.pointsList, slice); if (pointsA.Count < 1) { if (Slicer2D.Debug.enabled) { Debug.LogWarning("Slicer2D: " + pointsA.Count + " " + polygon.pointsList.Count); } } polyA.AddPoints(pointsA); // pointsA empty if (collisionSlice.GetPointsInside().Count > 0) { if (Vector2D.Distance(pointsA.Last(), collisionSlice.Last()) < Vector2D.Distance(pointsA.Last(), collisionSlice.First())) { collisionSlice.Reverse(); } polyA.AddPoints(collisionSlice.GetPointsInside()); } polyA.AddPoints(pointsB); if (collisionSlice.GetPointsInside().Count > 0) { collisionSlice.Reverse(); polyA.AddPoints(collisionSlice.GetPointsInside()); } foreach (Polygon2D poly in polygon.holesList) // Check for errors? { if (poly != holePoly && polyA.PolyInPoly(poly) == true) { polyA.AddHole(poly); } } result.AddPolygon(polyA); result.AddSlice(slices); return(result); } } return(result); }
static public Slice2D SliceIntoSameHole(Polygon2D polygon, Polygon2D holePoly, List <Vector2D> slice, ComplexCollision collisionSlice) { Slice2D result = Slice2D.Create(null, slice); // Slice Into Same Pair if (collisionSlice.polygonCollisionPairs.Count == 1) { Polygon2D slicePoly = new Polygon2D(collisionSlice.GetPointsInsidePlus()); Polygon2D newHole = new Polygon2D(); if (slicePoly.PolyInPoly(holePoly)) { newHole = slicePoly; } else { foreach (Pair2D pair in Pair2D.GetList(holePoly.pointsList)) { newHole.AddPoint(pair.A); if (Vector2D.Distance(pair.A, collisionSlice.Last()) < Vector2D.Distance(pair.A, collisionSlice.First())) { collisionSlice.Reverse(); } if (Math2D.LineIntersectSlice(pair, slice)) { newHole.AddPoints(collisionSlice.GetPoints()); } } } Polygon2D polygonA = new Polygon2D(polygon.pointsList); polygonA.AddHole(newHole); // Adds polygons if they are not in the hole foreach (Polygon2D poly in polygon.holesList) // Check for errors? { if (poly != holePoly && polygonA.PolyInPoly(poly) == true) { polygonA.AddHole(poly); } } if (Slicer2D.complexSliceType == Slicer2D.SliceType.FillSlicedHole) { result.AddPolygon(slicePoly); } result.AddPolygon(polygonA); return(result); // Slice Into Different Pair } else { Polygon2D polyA = new Polygon2D(polygon.pointsList); Polygon2D newHoleA = new Polygon2D(); Polygon2D newHoleB = new Polygon2D(); List <Pair2D> iterateList = Pair2D.GetList(holePoly.pointsList); bool addPoints = false; foreach (Pair2D pair in iterateList) { List <Vector2D> intersect = Math2D.GetListLineIntersectSlice(pair, slice); switch (addPoints) { case false: if (intersect.Count > 0) { addPoints = true; } break; case true: newHoleA.AddPoint(pair.A); if (intersect.Count > 0) { addPoints = false; if (Vector2D.Distance(intersect[0], collisionSlice.Last()) < Vector2D.Distance(intersect[0], collisionSlice.First())) { collisionSlice.Reverse(); } newHoleA.AddPoints(collisionSlice.GetPointsInsidePlus()); } break; } } addPoints = true; foreach (Pair2D pair in iterateList) { List <Vector2D> intersect = Math2D.GetListLineIntersectSlice(pair, slice); switch (addPoints) { case false: if (intersect.Count > 0) { addPoints = true; } break; case true: newHoleB.AddPoint(pair.A); if (intersect.Count > 0) { addPoints = false; if (Vector2D.Distance(intersect[0], collisionSlice.Last()) < Vector2D.Distance(intersect[0], collisionSlice.First())) { collisionSlice.Reverse(); } newHoleB.AddPoints(collisionSlice.GetPointsInsidePlus()); } break; } } if (newHoleB.GetArea() > newHoleA.GetArea()) { Polygon2D tempPolygon = newHoleA; newHoleA = newHoleB; newHoleB = tempPolygon; } polyA.AddHole(newHoleA); if (Slicer2D.complexSliceType == Slicer2D.SliceType.FillSlicedHole) { result.AddPolygon(newHoleB); } // Adds polygons if they are not in the hole foreach (Polygon2D poly in polygon.holesList) // Check for errors? { if (poly != holePoly && polyA.PolyInPoly(poly) == true) { polyA.AddHole(poly); } } result.AddPolygon(polyA); return(result); } }
static private Merge2D SliceWithoutHoles(Polygon2D polygon, List <Vector2D> slice, MergeCollision mergeCollision) { Merge2D result = Merge2D.Create(slice); // Simple non-hole slice Polygon2D polyA = new Polygon2D(); Polygon2D polyB = new Polygon2D(); Polygon2D currentPoly = polyA; List <Vector2D> slices = new List <Vector2D>(mergeCollision.GetPoints()); foreach (Pair2D p in Pair2D.GetList(polygon.pointsList)) { List <Vector2D> intersections = Math2D.GetListLineIntersectSlice(p, slice); if (intersections.Count() > 0) { if (intersections.Count == 2) { Vector2D first = intersections.First(); Vector2D last = intersections.Last(); if (Vector2D.Distance(last, p.A) < Vector2D.Distance(first, p.A)) { first = intersections.Last(); last = intersections.First(); } // Add Inside Points if (mergeCollision.GetPoints().Count > 0) // InsidePlus { if (Vector2D.Distance(first, mergeCollision.Last()) < Vector2D.Distance(first, mergeCollision.First())) { mergeCollision.Reverse(); } currentPoly.AddPoints(mergeCollision.GetPoints()); // InsidePlus } ///// currentPoly = polyB; if (mergeCollision.GetPoints().Count > 0) // InsidePlus( { currentPoly.AddPoints(mergeCollision.GetPoints()); // InsidePlus } currentPoly = polyA; } if (intersections.Count == 1) { Vector2D intersection = intersections.First(); ///// Add Inside Points if (mergeCollision.GetPoints().Count > 0) //InsidePlus { if (Vector2D.Distance(intersection, mergeCollision.Last()) < Vector2D.Distance(intersection, mergeCollision.First())) { mergeCollision.Reverse(); } currentPoly.AddPoints(mergeCollision.GetPoints()); // InsidePlus } ///// currentPoly = (currentPoly == polyA) ? polyB : polyA; } } currentPoly.AddPoint(p.B); } Polygon2D mainPoly = polyA; if (polyB != null && polyB.GetArea() > polyA.GetArea()) { mainPoly = polyB; } result.AddPolygon(mainPoly); foreach (Polygon2D hole in polygon.holesList) { mainPoly.AddHole(hole); } result.AddSlice(slices); return(result); }
public MergeObject(Polygon2D origin, Polygon2D target) { origin.Normalize(); target.Normalize(); originPolygon = origin; targetPolygon = target; originPointList = new List <Vector2D>(origin.pointsList); targetPointList = new List <Vector2D>(target.pointsList); // Count Intersections int collisionCount = 0; bool intoSameEdge = false; foreach (Pair2D pair in Pair2D.GetList(originPointList)) { List <Vector2D> resultPoints = Math2D.GetListLineIntersectPoly(pair, target); if (resultPoints.Count > 0) { collisionCount += resultPoints.Count; if (resultPoints.Count == 2) { intoSameEdge = true; } } } if (collisionCount == 2) { if (intoSameEdge == true) { } GetStartingPointOrigin(); GetStartingPointTarget(); // Sort Point List originPointList = Vector2DList.GetListStartingPoint(originPointList, originStartingPoint); // targetPointList = Vector2DList.GetListStartingPoint(targetPointList, targetStartingPoint); int Count = 0; foreach (Pair2D pair in Pair2D.GetList(targetPointList)) { List <Vector2D> resultPoints = Math2D.GetListLineIntersectPoly(pair, origin); if (resultPoints.Count > 0) { Count += resultPoints.Count; if (Count > 1) { targetStartingPoint = pair.B; continue; } } } targetPointList = Vector2DList.GetListStartingPoint(targetPointList, targetStartingPoint); // Create Pairs pairsOrigin = Pair2D.GetList(originPointList); pairsTarget = Pair2D.GetList(targetPointList); List <Vector2D> slice = new List <Vector2D>(); bool collided = false; List <Vector2D> sliceEnding = new List <Vector2D>(); foreach (Pair2D pair in pairsTarget) { List <Vector2D> collisions = Math2D.GetListLineIntersectPoly(pair, originPolygon); if (collided == false) { if (collisions.Count > 0) { collided = true; collisions = Vector2DList.GetListSortedToPoint(collisions, pair.B); slice.Add(collisions[0]); if (collisions.Count == 2) { sliceEnding.Add(pair.A); sliceEnding.Add(collisions[1]); } else if (collisions.Count > 2) { Debug.Log("Error"); } //foreach(Vector2D p in collisions) { // slice.Add(p); //} } } else { slice.Add(pair.A); if (collisions.Count > 0) { collisions = Vector2DList.GetListSortedToPoint(collisions, pair.A); foreach (Vector2D p in collisions) { slice.Add(p); } break; } } } foreach (Vector2D p in sliceEnding) { slice.Add(p); } resultPolygon = new Polygon2D(); collided = false; foreach (Pair2D pair in pairsOrigin) { List <Vector2D> points = Math2D.GetListLineIntersectPoly(pair, targetPolygon); if (collided == false) { resultPolygon.AddPoint(pair.A); if (points.Count > 0) { collided = true; resultPolygon.AddPoints(slice); } else { } } else { if (points.Count > 0) { collided = false; } } } } else if (collisionCount == 0) { Debug.Log("No Collisions Detected"); } else { Debug.Log("Incorrect Collision Count: " + collisionCount); } }
static private Slice2D SliceWithOneHole(Polygon2D polygon, List <Vector2D> slice, List <Vector2D> collisionSlice) { Slice2D result = Slice2D.Create(slice); Polygon2D holeA = polygon.PointInHole(slice.First()); Polygon2D holeB = polygon.PointInHole(slice.Last()); Polygon2D 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) { Slicer2D.Debug.LogError("This happened when collider had a lot of paths but they were not holes"); return(result); } List <Vector2D> slice2 = new List <Vector2D> (slice); Polygon2D polyA = new Polygon2D(polygon.pointsList); Polygon2D polyB = new Polygon2D(slice); Polygon2D polyC = new Polygon2D(slice2); // Get First Point - NOT FINISHED WITH INTERSECTION int Add; List <Vector2D> list; List <Pair2D> iterateList = Pair2D.GetList(holeA.pointsList); Add = 0; list = new List <Vector2D> (); foreach (Pair2D pair in iterateList) { List <Vector2D> intersect = Math2D.GetListLineIntersectSlice(pair, slice); if (intersect.Count > 0) { Add += intersect.Count; } if (Add == 1) { list.Add(pair.B); } } if (list.Count > 0) { if (Vector2D.Distance(list.First(), slice.First()) < Vector2D.Distance(list.First(), slice.Last())) { slice.Reverse(); } polyB.AddPoints(list); } Add = 0; list = new List <Vector2D> (); foreach (Pair2D pair in iterateList) { List <Vector2D> intersect = Math2D.GetListLineIntersectSlice(pair, slice2); if (intersect.Count > 0) { Add += intersect.Count; } if (Add == 2) { list.Add(pair.B); } } foreach (Pair2D pair in iterateList) { List <Vector2D> intersect = Math2D.GetListLineIntersectSlice(pair, slice2); if (intersect.Count > 0) { Add += intersect.Count; } if (Add == 2) { list.Add(pair.B); } } if (list.Count > 0) { if (Vector2D.Distance(list.First(), slice2.First()) < Vector2D.Distance(list.First(), slice2.Last())) { slice2.Reverse(); } polyC.AddPoints(list); } if (polyB.GetArea() > polyC.GetArea()) { Polygon2D swap = polyB; polyB = polyC; polyC = swap; } // Add holes to new created polygon foreach (Polygon2D 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 (Polygon2D poly in polygon.holesList) // Check for errors? { if (poly != holeA && polyC.PolyInPoly(poly) == false) { polyA.AddHole(poly); } } result.AddPolygon(polyA); result.AddSlice(collisionSlice); return(result); } else if (holePoly != null) { Polygon2D polyA = new Polygon2D(); Polygon2D polyB = new Polygon2D(holePoly.pointsList); polyB.pointsList.Reverse(); List <Vector2D> pointsA = Vector2DList.GetListStartingIntersectSlice(polygon.pointsList, slice); List <Vector2D> pointsB = Vector2DList.GetListStartingIntersectSlice(polyB.pointsList, slice); if (pointsA.Count < 1) { Slicer2D.Debug.LogError(pointsA.Count + " " + polygon.pointsList.Count); } polyA.AddPoints(pointsA); if (collisionSlice.Count > 0) { // pointsA empty if (Vector2D.Distance(pointsA.Last(), collisionSlice.Last()) < Vector2D.Distance(pointsA.Last(), collisionSlice.First())) { collisionSlice.Reverse(); } polyA.AddPoints(collisionSlice); } polyA.AddPoints(pointsB); if (collisionSlice.Count > 0) { collisionSlice.Reverse(); polyA.AddPoints(collisionSlice); } foreach (Polygon2D poly in polygon.holesList) // Check for errors? { if (poly != holePoly) { polyA.AddHole(poly); } } result.AddPolygon(polyA); result.AddSlice(collisionSlice); return(result); } } return(result); }