static public List <Polygon2D> CreateFromMeshCollider(MeshCollider meshCollider)
{
List <Polygon2D> newPolygons = new List <Polygon2D>();
Vector2 size = new Vector2(1, 1);
Vector2 offset = Vector2.zero;
Mesh mesh = meshCollider.sharedMesh;
int length = mesh.triangles.GetLength(0);
for (int i = 0; i < length; i = i + 3)
{
Vector2 vecA = mesh.vertices [mesh.triangles [i]];
Vector2 vecB = mesh.vertices [mesh.triangles [i + 1]];
Vector2 vecC = mesh.vertices [mesh.triangles [i + 2]];
Polygon2D poly = new Polygon2D();
poly.AddPoint(vecA.x, vecA.y);
poly.AddPoint(vecB.x, vecB.y);
poly.AddPoint(vecC.x, vecC.y);
newPolygons.Add(poly);
}
return(newPolygons);
}
bool UpdateMiddleEraseMesh()
{
if (oldPosition == null)
{
return(false);
}
Vector2D pos = new Vector2D(GetMousePosition());
Vector2D oldPos = new Vector2D(oldPosition);
if (Vector2D.Distance(pos, oldPos) < size)
{
return(false);
}
Polygon2D middlePolygon = new Polygon2D();
double rotation = Vector2D.Atan2(pos, oldPos) - Mathf.PI / 2;
Vector2D push = Vector2D.Zero();
push.Push(rotation, size);
middlePolygon.AddPoint(pos + push);
middlePolygon.AddPoint(pos - push);
middlePolygon.AddPoint(oldPos - push);
middlePolygon.AddPoint(oldPos + push);
eraseBrushMiddle = new EraseBrush(null, middlePolygon);
return(true);
}
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 GetPolygon()
{
if (eventPoly == null)
{
eventPoly = new Polygon2D();
eventPoly.AddPoint(Vector2D.Zero());
eventPoly.AddPoint(Vector2D.Zero());
eventPoly.AddPoint(Vector2D.Zero());
eventPoly.AddPoint(Vector2D.Zero());
}
return(eventPoly);
}
private Polygon2D GetPolygon()
{
if (polygon == null)
{
polygon = new Polygon2D();
polygon.AddPoint(0, 0);
polygon.AddPoint(0, 0);
polygon.AddPoint(0, 0);
polygon.AddPoint(0, 0);
}
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);
}
private void GeneratePhysicsShape()
{
polygons = new List <Polygon2D>();
#if UNITY_2018_1_OR_NEWER
int count = sprite.GetPhysicsShapeCount();
List <Vector2> points;
Polygon2D newPolygon;
for (int i = 0; i < count; i++)
{
points = new List <Vector2>();
sprite.GetPhysicsShape(i, points);
newPolygon = new Polygon2D();
for (int id = 0; id < points.Count; id++)
{
newPolygon.AddPoint(points[id]);
}
polygons.Add(newPolygon);
}
LightingDebug.totalObjectMaskShapeGenerations++;
#endif
}
static public List <Polygon2D> CreateFromPolygonColliderToLocalSpace(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);
}
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);
}
if (newPolygon.PolyInPoly(hole) == true)
{
newPolygon.AddHole(hole);
}
else
{
result.Add(hole);
}
}
}
return(result);
}
void CreateAsteroid()
{
GameObject newGameObject = new GameObject();
newGameObject.name = "Aseteroid";
float ratio = (float)Screen.width / Screen.height;
newGameObject.transform.position = new Vector2(Random.Range(-Camera.main.orthographicSize * ratio, Camera.main.orthographicSize * ratio), Camera.main.orthographicSize);
Polygon2D polygon = new Polygon2D();
float rot = 0;
while (rot < 360)
{
float dist = Random.Range(50, 100);
polygon.AddPoint(Mathf.Cos(Mathf.Deg2Rad * rot) * dist / 100f, Mathf.Sin(Mathf.Deg2Rad * rot) * dist / 100f);
rot += Random.Range(10, 45);
}
polygon.CreateCollider(newGameObject).isTrigger = true;
//newGameObject.AddComponent<SliceroidsKeepInScreen>();
SliceroidsColliderLineRenderer2D lineRenderer = newGameObject.AddComponent <SliceroidsColliderLineRenderer2D>();
lineRenderer.color = new Color(56f / 255, 1, 239f / 255, 1f);
newGameObject.AddComponent <Rigidbody2D>().AddForce(Vector2D.RotToVec(Vector2D.Atan2(new Vector2D(Vector2.zero), new Vector2D(newGameObject.transform.position))).vector * 100);
newGameObject.AddComponent <Slicer2D>().textureType = Slicer2D.TextureType.None;
}
public static List <Polygon2D> CreateFromCompositeCollider(CompositeCollider2D compositeCollider)
{
List <Polygon2D> list = new List <Polygon2D>();
if (compositeCollider != null)
{
int pathCount = compositeCollider.pathCount;
for (int i = 0; i < pathCount; i++)
{
int pointCount = compositeCollider.GetPathPointCount(i);
Vector2[] pointsInPath = new Vector2[pointCount];
compositeCollider.GetPath(i, pointsInPath);
Polygon2D polygon = new Polygon2D();
for (int j = 0; j < pointsInPath.Length; j++)
{
polygon.AddPoint(pointsInPath[j]);
}
polygon.Normalize();
list.Add(polygon);
}
}
return(list);
}
public void DrawTrajectory()
{
Polygon2D trajectory = new Polygon2D();
//trajectory.AddPoint(0, 0);
Vector2 pos = spawner.transform.position;
Vector2 gravity = Physics2D.gravity;
Vector2 force = spawner.transform.right * applyForce;
float timer = 0;
while (timer < 3)
{
float delta = 0.1f;
trajectory.AddPoint(pos);
pos += force * delta;
force += gravity * delta;
timer += delta;
}
Mesh mesh = Max2DMesh.CreatePolygon(transform, trajectory, -3f, 1f, false);
Max2DMesh.Draw(mesh, trajectoryMaterial);
}
// Get List Of Polygons from Collider (Usually Used Before Creating Slicer2D Object)
static public List <Polygon2D> GetListFromCollider(GameObject gameObject)
{
List <Polygon2D> result = new List <Polygon2D> ();
PolygonCollider2D polygonCollider = gameObject.GetComponent <PolygonCollider2D> ();
if (polygonCollider != null && polygonCollider.pathCount > 1)
{
Polygon2D newPolygon = new Polygon2D();
foreach (Vector2 p in polygonCollider.GetPath(0))
{
newPolygon.AddPoint(p + polygonCollider.offset);
}
result.Add(newPolygon.ToWorldSpace(gameObject.transform));
for (int i = 1; i < polygonCollider.pathCount; i++)
{
Polygon2D hole = new Polygon2D();
foreach (Vector2 p in polygonCollider.GetPath(i))
{
hole.AddPoint(p + polygonCollider.offset);
}
if (newPolygon.PolyInPoly(hole) == false)
{
result.Add(hole.ToWorldSpace(gameObject.transform));
}
}
}
return(result);
}
static private Polygon2D CreateFromPolygonCollider(PolygonCollider2D polygonCollider)
{
Polygon2D newPolygon = new Polygon2D();
if (polygonCollider != null)
{
foreach (Vector2 p in polygonCollider.GetPath(0))
{
newPolygon.AddPoint(p + polygonCollider.offset);
}
for (int i = 1; i < polygonCollider.pathCount; i++)
{
Polygon2D hole = new Polygon2D();
foreach (Vector2 p in polygonCollider.GetPath(i))
{
hole.AddPoint(p + polygonCollider.offset);
}
if (newPolygon.PolyInPoly(hole) == true)
{
newPolygon.AddHole(hole);
}
else
{
Slicer2D.Debug.LogError("Path is not a hole");
}
}
}
return(newPolygon);
}
public List <Polygon2D> GetShapePolygons()
{
if (shapePolygons == null)
{
shapePolygons = new List <Polygon2D>();
if (lightSprite == null)
{
return(shapePolygons);
}
#if UNITY_2018_1_OR_NEWER
int count = lightSprite.GetPhysicsShapeCount();
for (int i = 0; i < count; i++)
{
List <Vector2> points = new List <Vector2>();
lightSprite.GetPhysicsShape(i, points);
Polygon2D newPolygon = new Polygon2D();
foreach (Vector2 p in points)
{
newPolygon.AddPoint(p);
}
shapePolygons.Add(newPolygon);
}
#endif
}
return(shapePolygons);
}
public void LoadResource(Game game)
{
Player p1 = new Player();
p1.Transformation.Position.X = 300;
p1.Transformation.Position.Y = 300;
SpriteComponent sprite = new SpriteComponent(p1.Transformation, 3);
ThrustComponent thrust = new ThrustComponent(2);
p1.AddComponent(thrust);
p1.AddComponent(sprite);
thrust.GenerateParticles(600);
Texture texture = game.LoadTexture(@"C:\Source\escape-aliens\Resources\SpaceShipRed.png");
SDL.SDL_Rect renderRect;
SDL.SDL_Rect sourceRect;
renderRect.x = 0;
renderRect.y = 0;
renderRect.w = 80;
renderRect.h = 80;
sourceRect.w = 167;
sourceRect.h = 170;
sourceRect.x = 0;
sourceRect.y = 0;
texture.RenderRectangle = renderRect;
texture.SourceRectangle = sourceRect;
sprite.AddAnimationFrame(texture);
game.Input.KeyboardBindings.AddMapping(SDL.SDL_Scancode.SDL_SCANCODE_D, p1.RotateRight);
game.Input.KeyboardBindings.AddMapping(SDL.SDL_Scancode.SDL_SCANCODE_A, p1.RotateLeft);
game.Input.KeyboardBindings.AddMapping(SDL.SDL_Scancode.SDL_SCANCODE_W, p1.Forward);
game.AddObject(p1);
Polygon2D poly = new Polygon2D();
poly.AddPoint(300, 300);
poly.AddPoint(600, 400);
poly.AddPoint(400, 500);
Texture polyText = game.LoadTexture(@"C:\Source\escape-aliens\Resources\MapForeground.png");
FilledPolygon2D filledPolygon = new FilledPolygon2D(poly, polyText);
Asteroid asteroid = new Asteroid();
asteroid.AddComponent(filledPolygon);
game.AddObject(asteroid);
}
void OnCollisionEnter2D(Collision2D collision)
{
if (collision.collider.name.Contains("Terrain"))
{
Vector2D pos = new Vector2D(transform.position);
Polygon2D.defaultCircleVerticesCount = 15;;
Polygon2D slicePolygon = Polygon2D.Create(Polygon2D.PolygonType.Circle, 2f);
Polygon2D slicePolygonDestroy = null;
Polygon2D sliceDestroy = null;
slicePolygonDestroy = Polygon2D.Create(Polygon2D.PolygonType.Circle, 2.5f);
sliceDestroy = new Polygon2D();
foreach (Vector2D id in slicePolygonDestroy.pointsList)
{
sliceDestroy.AddPoint(new Vector2D(id.vector + pos.vector));
}
Polygon2D slice = new Polygon2D();
foreach (Vector2D id in slicePolygon.pointsList)
{
slice.AddPoint(new Vector2D(id.vector + pos.vector));
}
foreach (Slicer2D id in Slicer2D.GetList())
{
Slice2D result = id.PolygonSlice2(slice); // Why not use Slice All?
if (result.polygons.Count > 0)
{
foreach (Polygon2D p in new List <Polygon2D>(result.polygons))
{
if (sliceDestroy.PolyInPoly(p) == true)
{
result.polygons.Remove(p);
}
}
if (result.polygons.Count > 0)
{
id.PerformResult(result.polygons, new Slice2D());
}
else
{
Destroy(id.gameObject);
}
}
}
Destroy(gameObject);
Polygon2D.defaultCircleVerticesCount = 25;
}
}
// Not finished - still has some artifacts
static public List <Vector2D> PreparePolygon(Polygon2D polygon)
{
Polygon2D newPolygon = new Polygon2D();
polygon.Normalize();
DoublePair2D pair;
foreach (Vector2D pB in polygon.pointsList)
{
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 = new DoublePair2D(polygon.pointsList[indexA], pB, polygon.pointsList[indexC]);
float rotA = (float)Vector2D.Atan2(pair.B, pair.A);
float rotC = (float)Vector2D.Atan2(pair.B, pair.C);
Vector2D pairA = new Vector2D(pair.A);
pairA.Push(rotA - Mathf.PI / 2, precision);
Vector2D pairC = new Vector2D(pair.C);
pairC.Push(rotC + Mathf.PI / 2, precision);
Vector2D vecA = new Vector2D(pair.B);
vecA.Push(rotA - Mathf.PI / 2, precision);
vecA.Push(rotA, 10f);
Vector2D vecC = new Vector2D(pair.B);
vecC.Push(rotC + Mathf.PI / 2, precision);
vecC.Push(rotC, 10f);
Vector2D result = Math2D.GetPointLineIntersectLine(new Pair2D(pairA, vecA), new Pair2D(pairC, vecC));
if (result != null)
{
newPolygon.AddPoint(result);
}
}
return(newPolygon.pointsList);
}
static public Polygon2D CreateFromCapsuleCollider(CapsuleCollider capsuleCollider, int pointsCount = -1)
{
if (pointsCount < 1)
{
pointsCount = defaultCircleVerticesCount;
}
Polygon2D newPolygon = new Polygon2D();
float radius = capsuleCollider.radius;
float height = capsuleCollider.height / 2;
Vector2 size = new Vector2(capsuleCollider.radius, capsuleCollider.radius);
Vector2 offset = capsuleCollider.center;
float off = 0;
if (height > radius)
{
off = height - radius;
}
float i = 0;
while (i < 180)
{
Vector2 v = new Vector2(Mathf.Cos(i * Mathf.Deg2Rad) * size.x, off + Mathf.Sin(i * Mathf.Deg2Rad) * size.x);
newPolygon.AddPoint(v + offset);
i += 360f / (float)pointsCount;
}
while (i < 360)
{
Vector2 v = new Vector2(Mathf.Cos(i * Mathf.Deg2Rad) * size.x, -off + Mathf.Sin(i * Mathf.Deg2Rad) * size.x);
newPolygon.AddPoint(v + offset);
i += 360f / (float)pointsCount;
}
return(newPolygon);
}
static private Polygon2D CreateFromEdgeCollider(EdgeCollider2D edgeCollider)
{
Polygon2D newPolygon = new Polygon2D();
if (edgeCollider != null)
{
foreach (Vector2 p in edgeCollider.points)
{
newPolygon.AddPoint(p + edgeCollider.offset);
}
}
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);
}
public Polygon2D ToWorldSpace(Transform transform)
{
Polygon2D newPolygon = new Polygon2D();
foreach (Vector2D id in pointsList)
{
newPolygon.AddPoint(transform.TransformPoint(id.vector));
}
foreach (Polygon2D p in holesList)
{
newPolygon.AddHole(p.ToWorldSpace(transform));
}
return(newPolygon);
}
public Polygon2D Copy()
{
Polygon2D newPolygon = new Polygon2D();
foreach (Vector2D id in pointsList)
{
newPolygon.AddPoint(id.ToVector2());
}
foreach (Polygon2D p in holesList)
{
newPolygon.AddHole(p.Copy());
}
return(newPolygon);
}
public Polygon2D ToWorldSpace(Transform transform)
{
Polygon2D newPolygon = new Polygon2D();
for (int id = 0; id < pointsList.Count; id++)
{
newPolygon.AddPoint(transform.TransformPoint(pointsList[id].ToVector2()));
}
for (int id = 0; id < holesList.Count; id++)
{
newPolygon.AddHole(holesList[id].ToWorldSpace(transform));
}
return(newPolygon);
}
public void GeneratePhysicsShape()
{
int count = sprite.GetPhysicsShapeCount();
for (int i = 0; i < count; i++)
{
List <Vector2> points = new List <Vector2>();
sprite.GetPhysicsShape(0, points);
Polygon2D newPolygon = new Polygon2D();
foreach (Vector2 p in points)
{
newPolygon.AddPoint(p);
}
polygons.Add(newPolygon);
}
}
static public Merge2D MergePolygon(Polygon2D polygon, Polygon2D mergePolygon)
{
Merge2D result = Merge2D.Create(mergePolygon.pointsList);
Vector2D startPoint = null;
foreach (Vector2D id in mergePolygon.pointsList)
{
if (polygon.PointInPoly(id) == true)
{
startPoint = id;
break;
}
}
if (startPoint == null)
{
if (Slicer2D.Debug.enabled)
{
Debug.LogWarning("Starting Point Error In Polygon Merge");
}
return(result);
}
mergePolygon.pointsList = Vector2DList.GetListStartingPoint(mergePolygon.pointsList, startPoint);
mergePolygon.AddPoint(startPoint);
// Not Necessary
if (polygon.SliceIntersectPoly(mergePolygon.pointsList) == false)
{
return(result);
}
result = ComplexMerger.Merge(polygon, new List <Vector2D> (mergePolygon.pointsList));
if (result.polygons.Count < 1)
{
if (Slicer2D.Debug.enabled)
{
Debug.LogWarning("Merger2D: Returns Empty Polygon Slice");
}
}
return(result);
}
public Polygon2D ToScale(float scaleX = 1f, float scaleY = 1f, Vector2D center = null)
{
Polygon2D newPolygon = new Polygon2D();
if (center == null)
{
center = new Vector2D(Vector2.zero);
}
foreach (Vector2D pos in pointsList)
{
float dist = Vector2.Distance(pos.vector, center.vector);
float rot = Vector2D.Atan2(pos.vector, center.vector);
newPolygon.AddPoint(center.vector.x + Mathf.Cos(rot) * dist * scaleX, center.vector.y + Mathf.Sin(rot) * dist * scaleY);
}
return(newPolygon);
}
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 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);
}
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 Polygon2 CreateFromSphereCollider(SphereCollider sphereCollider, int pointsCount = -1)
{
if (pointsCount < 1)
{
pointsCount = defaultCircleVerticesCount;
}
Polygon2D newPolygon = new Polygon2D();
float size = sphereCollider.radius;
float i = 0;
Vector2 offset = sphereCollider.center;
while (i < 360)
{
newPolygon.AddPoint(new Vector2(Mathf.Cos(i * Mathf.Deg2Rad) * size, Mathf.Sin(i * Mathf.Deg2Rad) * size) + offset);
i += 360f / (float)pointsCount;
}
return(new Polygon2(newPolygon));
}
