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