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