static public Polygon2D CreateFromRect(Vector2 size)
{
Polygon2D polygon = new Polygon2D();
polygon.AddPoint(-size.x, -size.y);
polygon.AddPoint(size.x, -size.y);
polygon.AddPoint(size.x, size.y);
polygon.AddPoint(-size.x, size.y);
return(polygon);
}
static public Polygon2D CreateFromBoxCollider(BoxCollider2D boxCollider)
{
Polygon2D newPolygon = new Polygon2D();
Vector2 size = new Vector2(boxCollider.size.x / 2, boxCollider.size.y / 2);
newPolygon.AddPoint(new Vector2(-size.x, -size.y) + boxCollider.offset);
newPolygon.AddPoint(new Vector2(-size.x, size.y) + boxCollider.offset);
newPolygon.AddPoint(new Vector2(size.x, size.y) + boxCollider.offset);
newPolygon.AddPoint(new Vector2(size.x, -size.y) + boxCollider.offset);
return(newPolygon);
}
public Polygon2D ToWorldSpace(Transform transform)
{
Polygon2D newPolygon = new Polygon2D();
for (int i = 0; i < pointsList.Count; i++)
{
newPolygon.AddPoint(transform.TransformPoint(pointsList[i].ToVector2()));
}
for (int i = 0; i < holesList.Count; i++)
{
newPolygon.AddHole(holesList[i].ToWorldSpace(transform));
}
return(newPolygon);
}
public Polygon2D ToLocalSpace(Transform transform)
{
Polygon2D newPolygon = new Polygon2D();
foreach (Vector2D id in pointsList)
{
newPolygon.AddPoint(transform.InverseTransformPoint(id.ToVector2()));
}
foreach (Polygon2D p in holesList)
{
newPolygon.AddHole(p.ToLocalSpace(transform));
}
return(newPolygon);
}
static public Polygon2D CreateFromEdgeCollider(EdgeCollider2D edgeCollider)
{
Polygon2D newPolygon = new Polygon2D();
if (edgeCollider != null)
{
int count = edgeCollider.points.Length;
for (int i = 0; i < count - 1; i++)
{
Vector2 p = edgeCollider.points[i];
newPolygon.AddPoint(p + edgeCollider.offset);
}
//newPolygon.AddPoint (edgeCollider.points[0] + edgeCollider.offset);
}
return(newPolygon);
}
// ToTransform?
public Polygon2D ToRotation(float rotation, Vector2D center = null)
{
Polygon2D newPolygon = new Polygon2D();
if (center == null)
{
center = new Vector2D(Vector2.zero);
}
foreach (Vector2D pos in pointsList)
{
float dist = (float)Vector2D.Distance(pos, center);
float rot = (float)Vector2D.Atan2(pos, center) + rotation;
newPolygon.AddPoint((float)center.x + Mathf.Cos(rot) * dist, (float)center.y + Mathf.Sin(rot) * dist);
}
return(newPolygon);
}
static public Polygon2D CreateFromCircleCollider(CircleCollider2D circleCollider, int pointsCount = -1)
{
if (pointsCount < 1)
{
pointsCount = defaultCircleVerticesCount;
}
Polygon2D newPolygon = new Polygon2D();
float size = circleCollider.radius;
float i = 0;
while (i < 360)
{
newPolygon.AddPoint(new Vector2(Mathf.Cos(i * Mathf.Deg2Rad) * size, Mathf.Sin(i * Mathf.Deg2Rad) * size) + circleCollider.offset);
i += 360f / (float)pointsCount;
}
return(newPolygon);
}
static public List <Polygon2D> CreateFromPolygonColliderToLocalSpace(PolygonCollider2D collider)
{
List <Polygon2D> result = new List <Polygon2D>();
if (collider != null && collider.pathCount > 0)
{
Polygon2D newPolygon = new Polygon2D();
Vector2[] pointList = collider.GetPath(0);
for (int x = 0; x < pointList.Length; x++)
{
newPolygon.AddPoint(pointList[x] + collider.offset);
}
result.Add(newPolygon);
for (int i = 1; i < collider.pathCount; i++)
{
Polygon2D hole = new Polygon2D();
pointList = collider.GetPath(i);
for (int x = 0; x < pointList.Length; x++)
{
hole.AddPoint(pointList[x] + collider.offset);
}
if (newPolygon.PolyInPoly(hole) == true)
{
newPolygon.AddHole(hole);
}
else
{
result.Add(hole);
}
}
}
return(result);
}
// Get List Of Polygons from Collider (Usually Used Before Creating Slicer2D Object)
static public List <Polygon2D> CreateFromPolygonColliderToWorldSpace(PolygonCollider2D collider)
{
List <Polygon2D> result = new List <Polygon2D> ();
if (collider != null && collider.pathCount > 0)
{
Polygon2D newPolygon = new Polygon2D();
foreach (Vector2 p in collider.GetPath(0))
{
newPolygon.AddPoint(p + collider.offset);
}
newPolygon = newPolygon.ToWorldSpace(collider.transform);
result.Add(newPolygon);
for (int i = 1; i < collider.pathCount; i++)
{
Polygon2D hole = new Polygon2D();
foreach (Vector2 p in collider.GetPath(i))
{
hole.AddPoint(p + collider.offset);
}
hole = hole.ToWorldSpace(collider.transform);
if (newPolygon.PolyInPoly(hole) == true)
{
newPolygon.AddHole(hole);
}
else
{
result.Add(hole);
}
}
}
return(result);
}
static public List <Vector2D> Get(Polygon2D polygon, float multiplier = 1f)
{
Polygon2D newPolygon = new Polygon2D();
polygon.Normalize();
Vector2D result;
double rotA, rotC;
Vector2D pB;
for (int i = 0; i < polygon.pointsList.Count; i++)
{
pB = polygon.pointsList[i];
int indexB = polygon.pointsList.IndexOf(pB);
int indexA = (indexB - 1);
if (indexA < 0)
{
indexA += polygon.pointsList.Count;
}
int indexC = (indexB + 1);
if (indexC >= polygon.pointsList.Count)
{
indexC -= polygon.pointsList.Count;
}
pair.A = polygon.pointsList[indexA];
pair.B = pB;
pair.C = polygon.pointsList[indexC];
rotA = Vector2D.Atan2(pair.B, pair.A);
rotC = Vector2D.Atan2(pair.B, pair.C);
pairA.x = pair.A.x;
pairA.y = pair.A.y;
pairA.Push(rotA - Mathf.PI / 2, precision * multiplier);
pairC.x = pair.C.x;
pairC.y = pair.C.y;
pairC.Push(rotC + Mathf.PI / 2, precision * multiplier);
vecA.x = pair.B.x;
vecA.y = pair.B.y;
vecA.Push(rotA - Mathf.PI / 2, precision * multiplier);
vecA.Push(rotA, 100f);
vecC.x = pair.B.x;
vecC.y = pair.B.y;
vecC.Push(rotC + Mathf.PI / 2, precision * multiplier);
vecC.Push(rotC, 100f);
pair0.A = pairA;
pair0.B = vecA;
pair1.A = pairC;
pair1.B = vecC;
result = Math2D.GetPointLineIntersectLine(pair0, pair1);
if (result != null)
{
newPolygon.AddPoint(result);
}
}
return(newPolygon.pointsList);
}
// Capsule Missing
static public Polygon2D Create(PolygonType type, float size = 1f)
{
Polygon2D newPolygon = new Polygon2D();
switch (type)
{
case PolygonType.Pentagon:
newPolygon.AddPoint(0f * size, 1f * size);
newPolygon.AddPoint(-0.9510565f * size, 0.309017f * size);
newPolygon.AddPoint(-0.5877852f * size, -0.8090171f * size);
newPolygon.AddPoint(0.5877854f * size, -0.8090169f * size);
newPolygon.AddPoint(0.9510565f * size, 0.3090171f * size);
break;
case PolygonType.Rectangle:
newPolygon.AddPoint(-size, -size);
newPolygon.AddPoint(size, -size);
newPolygon.AddPoint(size, size);
newPolygon.AddPoint(-size, size);
break;
case PolygonType.Circle:
float i = 0;
float cycle = 360f / (float)defaultCircleVerticesCount;
while (i < 360)
{
newPolygon.AddPoint(Mathf.Cos(i * Mathf.Deg2Rad) * size, Mathf.Sin(i * Mathf.Deg2Rad) * size);
i += cycle;
}
break;
case PolygonType.Hexagon:
for (int s = 1; s < 360; s = s + 60)
{
newPolygon.AddPoint(Mathf.Cos(s * Mathf.Deg2Rad) * size, Mathf.Sin(s * Mathf.Deg2Rad) * size);
}
break;
case PolygonType.Octagon:
for (int s = 1; s < 360; s = s + 40)
{
newPolygon.AddPoint(Mathf.Cos(s * Mathf.Deg2Rad) * size, Mathf.Sin(s * Mathf.Deg2Rad) * size);
}
break;
}
return(newPolygon);
}
static public Polygon2D CreateFromCapsuleCollider(CapsuleCollider2D capsuleCollider, int pointsCount = -1)
{
if (pointsCount < 1)
{
pointsCount = defaultCircleVerticesCount;
}
Polygon2D newPolygon = new Polygon2D();
Vector2 size = new Vector2(capsuleCollider.size.x / 2, capsuleCollider.size.y / 2);
float offset = 0;
float i = 0;
switch (capsuleCollider.direction)
{
case CapsuleDirection2D.Vertical:
float sizeXY = (capsuleCollider.transform.localScale.x / capsuleCollider.transform.localScale.y);
size.x *= sizeXY;
i = 0;
if (capsuleCollider.size.x < capsuleCollider.size.y)
{
offset = (capsuleCollider.size.y - capsuleCollider.size.x) / 2;
}
while (i < 180)
{
Vector2 v = new Vector2(Mathf.Cos(i * Mathf.Deg2Rad) * size.x, offset + Mathf.Sin(i * Mathf.Deg2Rad) * size.x);
newPolygon.AddPoint(v + capsuleCollider.offset);
i += 360f / (float)pointsCount;
}
while (i < 360)
{
Vector2 v = new Vector2(Mathf.Cos(i * Mathf.Deg2Rad) * size.x, -offset + Mathf.Sin(i * Mathf.Deg2Rad) * size.x);
newPolygon.AddPoint(v + capsuleCollider.offset);
i += 360f / (float)pointsCount;
}
break;
case CapsuleDirection2D.Horizontal:
float sizeYX = (capsuleCollider.transform.localScale.y / capsuleCollider.transform.localScale.x);
size.x *= sizeYX; // not size.y?
i = -90;
if (capsuleCollider.size.y < capsuleCollider.size.x)
{
offset = (capsuleCollider.size.x - capsuleCollider.size.y) / 2;
}
while (i < 90)
{
Vector2 v = new Vector2(offset + Mathf.Cos(i * Mathf.Deg2Rad) * size.y, Mathf.Sin(i * Mathf.Deg2Rad) * size.y);
newPolygon.AddPoint(v + capsuleCollider.offset);
i += 360f / (float)pointsCount;
}
while (i < 270)
{
Vector2 v = new Vector2(-offset + Mathf.Cos(i * Mathf.Deg2Rad) * size.y, Mathf.Sin(i * Mathf.Deg2Rad) * size.y);
newPolygon.AddPoint(v + capsuleCollider.offset);
i += 360f / (float)pointsCount;
}
break;
}
return(newPolygon);
}
