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