public static Polygon RandomCircleSweep(double scale, int vertexCount) { PolygonPoint point; PolygonPoint[] points; double radius = scale / 4; points = new PolygonPoint[vertexCount]; for (int i = 0; i < vertexCount; i++) { do { if (i % 250 == 0) { radius += scale / 2 * (0.5 - RNG.NextDouble()); } else if (i % 50 == 0) { radius += scale / 5 * (0.5 - RNG.NextDouble()); } else { radius += 25 * scale / vertexCount * (0.5 - RNG.NextDouble()); } radius = radius > scale / 2 ? scale / 2 : radius; radius = radius < scale / 10 ? scale / 10 : radius; } while (radius < scale / 10 || radius > scale / 2); point = new PolygonPoint(radius * Math.Cos((PI_2 * i) / vertexCount), radius * Math.Sin((PI_2 * i) / vertexCount)); points[i] = point; } return new Polygon(points); }
public static Poly2Tri.Polygon ConvertFromClipper(List<ClipperLib.IntPoint> polygon) { Poly2Tri.PolygonPoint[] points = new Poly2Tri.PolygonPoint[polygon.Count]; for(int i = 0; i < polygon.Count; i++) { points[i] = new Poly2Tri.PolygonPoint(polygon[i].X,polygon[i].Y); } return new Poly2Tri.Polygon(points); }
/// <summary> /// To create a polygon we need atleast 3 separate points /// </summary> /// public Polygon(PolygonPoint p1, PolygonPoint p2, PolygonPoint p3) { p1._next = p2; p2._next = p3; p3._next = p1; p1._previous = p3; p2._previous = p1; p3._previous = p2; _points.Add(p1); _points.Add(p2); _points.Add(p3); }
/// <summary> /// Inserts newPoint after point. /// </summary> /// <param name="point">The point to insert after in the polygon</param> /// <param name="newPoint">The point to insert into the polygon</param> public void InsertPointAfter(PolygonPoint point, PolygonPoint newPoint) { // Validate that int index = _points.IndexOf(point); if (index == -1) { throw new ArgumentException("Tried to insert a point into a Polygon after a point not belonging to the Polygon", "point"); } newPoint.Next = point.Next; newPoint.Previous = point; point.Next.Previous = newPoint; point.Next = newPoint; _points.Insert(index + 1, newPoint); }
/// <summary> /// Removes a point from the polygon. Note this can be a somewhat expensive operation /// as it must recalculate the bounding area from scratch. /// </summary> /// <param name="p"></param> public void RemovePoint(PolygonPoint p) { PolygonPoint next, prev; next = p.Next; prev = p.Previous; prev.Next = next; next.Previous = prev; mPoints.Remove(p); mBoundingBox.Clear(); foreach (PolygonPoint tmp in mPoints) { mBoundingBox.AddPoint(tmp); } }
/// <summary> /// Will insert a point in the polygon after given point /// </summary> public void insertPointAfter(PolygonPoint a, PolygonPoint newPoint) { // Validate that int index = _points.IndexOf(a); if (index != -1) { newPoint.setNext(a.getNext()); newPoint.setPrevious(a); a.getNext().setPrevious(newPoint); a.setNext(newPoint); _points.Insert(index + 1, newPoint); } else { throw new Exception("Tried to insert a point into a Polygon after a point not belonging to the Polygon"); } }
/// <summary> /// Create a polygon from a list of at least 3 points with no duplicates. /// </summary> /// <param name="points">A list of unique points</param> public Polygon(PolygonPoint[] points) { this._points = points; if (points.Length < 3) { throw new ArgumentException("List has fewer than 3 points", "points"); } // Lets do one sanity check that first and last point hasn't got same position // Its something that often happen when importing polygon data from other formats if (points[0].Equals(points[points.Length - 1])) { //reduce last *** PolygonPoint[] newPoints = new PolygonPoint[points.Length - 1]; Array.Copy(this._points, 0, newPoints, 0, points.Length - 1); this._points = newPoints; } }
/// <summary> /// Inserts list (after last point in polygon?) /// </summary> /// <param name="list"></param> public void AddPoints(IEnumerable <PolygonPoint> list) { PolygonPoint first; foreach (PolygonPoint p in list) { p.Previous = _last; if (_last != null) { p.Next = _last.Next; _last.Next = p; } _last = p; _points.Add(p); } first = (PolygonPoint)_points[0]; _last.Next = first; first.Previous = _last; }
public void addPoints(List <PolygonPoint> list) { PolygonPoint first; foreach (PolygonPoint p in list) { p.setPrevious(_last); if (_last != null) { p.setNext(_last.getNext()); _last.setNext(p); } _last = p; _points.Add(p); } first = (PolygonPoint)_points[0]; _last.setNext(first); first.setPrevious(_last); }
public static Polygon RandomCircleSweep2(double scale, int vertexCount) { PolygonPoint point; PolygonPoint[] points; double radius = scale / 4; points = new PolygonPoint[vertexCount]; for (int i = 0; i < vertexCount; i++) { do { radius += scale / 5 * (0.5 - RNG.NextDouble()); radius = radius > scale / 2 ? scale / 2 : radius; radius = radius < scale / 10 ? scale / 10 : radius; } while (radius < scale / 10 || radius > scale / 2); point = new PolygonPoint(radius * Math.Cos((PI_2 * i) / vertexCount), radius * Math.Sin((PI_2 * i) / vertexCount)); points [i] = point; } return(new Polygon(points)); }
public Polygon CleanClone() { //recursive Polygon newPolygon = new Polygon(); var myPoints = this._points; int j = myPoints.Length; TriangulationPoint[] clonePoints = new TriangulationPoint[j]; newPolygon._points = clonePoints; for (int i = j - 1; i >= 0; --i) { var p = myPoints[i]; clonePoints[i] = new PolygonPoint(p.X, p.Y); } //----------------------------------------------------------------- Polygon[] myHoles = this._holes; if (myHoles != null) { j = myHoles.Length; Polygon[] cloneHoles = new Polygon[j]; newPolygon._holes = cloneHoles; for (int i = j - 1; i >= 0; --i) { cloneHoles[i] = myHoles[i].CleanClone(); } //for (int i = 0; i < j; ++i) //{ // cloneHoles.Add(myHoles[i].CleanClone()); //} } return(newPolygon); }
/// <summary> /// Removes a point from the polygon. /// </summary> /// <param name="p"></param> public void RemovePoint(PolygonPoint p) { PolygonPoint next, prev; next = p.Next; prev = p.Previous; prev.Next = next; next.Previous = prev; _points.Remove(p); }
public static Point2D ToBasePoint(PolygonPoint p) { return (Point2D)p; }
/// <summary> /// Inserts list (after last point in polygon?) /// </summary> /// <param name="list"></param> public void AddPoints(IEnumerable<PolygonPoint> list) { PolygonPoint first; foreach (PolygonPoint p in list) { p.Previous = _last; if (_last != null) { p.Next = _last.Next; _last.Next = p; } _last = p; _points.Add(p); } first = (PolygonPoint)_points[0]; _last.Next = first; first.Previous = _last; }
/// <summary> /// Adds a point after the last in the polygon. /// </summary> /// <param name="p">The point to add</param> public void AddPoint(PolygonPoint p) { p.Previous = _last; p.Next = _last.Next; _last.Next = p; _points.Add(p); }
public void Add(PolygonPoint p) { Add(p, -1, true); }
/// <summary> /// Inserts newPoint after point. /// </summary> /// <param name="point">The point to insert after in the polygon</param> /// <param name="newPoint">The point to insert into the polygon</param> public void InsertPointAfter(PolygonPoint point, PolygonPoint newPoint) { // Validate that int index = _points.IndexOf(point); if (index == -1) throw new ArgumentException("Tried to insert a point into a Polygon after a point not belonging to the Polygon", "point"); newPoint.Next = point.Next; newPoint.Previous = point; point.Next.Previous = newPoint; point.Next = newPoint; _points.Insert(index + 1, newPoint); }
public static TriangulationPoint ToTriangulationPoint(PolygonPoint p) { return((TriangulationPoint)p); }
public static Point2D ToBasePoint(PolygonPoint p) { return((Point2D)p); }
public static TriangulationPoint ToTriangulationPoint(PolygonPoint p) { return (TriangulationPoint)p; }
public static Vector2 ToOtk(PolygonPoint v) { return new Vector2((float)v.X, (float)v.Y); }
static GameObject CreateMeshFromColl(LevelBase l, Transform t, LevelShape[] s) { GameObject partObj = new GameObject("Part"); PolygonCollider2D[] colls = t.GetComponents<PolygonCollider2D>(); Polygon polygon = null; List<EdgeCollider2D> collsToAdd = new List<EdgeCollider2D>(); foreach (PolygonCollider2D c in colls) { if (c.enabled == false) continue; Vector2[] vecs = c.points; List<Vector2> edgeVecs = new List<Vector2>(); edgeVecs.AddRange(vecs); edgeVecs.Add(vecs[0]); EdgeCollider2D e = partObj.AddComponent<EdgeCollider2D>(); e.points = edgeVecs.ToArray(); List<PolygonPoint> pts = new List<Poly2Tri.PolygonPoint>(); for (int i = 0; i < vecs.Length; i++) { PolygonPoint pt = new Poly2Tri.PolygonPoint(vecs[i].x * l.factor, vecs[i].y * l.factor); pts.Add(pt); } if (polygon == null) { polygon = new Polygon(pts); } else { pts.Reverse(); polygon.AddHole(new Polygon(pts)); } c.enabled = false; } P2T.Triangulate(polygon); Mesh m = CreateMesh2(polygon.Points, polygon.Triangles); Vector3[] vertices = m.vertices; Color[] colors = new Color[vertices.Length]; int j = 0; while (j < vertices.Length) { colors[j] = l.fillColor; j++; } m.colors = colors; MeshFilter mf = partObj.AddComponent<MeshFilter>(); bool extrudeMesh = false; if (extrudeMesh) { Mesh extruded = new Mesh(); Matrix4x4 m1 = Matrix4x4.TRS(new Vector3(0, 0, 0), Quaternion.identity, new Vector3(1, 1, 1)); List<Matrix4x4> mxs = new List<Matrix4x4>(); mxs.Add(m1); for (int i = 0; i < s.Length; i++) { Matrix4x4 m3 = Matrix4x4.TRS(s[i].exturePos, Quaternion.Euler(s[i].extrudeRotation.x, s[i].extrudeRotation.y, s[i].extrudeRotation.z), s[i].extrudeScale); mxs.Add(m3); } MeshExtrusion.ExtrudeMesh(m, extruded, mxs.ToArray(), false); mf.sharedMesh = extruded; } else { mf.sharedMesh = m; } MeshRenderer mr = partObj.AddComponent<MeshRenderer>(); mr.material = l.hillMaterial; return partObj; }
private double GetDistance(PolygonPoint a, PolygonPoint b) { double dx = b.X - a.X; double dy = b.Y - a.Y; return Math.Sqrt(dx * dx + dy * dy); }
public static MeshProperties[] CreateMesh(List <BoundaryPoint> genPoly, Transform objTrans, float spriteSquareSize) { const int _FRONTOFFSET = 3; const float _BACKFACE_OFFSET = 0.5f; const float _SCALE_FACTOR = 1.1f; MeshProperties _generatedMesh; MeshProperties _frontFaceMesh; Vector2[] _genPolyArrFront = new Vector2[genPoly.Count]; List <VertexProperties> _verts = new List <VertexProperties>(); List <VertexProperties> _frontFaceVerticies = new List <VertexProperties>(); List <int> _indicies = new List <int>(); List <int> _frontFaceIndicies = new List <int>(); //ConvertingToArray for (int i = 0; i < genPoly.Count; i++) { _genPolyArrFront[i] = objTrans.TransformPoint(genPoly[i].Pos); } Vector3 vecSum = Vector3.zero; //VerticiesFront for (int i = 0; i < genPoly.Count; i++) { Vector3 _position = new Vector3(_genPolyArrFront[i].x, _genPolyArrFront[i].y, 0.0f); vecSum += _position; _verts.Add(new VertexProperties { position = _position }); _verts.Add(new VertexProperties { position = _position }); _verts.Add(new VertexProperties { position = _position }); _frontFaceVerticies.Add(new VertexProperties { position = _position }); } //Calculating the center of the unscaled polygon Vector3 polygonCenter = vecSum / genPoly.Count; polygonCenter.z = objTrans.position.z; Matrix4x4 scaleMatrix = BlastProof.Mathematics.ScaleMatrix(_SCALE_FACTOR); Vector3 vecSum2 = Vector3.zero; //VerticiesBack for (int i = 0; i < genPoly.Count; i++) { Vector3 _position = scaleMatrix.MultiplyPoint(new Vector3(_genPolyArrFront[i].x, _genPolyArrFront[i].y, _BACKFACE_OFFSET)); vecSum2 += _position; _verts.Add(new VertexProperties { position = _position }); _verts.Add(new VertexProperties { position = _position }); _verts.Add(new VertexProperties { position = _position }); } Vector3 scaledPolyCenter = vecSum2 / genPoly.Count; scaledPolyCenter.z = objTrans.position.z; //Caching how much should the polygon move on axis so it matches the original scale polygon Vector3 translVec = polygonCenter - scaledPolyCenter; Matrix4x4 transMatrix = BlastProof.Mathematics.TranslateMatrix(translVec); //Multiplying each backface polygon position with the translation matrix so the center of backface polygon and frontface polygon matches for (int i = _verts.Count / 2; i < _verts.Count; i++) { _verts[i].position = transMatrix.MultiplyPoint(_verts[i].position); } var newGenPolyArrFront = new List <Poly2Tri.PolygonPoint>(); for (int i = 0; i < _genPolyArrFront.Length; i++) { var point = new Poly2Tri.PolygonPoint(_genPolyArrFront[i].x, _genPolyArrFront[i].y); point.index = i; newGenPolyArrFront.Add(point); } Poly2Tri.Polygon poly = new Poly2Tri.Polygon(newGenPolyArrFront); DTSweepContext tcx = new DTSweepContext(); tcx.PrepareTriangulation(poly); DTSweep.Triangulate(tcx); List <int> indiciesFromTriangulator = new List <int>(); foreach (var triangle in poly.Triangles) { foreach (var point in triangle.Points) { indiciesFromTriangulator.Add(point.index); } } indiciesFromTriangulator.Reverse(); Triangulator tri = new Triangulator(_genPolyArrFront); int[] triangledPoly = indiciesFromTriangulator.ToArray(); //FrontFaceIndicies for (int i = 0; i < triangledPoly.Length; i++) { _indicies.Add(triangledPoly[i] * _FRONTOFFSET); _frontFaceIndicies.Add(triangledPoly[i]); } //BackFaceIndicies for (int i = triangledPoly.Length - 1; i >= 0; i--) { _indicies.Add(triangledPoly[i] * _FRONTOFFSET + (_verts.Count / 2)); } //Front-Back Faces normals for (int i = 0; i < _indicies.Count / 2; i += 3) { int[] v1 = { _indicies[i], _indicies[(i + 1) % (_indicies.Count / 2)], _indicies[(i + 2) % (_indicies.Count / 2)] }; int[] v2 = { _indicies[i + (_indicies.Count / 2)], _indicies[(i + 1) % (_indicies.Count / 2) + (_indicies.Count / 2)], _indicies[(i + 2) % (_indicies.Count / 2) + (_indicies.Count / 2)] }; GetNormalsForVerts(_verts, v1); GetNormalsForVerts(_verts, v2); GetUVsWithSize(_verts, v1, Faces.forward, spriteSquareSize); GetUVsWithSize(_verts, v2, Faces.forward, spriteSquareSize); } //Generating Side Triangles for (int i = 1; i < _verts.Count / 2; i += 6) { int[] frontFaceVerts = { i, (i + 3) % (_verts.Count / 2) }; int[] backFaceVerts = { (i + (_verts.Count / 2)), (i + 3) % (_verts.Count / 2) + (_verts.Count / 2) }; //verts pos are used as uvs int[] uvCoord = { i, (i + 3) % (_verts.Count / 2), (i + (_verts.Count / 2)), (i + 3) % (_verts.Count / 2) + (_verts.Count / 2) }; GetQuadIndicies(frontFaceVerts, backFaceVerts, _indicies, _verts); GetUVsWithSize(_verts, uvCoord, Faces.left, spriteSquareSize); } //Generate Up-Down Verts for (int i = 5; i < _verts.Count / 2; i += 6) { int[] frontFaceVerts = { i % (_verts.Count / 2), (i + 3) % (_verts.Count / 2) }; int[] backFaceVerts = { (i % (_verts.Count / 2) + (_verts.Count / 2)), (i + 3) % (_verts.Count / 2) + (_verts.Count / 2) }; //verts pos are used as uvs int[] uvCoord = { i % (_verts.Count / 2), (i + 3) % (_verts.Count / 2), (i % (_verts.Count / 2) + (_verts.Count / 2)), (i + 3) % (_verts.Count / 2) + (_verts.Count / 2) }; GetQuadIndicies(frontFaceVerts, backFaceVerts, _indicies, _verts); GetUVsWithSize(_verts, uvCoord, Faces.up, spriteSquareSize); } _generatedMesh = new MeshProperties(_verts); _generatedMesh.mesh_center = polygonCenter; _generatedMesh.SetIndicies(_indicies.ToArray()); _frontFaceMesh = new MeshProperties(_frontFaceVerticies); _frontFaceMesh.mesh_center = polygonCenter; _frontFaceMesh.SetIndicies(_frontFaceIndicies.ToArray()); return(new MeshProperties[] { _generatedMesh, _frontFaceMesh }); }