void Start()
{
if (originalSize == 0)
{
originalSize = Polygon2D.CreateFromCollider(gameObject).ToWorldSpace(transform).GetArea();
}
}
void Start()
{
bool addEvents = false;
foreach (Collider2D collider in anchorColliders)
{
addEvents = true;
}
if (addEvents == false)
{
return;
}
Slicer2D slicer = GetComponent <Slicer2D> ();
if (slicer != null)
{
slicer.AddResultEvent(OnSliceResult);
slicer.AddEvent(OnSlice);
}
foreach (Collider2D collider in anchorColliders)
{
polygons.Add(Polygon2D.CreateFromCollider(collider.gameObject));
colliders.Add(collider);
}
}
private void ExplodeAll()
{
List <Slice2D> results = Slicer2D.ExplodeAll(sliceLayer);
if (addForce == true)
{
foreach (Slice2D id in results)
{
foreach (GameObject gameObject in id.gameObjects)
{
Rigidbody2D rigidBody2D = gameObject.GetComponent <Rigidbody2D> ();
if (rigidBody2D)
{
float sliceRotation = Vector2D.Atan2(new Vector2D(0, 0), new Vector2D(gameObject.transform.position));
Rect rect = Polygon2D.CreateFromCollider(gameObject).GetBounds();
Physics2DHelper.AddForceAtPosition(rigidBody2D, new Vector2(Mathf.Cos(sliceRotation) * addForceAmount / 10f, Mathf.Sin(sliceRotation) * addForceAmount / 10f), rect.center);
}
}
if (sliceResultEvent != null)
{
sliceResultEvent(id);
}
}
}
}
void Start()
{
if (GetComponents <Mesh2D>().Length > 1)
{
Slicer2D.Debug.LogError("Multiple 'Mesh2D' components cannot be attached to the same game object");
return;
}
if (GetComponent <Slicer2D>() != null)
{
Slicer2D.Debug.LogError("'Mesh2D' and Slicer2D components cannot be attached to the same game object");
return;
}
// Generate Mesh from collider
Polygon2D polygon = Polygon2D.CreateFromCollider(gameObject);
if (polygon != null)
{
polygon.CreateMesh(gameObject, Vector2.zero, Vector2.zero, triangulation);
// Setting Mesh material
if (material != null)
{
MeshRenderer meshRenderer = GetComponent <MeshRenderer> ();
meshRenderer.material = material;
meshRenderer.sortingLayerName = sortingLayerName;
meshRenderer.sortingLayerID = sortingLayerID;
meshRenderer.sortingOrder = sortingOrder;
}
}
}
// Polygon Scatter Particles Effect
void ExplodePolygon(GameObject CutObject)
{
Slicer2D.explosionPieces = 5;
Slice2D explosionResult = CutObject.GetComponent <Slicer2D>().Explode();
float z = 0f;
foreach (GameObject b in explosionResult.gameObjects)
{
z -= 0.01f;
Slicer2D slicer = b.GetComponent <Slicer2D>();
slicer.Initialize();
Destroy(slicer);
b.AddComponent <DestroyTimer>();
Rigidbody2D rigidBody2D = b.AddComponent <Rigidbody2D>();
b.transform.Translate(0, 0, 1 + z);
if (rigidBody2D)
{
Rect rect = Polygon2D.CreateFromCollider(b).GetBounds();
float sliceRotation = Vector2D.Atan2(new Vector2D(rect.center), new Vector2D(b.transform.position));
Physics2DHelper.AddForceAtPosition(rigidBody2D, new Vector2(Mathf.Cos(sliceRotation) * 351f, Mathf.Sin(sliceRotation) * 351f), rect.center);
}
}
}
private void Explode(Vector2 position)
{
if (fixedJoint != null)
{
Destroy(fixedJoint);
}
transform.SetParent(null);
List <Slice2D> results = Slicer2D.ExplodeAll(BreakableManager.Instance.Slice2DLayer);
if (addedExplosionForceOnBreak > 0)
{
foreach (Slice2D id in results)
{
foreach (GameObject gameObject in id.gameObjects)
{
var joint = gameObject.GetComponent <FixedJoint2D>();
if (joint != null)
{
Destroy(joint);
}
Rigidbody2D rigidBody2D = gameObject.GetComponent <Rigidbody2D>();
if (rigidBody2D)
{
float sliceRotation = Vector2D.Atan2(new Vector2D(position),
new Vector2D(gameObject.transform.position));
Rect rect = Polygon2D.CreateFromCollider(gameObject).GetBounds();
Physics2DHelper.AddForceAtPosition(rigidBody2D, new Vector2(Mathf.Cos(sliceRotation) *
addedExplosionForceOnBreak, Mathf.Sin(sliceRotation) * addedExplosionForceOnBreak), rect.center);
}
}
}
}
}
public Polygon2D GetPolygon()
{
if (polygon == null)
{
polygon = Polygon2D.CreateFromCollider(gameObject);
}
return(polygon);
}
void Start()
{
foreach (Slicer2D slicer in Slicer2D.GetList())
{
startingArea += Polygon2D.CreateFromCollider(slicer.gameObject).ToWorldSpace(slicer.transform).GetArea();
}
instance = this;
}
public Polygon2D GetEdges()
{
if (edges == null)
{
edges = Polygon2D.CreateFromCollider(gameObject);
}
return(edges);
}
public void Start()
{
poly = Polygon2D.CreateFromCollider(gameObject);
if (GetComponent <EdgeCollider2D>() != null)
{
connectedLine = false;
}
}
// Recalculate area that is left
public void UpdateText()
{
leftArea = 0;
foreach (Slicer2D slicer in Slicer2D.GetList())
{
Polygon2D poly = Polygon2D.CreateFromCollider(slicer.gameObject);
leftArea += poly.ToWorldSpace(slicer.gameObject.transform).GetArea();
}
leftArea = ((leftArea) / startingArea) * 100f;
text.text = "Left: " + (int)leftArea + "%";
}
bool SliceIntesectEdges(List <Vector2D> slice)
{
foreach (ThinSliceEdge edge in ThinSliceEdge.GetList())
{
Polygon2D edgePolygon = Polygon2D.CreateFromCollider(edge.gameObject);
if (Math2D.SliceIntersectSlice(slice, edgePolygon.ToWorldSpace(edge.transform).pointsList))
{
return(true);
}
}
return(false);
}
void Update()
{
if (Input.GetKeyDown(KeyCode.Space))
{
float timer = Time.realtimeSinceStartup;
Polygon2D poly = Polygon2D.CreateFromCollider(gameObject).ToWorldSpace(transform);
Slicer2D.ComplexSliceAll(poly.pointsList, Slice2DLayer.Create());
Destroy(gameObject);
Slicer2D.Debug.Log(name + " in " + (Time.realtimeSinceStartup - timer) * 1000 + "ms");
}
}
public void Start()
{
polygon = Polygon2D.CreateFromCollider(gameObject);
Shader shaderAdditive = Shader.Find("Particles/Additive");
Shader shaderMultiply = Shader.Find("Particles/Multiply");
materialAdditive = new Material(shaderAdditive);
materialAdditive.color = Color.white;
materialAdditive.mainTexture = Resources.Load("Textures/Bevel") as Texture;
materialMultiply = new Material(shaderMultiply);
materialMultiply.color = Color.white;
materialMultiply.mainTexture = Resources.Load("Textures/Bevel") as Texture;
}
// After Slice - Get smallest polygon which does not have balls in it
GameObject GetCutGameObject(Slice2D sliceResult)
{
float area = 1e+10f;
GameObject CutObject = null;
foreach (GameObject resultObject in sliceResult.gameObjects)
{
Polygon2D poly = Polygon2D.CreateFromCollider(resultObject);
if (poly.GetArea() < area && PolygonHasBallsInside(poly.ToWorldSpace(resultObject.transform)) == false)
{
CutObject = resultObject;
area = poly.GetArea();
}
}
return(CutObject);
}
public static void SpriteToMesh(GameObject gameObject, VirtualSpriteRenderer spriteRenderer, PolygonTriangulator2D.Triangulation triangulation = PolygonTriangulator2D.Triangulation.Advanced)
{
Texture2D texture = null;
Sprite sprite = null;
if (spriteRenderer.sprite != null)
{
sprite = spriteRenderer.sprite;
texture = sprite.texture;
}
float spriteSheetU = (float)(texture.width) / sprite.rect.width;
float spriteSheetV = (float)(texture.height) / sprite.rect.height;
Rect rect = sprite.rect;
Rect uvRect = new Rect((float)rect.x / texture.width, (float)rect.y / texture.height, (float)rect.width / texture.width, (float)rect.height / texture.height);
Vector2 scale = new Vector2(spriteSheetU * rect.width / sprite.pixelsPerUnit, spriteSheetV * rect.height / spriteRenderer.sprite.pixelsPerUnit);
float pivotX = sprite.pivot.x / sprite.rect.width - 0.5f;
float pivotY = sprite.pivot.y / sprite.rect.height - 0.5f;
float ix = -0.5f + pivotX / spriteSheetU;
float iy = -0.5f + pivotY / spriteSheetV;
Vector2 uvOffset = new Vector2(uvRect.center.x + ix, uvRect.center.y + iy);
Polygon2D polygon2D = Polygon2D.CreateFromCollider(gameObject);
polygon2D.CreateMesh(gameObject, scale, uvOffset, triangulation);
MeshRenderer meshRenderer = gameObject.GetComponent <MeshRenderer> ();
if (meshRenderer == null)
{
meshRenderer = gameObject.AddComponent <MeshRenderer> ();
}
meshRenderer.sharedMaterial = spriteRenderer.material;
meshRenderer.sharedMaterial.mainTexture = texture;
meshRenderer.sharedMaterial.color = spriteRenderer.color;
meshRenderer.sortingLayerName = spriteRenderer.sortingLayerName;
meshRenderer.sortingLayerID = spriteRenderer.sortingLayerID;
meshRenderer.sortingOrder = spriteRenderer.sortingOrder;
}
void Start()
{
// Generate Mesh from collider
Polygon2D polygon = Polygon2D.CreateFromCollider(gameObject);
if (polygon != null)
{
polygon.CreateMesh3D(gameObject, size, Vector2.zero, Vector2.zero, triangulation);
// Setting Mesh material
if (material != null)
{
MeshRenderer meshRenderer = GetComponent <MeshRenderer> ();
meshRenderer.material = material;
meshRenderer.sortingLayerName = sortingLayerName;
meshRenderer.sortingLayerID = sortingLayerID;
meshRenderer.sortingOrder = sortingOrder;
}
}
}
void OnSliceResult(Slice2D sliceResult)
{
if (polygons.Count < 1)
{
return;
}
List <GameObject> gameObjects = new List <GameObject>();
foreach (GameObject p in sliceResult.gameObjects)
{
Polygon2D polyA = Polygon2D.CreateFromCollider(p).ToWorldSpace(p.transform);
bool perform = true;
foreach (Polygon2D polyB in polygons)
{
if (Math2D.PolyCollidePoly(polyA, GetPolygonInWorldSpace(polyB)))
{
perform = false;
}
}
if (perform)
{
gameObjects.Add(p);
}
}
foreach (GameObject p in gameObjects)
{
switch (anchorType)
{
case AnchorType.AttachRigidbody:
if (p.GetComponent <Rigidbody2D> () == null)
{
p.AddComponent <Rigidbody2D> ();
}
p.GetComponent <Rigidbody2D> ().isKinematic = false;
break;
case AnchorType.RemoveConstraints:
if (p.GetComponent <Rigidbody2D> () != null)
{
p.GetComponent <Rigidbody2D> ().constraints = 0;
p.GetComponent <Rigidbody2D>().useAutoMass = true;
}
break;
default:
break;
}
Destroy(p.GetComponent <Slicer2DAnchors>());
}
if (gameObjects.Count > 0)
{
Slice2D newSlice = Slice2D.Create(sliceResult.sliceType);
newSlice.gameObjects = gameObjects;
if ((sliceResultEvent != null))
{
sliceResultEvent(newSlice);
}
}
}
void SliceJointEvent(Slice2D sliceResult)
{
RecalculateJoints();
// Remove Slicer Component Duplicated From Sliced Components
foreach (GameObject g in sliceResult.gameObjects)
{
List <Joint2D> joints = Joint2D.GetJoints(g);
foreach (Joint2D joint in joints)
{
if (Polygon2D.CreateFromCollider(g).PointInPoly(new Vector2D(joint.anchoredJoint2D.anchor)) == false)
{
Destroy(joint.anchoredJoint2D);
}
else
{
if (joint.anchoredJoint2D != null && joint.anchoredJoint2D.connectedBody != null)
{
Slicer2D slicer2D = joint.anchoredJoint2D.connectedBody.gameObject.GetComponent <Slicer2D>();
if (slicer2D != null)
{
slicer2D.RecalculateJoints();
}
}
}
}
}
if (body2D == null)
{
return;
}
// Reconnect Joints To Sliced Bodies
foreach (Joint2D joint in joints)
{
if (joint.anchoredJoint2D == null)
{
continue;
}
foreach (GameObject g in sliceResult.gameObjects)
{
Polygon2D poly = Polygon2D.CreateFromCollider(g);
switch (joint.jointType)
{
case Joint2D.Type.HingeJoint2D:
if (poly.PointInPoly(new Vector2D(Vector2.zero)))
{
joint.anchoredJoint2D.connectedBody = g.GetComponent <Rigidbody2D> ();
}
break;
default:
if (poly.PointInPoly(new Vector2D(joint.anchoredJoint2D.connectedAnchor)))
{
joint.anchoredJoint2D.connectedBody = g.GetComponent <Rigidbody2D> ();
}
break;
}
}
}
}
