public bool Update(Vector2D pos)
{
float scroll = Input.GetAxis("Mouse ScrollWheel");
float newPolygonSize = polygonSize + scroll;
if (newPolygonSize > 0.05f)
{
polygonSize = newPolygonSize;
}
mouseDown = true;
if (Input.GetMouseButtonDown(0))
{
Polygon2D.defaultCircleVerticesCount = polygonEdgeCount;
slicePolygon = Polygon2D.Create(polygonType, polygonSize);
Polygon2D polygon = new Polygon2D();
polygon.pointsList = new List <Vector2D>(slicePolygon.pointsList);
polygon.ToOffsetItself(pos);
EraseBrush EraseBrush = new EraseBrush(null, polygon);
Destruction2D.DestroyByPolygonAll(EraseBrush, destructionLayer);
return(true);
}
else
{
return(false);
}
}
public void Initialize()
{
Polygon2D.defaultCircleVerticesCount = polygonEdgeCount;
slicePolygon = Polygon2D.Create(polygonType, polygonSize);
eraseBrush.SetBrush(slicePolygon);
}
private void PolygonCreator(Vector2D pos, Transform transform)
{
Polygon2D.defaultCircleVerticesCount = edgeCount;
Polygon2D newPolygon = Polygon2D.Create(polygonType, polygonSize).ToOffset(pos);
CreatePolygon(newPolygon, transform);
}
public void Initialize()
{
Polygon2D.defaultCircleVerticesCount = circleVerticesCount;
Polygon2D circlePolygon = Polygon2D.Create(Polygon2D.PolygonType.Hexagon, size);
eraseBrushStart.SetBrush(circlePolygon.Copy());
}
static public Slice2D ExplodeByPoint(Polygon2D polygon, Vector2D point)
{
Slice2D result = Slice2D.Create(point);
if (polygon.PointInPoly(point) == false)
{
return(result);
}
float sliceRot = UnityEngine.Random.Range(0, 360);
Polygon2D hole = Polygon2D.Create(Polygon2D.PolygonType.Rectangle, 0.1f);
hole = hole.ToOffset(point);
polygon.AddHole(hole);
result.AddPolygon(polygon);
int tries = 0;
while (result.polygons.Count < Slicer2D.explosionPieces)
{
foreach (Polygon2D p in new List <Polygon2D>(result.polygons))
{
sliceRot += UnityEngine.Random.Range(15, 45) * Mathf.Deg2Rad;
Vector2D v = new Vector2D(point);
v.Push(sliceRot, 0.4f);
Slice2D newResult = SliceFromPoint(p, v, sliceRot);
if (newResult.slices.Count > 0)
{
foreach (List <Vector2D> i in newResult.slices)
{
result.AddSlice(i);
}
}
if (newResult.polygons.Count > 0)
{
foreach (Polygon2D poly in newResult.polygons)
{
result.AddPolygon(poly);
}
result.RemovePolygon(p);
}
}
tries += 1;
if (tries > 20)
{
return(result);
}
}
return(result);
}
private void PolygonSlice(Vector2 pos)
{
Polygon2D.defaultCircleVerticesCount = edgeCount;
Polygon2D slicePoly = Polygon2D.Create(polygonType, polygonSize * visuals.visualScale).ToOffset(pos);
Merge.Merging.PolygonMergeAll(slicePoly, sliceLayer);
}
private void PolygonSlice(Vector2 pos)
{
Polygon2D.defaultCircleVerticesCount = edgeCount;
Polygon2D slicePolygon = Polygon2D.Create(polygonType, polygonSize * visuals.visualScale);
Slicing.PolygonSliceAll(pos.ToVector2D(), slicePolygon, polygonDestroy, sliceLayer);
}
private void PolygonSlice(Vector2D pos)
{
Polygon2D slicePolygonDestroy = null;
if (polygonDestroy == true)
{
slicePolygonDestroy = Polygon2D.Create(polygonType, polygonSize * 1.1f);
}
Slicer2D.PolygonSliceAll(pos, Polygon2D.Create(polygonType, polygonSize), slicePolygonDestroy, sliceLayer);
}
static public Mesh GenerateCreateMesh(Vector2D pos, Polygon2D.PolygonType polygonType, float polygonSize, Slicer2DController.CreateType createType, List <Vector2D> complexSlicerPointsList, Pair2D linearPair, float minVertexDistance, Transform transform, float lineWidth, float zPosition, float squareSize)
{
List <Mesh2DTriangle> trianglesList = new List <Mesh2DTriangle>();
float size = squareSize;
if (createType == Slicer2DController.CreateType.Slice)
{
if (complexSlicerPointsList.Count > 0)
{
linearPair.A = new Vector2D(complexSlicerPointsList.First());
linearPair.B = new Vector2D(complexSlicerPointsList.Last());
trianglesList.Add(CreateLineNew(new Pair2D(new Vector2D(linearPair.A.x - size, linearPair.A.y - size), new Vector2D(linearPair.A.x + size, linearPair.A.y - size)), transform, lineWidth, zPosition));
trianglesList.Add(CreateLineNew(new Pair2D(new Vector2D(linearPair.A.x - size, linearPair.A.y - size), new Vector2D(linearPair.A.x - size, linearPair.A.y + size)), transform, lineWidth, zPosition));
trianglesList.Add(CreateLineNew(new Pair2D(new Vector2D(linearPair.A.x + size, linearPair.A.y + size), new Vector2D(linearPair.A.x + size, linearPair.A.y - size)), transform, lineWidth, zPosition));
trianglesList.Add(CreateLineNew(new Pair2D(new Vector2D(linearPair.A.x + size, linearPair.A.y + size), new Vector2D(linearPair.A.x - size, linearPair.A.y + size)), transform, lineWidth, zPosition));
trianglesList.Add(CreateLineNew(new Pair2D(new Vector2D(linearPair.B.x - size, linearPair.B.y - size), new Vector2D(linearPair.B.x + size, linearPair.B.y - size)), transform, lineWidth, zPosition));
trianglesList.Add(CreateLineNew(new Pair2D(new Vector2D(linearPair.B.x - size, linearPair.B.y - size), new Vector2D(linearPair.B.x - size, linearPair.B.y + size)), transform, lineWidth, zPosition));
trianglesList.Add(CreateLineNew(new Pair2D(new Vector2D(linearPair.B.x + size, linearPair.B.y + size), new Vector2D(linearPair.B.x + size, linearPair.B.y - size)), transform, lineWidth, zPosition));
trianglesList.Add(CreateLineNew(new Pair2D(new Vector2D(linearPair.B.x + size, linearPair.B.y + size), new Vector2D(linearPair.B.x - size, linearPair.B.y + size)), transform, lineWidth, zPosition));
Vector2D vA, vB;
foreach (Pair2D pair in Pair2D.GetList(complexSlicerPointsList, true))
{
vA = new Vector2D(pair.A);
vB = new Vector2D(pair.B);
vA.Push(Vector2D.Atan2(pair.A, pair.B), -minVertexDistance / 5);
vB.Push(Vector2D.Atan2(pair.A, pair.B), minVertexDistance / 5);
trianglesList.Add(CreateLineNew(new Pair2D(vA, vB), transform, lineWidth, zPosition));
}
}
}
else
{
Polygon2D poly = Polygon2D.Create(polygonType, polygonSize).ToOffset(pos);
Vector2D vA, vB;
foreach (Pair2D pair in Pair2D.GetList(poly.pointsList, true))
{
vA = new Vector2D(pair.A);
vB = new Vector2D(pair.B);
vA.Push(Vector2D.Atan2(pair.A, pair.B), -minVertexDistance / 5);
vB.Push(Vector2D.Atan2(pair.A, pair.B), minVertexDistance / 5);
trianglesList.Add(CreateLineNew(new Pair2D(vA, vB), transform, lineWidth, zPosition));
}
}
return(ExportMesh(trianglesList));
}
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;
}
}
public void Draw(Transform transform, Vector2 pos)
{
Polygon2D.defaultCircleVerticesCount = polygonEdgeCount;
slicePolygon = Polygon2D.Create(polygonType, polygonSize);
slicePolygon.ToOffsetItself(new Vector2D(pos));
visuals.GenerateComplexMesh(slicePolygon.pointsList, transform);
visuals.Draw();
}
static public Mesh GenerateCreateMesh(Vector2D pos, Polygon2D.PolygonType polygonType, float polygonSize, Slicer2DCreateControllerObject.CreateType createType, List <Vector2D> complexSlicerPointsList, Pair2D linearPair, float minVertexDistance, Transform transform, float lineWidth, float zPosition, float squareSize, Slicer2DLineEndingType endingType, int edges)
{
Mesh2DMesh trianglesList = new Mesh2DMesh();
float size = squareSize;
if (createType == Slicer2DCreateControllerObject.CreateType.Slice)
{
if (complexSlicerPointsList.Count > 0)
{
linearPair.A = new Vector2D(complexSlicerPointsList.First());
linearPair.B = new Vector2D(complexSlicerPointsList.Last());
GenerateSquare(trianglesList, linearPair.A, size, transform, lineWidth, zPosition, endingType, edges);
GenerateSquare(trianglesList, linearPair.B, size, transform, lineWidth, zPosition, endingType, edges);
Vector2D vA, vB;
foreach (Pair2D pair in Pair2D.GetList(complexSlicerPointsList, true))
{
vA = new Vector2D(pair.A);
vB = new Vector2D(pair.B);
vA.Push(Vector2D.Atan2(pair.A, pair.B), -minVertexDistance / 5);
vB.Push(Vector2D.Atan2(pair.A, pair.B), minVertexDistance / 5);
trianglesList.Add(Max2DMesh.CreateLine(new Pair2D(vA, vB), transform.localScale, lineWidth, zPosition));
}
}
}
else
{
Polygon2D poly = Polygon2D.Create(polygonType, polygonSize).ToOffset(pos);
Vector2D vA, vB;
foreach (Pair2D pair in Pair2D.GetList(poly.pointsList, true))
{
vA = new Vector2D(pair.A);
vB = new Vector2D(pair.B);
vA.Push(Vector2D.Atan2(pair.A, pair.B), -minVertexDistance / 5);
vB.Push(Vector2D.Atan2(pair.A, pair.B), minVertexDistance / 5);
trianglesList.Add(Max2DMesh.CreateLine(new Pair2D(vA, vB), transform.localScale, lineWidth, zPosition));
}
}
return(Max2DMesh.Export(trianglesList));
}
///// POLYGON /////
public void GeneratePolygonMesh(Vector2 pos, Polygon2D.PolygonType polygonType, float polygonSize, float minVertexDistance, Transform transform, float lineWidth, float zPosition)
{
Polygon2D slicePolygon = Polygon2D.Create(polygonType, polygonSize).ToOffset(pos);
Vector2 vA, vB;
foreach (Pair2 pair in Pair2.GetList(slicePolygon.pointsList, true))
{
vA = pair.a;
vB = pair.b;
vA = vA.Push(pair.a.Atan2(pair.b), -minVertexDistance / 5);
vB = vB.Push(pair.a.Atan2(pair.b), minVertexDistance / 5);
CreateLine(new Pair2(vA, vB), transform.localScale, lineWidth, zPosition);
}
}
///// Create /////
public void GenerateCreateMesh(Vector2 pos, Polygon2D.PolygonType polygonType, float polygonSize, Slicer2DCreateControllerObject.CreateType createType, List <Vector2D> complexSlicerPointsList, Pair2D linearPair, float minVertexDistance, Transform transform, float lineWidth, float zPosition, float squareSize, Slicer2DLineEndingType endingType, int edges)
{
float size = squareSize;
if (createType == Slicer2DCreateControllerObject.CreateType.Slice)
{
if (complexSlicerPointsList.Count > 0)
{
linearPair.A = new Vector2D(complexSlicerPointsList.First());
linearPair.B = new Vector2D(complexSlicerPointsList.Last());
GenerateSquare(linearPair.A.ToVector2(), size, transform, lineWidth, zPosition, endingType, edges);
GenerateSquare(linearPair.B.ToVector2(), size, transform, lineWidth, zPosition, endingType, edges);
Vector2D vA, vB;
foreach (Pair2 pair in Pair2.GetList(complexSlicerPointsList, true))
{
vA = new Vector2D(pair.a);
vB = new Vector2D(pair.b);
vA.Push(Vector2D.Atan2(pair.a, pair.b), -minVertexDistance / 5);
vB.Push(Vector2D.Atan2(pair.a, pair.b), minVertexDistance / 5);
CreateLine(new Pair2(vA.ToVector2(), vB.ToVector2()), transform.localScale, lineWidth, zPosition);
}
}
}
else
{
Polygon2D poly = Polygon2D.Create(polygonType, polygonSize).ToOffset(pos);
Vector2D vA, vB;
foreach (Pair2 pair in Pair2.GetList(poly.pointsList, true))
{
vA = new Vector2D(pair.a);
vB = new Vector2D(pair.b);
vA.Push(Vector2D.Atan2(pair.a, pair.b), -minVertexDistance / 5);
vB.Push(Vector2D.Atan2(pair.a, pair.b), minVertexDistance / 5);
CreateLine(new Pair2(vA.ToVector2(), vB.ToVector2()), transform.localScale, lineWidth, zPosition);
}
}
}
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 = Polygon2D.Create(Polygon2D.PolygonType.Circle, 2.5f);
slicePolygon = slicePolygon.ToOffset(pos);
slicePolygonDestroy = slicePolygonDestroy.ToOffset(pos);
foreach (Slicer2D id in Slicer2D.GetListCopy())
{
Slice2D result = Slicer2D.API.PolygonSlice(id.shape.GetLocal().ToWorldSpace(id.transform), slicePolygon);
if (result.GetPolygons().Count > 0)
{
foreach (Polygon2D p in new List <Polygon2D>(result.GetPolygons()))
{
if (slicePolygonDestroy.PolyInPoly(p) == true)
{
result.GetPolygons().Remove(p);
}
}
if (result.GetPolygons().Count > 0)
{
id.PerformResult(result.GetPolygons(), new Slice2D());
}
else
{
// Polygon is Destroyed!!!
Destroy(id.gameObject);
}
}
}
Destroy(gameObject);
Polygon2D.defaultCircleVerticesCount = 25;
}
}
static public Mesh GeneratePolygonMesh(Vector2D pos, Polygon2D.PolygonType polygonType, float polygonSize, float minVertexDistance, Transform transform, float lineWidth, float zPosition)
{
Mesh2DMesh trianglesList = new Mesh2DMesh();
Polygon2D slicePolygon = Polygon2D.Create(polygonType, polygonSize).ToOffset(pos);
Vector2D vA, vB;
foreach (Pair2D pair in Pair2D.GetList(slicePolygon.pointsList, true))
{
vA = new Vector2D(pair.A);
vB = new Vector2D(pair.B);
vA.Push(Vector2D.Atan2(pair.A, pair.B), -minVertexDistance / 5);
vB.Push(Vector2D.Atan2(pair.A, pair.B), minVertexDistance / 5);
trianglesList.Add(Max2DMesh.CreateLine(new Pair2D(vA, vB), transform.localScale, lineWidth, zPosition));
}
return(Max2DMesh.Export(trianglesList));
}
private void PolygonSlice(Vector2D pos)
{
Polygon2D.defaultCircleVerticesCount = edgeCount;
Slicer2D.PolygonSliceAll(pos, Polygon2D.Create(polygonType, polygonSize * visualScale), polygonDestroy, sliceLayer);
}
public void OnRenderObject()
{
Vector2D pos = GetMousePosition();
if (drawSlicer == false)
{
return;
}
Max2D.SetBorder(true);
Max2D.SetLineMode(Max2D.LineMode.Smooth);
Max2D.SetLineWidth(lineWidth * .5f);
Max2D.SetScale(visualScale);
if (mouseDown)
{
Max2D.SetColor(slicerColor);
switch (sliceType)
{
case SliceType.Complex:
if (complexSlicerPointsList.Count > 0)
{
if (startSliceIfPossible == false || startedSlice == true)
{
Max2D.SetColor(Color.black);
Max2D.DrawLineSquare(complexSlicerPointsList.Last(), 0.6f * visualScale, zPosition);
Max2D.DrawLineSquare(complexSlicerPointsList.First(), 0.6f * visualScale, zPosition);
Max2D.DrawLineSquare(complexSlicerPointsList.Last(), 0.4f * visualScale, zPosition);
Max2D.DrawLineSquare(complexSlicerPointsList.First(), 0.4f * visualScale, zPosition);
Max2D.SetColor(slicerColor);
Max2D.DrawStrippedLine(complexSlicerPointsList, minVertsDistance, zPosition);
Max2D.DrawLineSquare(complexSlicerPointsList.Last(), 0.5f * visualScale, zPosition);
Max2D.DrawLineSquare(complexSlicerPointsList.First(), 0.5f * visualScale, zPosition);
}
}
break;
case SliceType.ComplexTracked:
if (complexSlicerPointsList.Count > 0)
{
Max2D.DrawLineSquare(pos, 0.5f * visualScale, zPosition);
foreach (ComplexSlicerTrackerObject tracker in complexTracker.trackerList)
{
if (tracker.slicer != null && tracker.tracking)
{
Max2D.DrawSlice(Vector2DList.ToWorldSpace(tracker.slicer.transform, tracker.pointsList), tracker.slicer.transform.position.z - 0.001f);
}
}
}
break;
case SliceType.Create:
if (createType == CreateType.Slice)
{
if (complexSlicerPointsList.Count > 0)
{
Max2D.SetColor(Color.black);
Max2D.DrawLineSquare(complexSlicerPointsList.Last(), 0.4f * visualScale, zPosition);
Max2D.DrawLineSquare(complexSlicerPointsList.First(), 0.4f * visualScale, zPosition);
Max2D.DrawLineSquare(complexSlicerPointsList.Last(), 0.6f * visualScale, zPosition);
Max2D.DrawLineSquare(complexSlicerPointsList.First(), 0.6f * visualScale, zPosition);
Max2D.SetColor(slicerColor);
Max2D.DrawLineSquare(complexSlicerPointsList.Last(), 0.5f * visualScale, zPosition);
Max2D.DrawLineSquare(complexSlicerPointsList.First(), 0.5f * visualScale, zPosition);
Max2D.DrawStrippedLine(complexSlicerPointsList, minVertsDistance, zPosition, true);
}
}
else
{
Max2D.DrawStrippedLine(Polygon2D.Create(polygonType, polygonSize).pointsList, minVertsDistance, zPosition, true, pos);
}
break;
case SliceType.Linear:
Max2D.SetColor(Color.black);
Max2D.DrawLineSquare(linearPair.A, 0.6f * visualScale, zPosition);
Max2D.DrawLineSquare(linearPair.B, 0.6f * visualScale, zPosition);
Max2D.DrawLineSquare(linearPair.A, 0.4f * visualScale, zPosition);
Max2D.DrawLineSquare(linearPair.B, 0.4f * visualScale, zPosition);
Max2D.SetColor(slicerColor);
Max2D.DrawLineSquare(linearPair.A, 0.5f * visualScale, zPosition);
Max2D.DrawLineSquare(linearPair.B, 0.5f * visualScale, zPosition);
Max2D.DrawLine(linearPair.A, linearPair.B, zPosition);
break;
case SliceType.LinearCut:
linearCutLine = LinearCut.Create(linearPair, linearCutSize);
Max2D.DrawStrippedLine(linearCutLine.GetPointsList(), 0, zPosition, true);
break;
case SliceType.ComplexCut:
complexCutLine = ComplexCut.Create(complexSlicerPointsList, complexCutSize);
Max2D.DrawStrippedLine(complexCutLine.GetPointsList(), 0, zPosition, true);
break;
case SliceType.Point:
break;
case SliceType.Explode:
break;
case SliceType.Polygon:
slicePolygon = Polygon2D.Create(polygonType, polygonSize);
Max2D.DrawStrippedLine(slicePolygon.pointsList, minVertsDistance, zPosition, true, pos);
break;
default:
break;
}
}
// Reset Graphics
Max2D.SetScale(1f);
}
private void PolygonCreator(Vector2D pos)
{
Polygon2D newPolygon = Polygon2D.Create(polygonType, polygonSize).ToOffset(pos);
CreatePolygon(newPolygon);
}
