static public void ExplodeGameObject(GameObject CutObject, GameObject originObject)
{
Slicer2D slicerA = CutObject.GetComponent <Slicer2D>();
Slicer2D slicerB = originObject.GetComponent <Slicer2D>();
Polygon2D polyA = slicerA.shape.GetWorld();
Polygon2D polyB = slicerB.shape.GetWorld();
Rect boundsA = polyA.GetBounds();
Rect boundsB = polyB.GetBounds();
Vector2D centerA = new Vector2D(boundsA.center);
Vector2D centerB = new Vector2D(boundsB.center);
double direction = (double)Vector2D.Atan2(centerA, centerB);
Rigidbody2D rigidBody2D = CutObject.AddComponent <Rigidbody2D>();
rigidBody2D.AddForce(Vector2D.RotToVec(direction).ToVector2() * 200);
rigidBody2D.AddTorque(Random.Range(-15, 15));
cutObjects++;
CutObject.transform.Translate(0, 0, 100 - cutObjects + CutObject.transform.position.z);
CutObject.AddComponent <Mesh2D>().material = slicerA.materialSettings.material;
CutObject.AddComponent <DestroyTimer>();
UnityEngine.Object.Destroy(CutObject.GetComponent <Slicer2D>());
UnityEngine.Object.Destroy(CutObject.GetComponent <ThinSliceRules>());
}
override public void OnInspectorGUI()
{
Slicer2D script = target as Slicer2D;
script.textureType = (Slicer2D.TextureType)EditorGUILayout.EnumPopup("Texture Type", script.textureType);
script.triangulation = (PolygonTriangulator2D.Triangulation)EditorGUILayout.EnumPopup("Triangulation", script.triangulation);
script.centerOfMass = (Slicer2D.CenterOfMass)EditorGUILayout.EnumPopup("Center of Mass", script.centerOfMass);
if (script.textureType == Slicer2D.TextureType.Mesh2D)
{
script.material = (Material)EditorGUILayout.ObjectField("Material", script.material, typeof(Material), true);
}
if (script.textureType == Slicer2D.TextureType.Mesh3D)
{
script.material = (Material)EditorGUILayout.ObjectField("Material", script.material, typeof(Material), true);
}
script.slicingLayer = (SlicingLayer)EditorGUILayout.EnumPopup("Slicing Layer", script.slicingLayer);
script.slicingLimit = GUILayout.Toggle(script.slicingLimit, "Slicing Limit");
if (script.slicingLimit)
{
script.maxSlices = EditorGUILayout.IntSlider("Max Slices", script.maxSlices, 1, 10);
}
script.recalculateMass = GUILayout.Toggle(script.recalculateMass, "Recalculate Mass");
}
public void CopyTracker(Slice2D slice, Slicer2D slicer)
{
foreach (Demo10LinearTrackedSlicer trackerComponent in Object.FindObjectsOfType <Demo10LinearTrackedSlicer>())
{
if (trackerComponent.trackerObject == this)
{
continue;
}
foreach (LinearSlicerTrackerObject trackerObject in new List <LinearSlicerTrackerObject>(trackerComponent.trackerObject.trackerList))
{
if (trackerObject.slicer != slicer)
{
continue;
}
foreach (GameObject g in slice.gameObjects)
{
LinearSlicerTrackerObject t = trackerComponent.trackerObject.GetSlicerTracker(g.GetComponent <Slicer2D>());
if (t == null)
{
t = new LinearSlicerTrackerObject();
t.slicer = g.GetComponent <Slicer2D>();
t.firstPosition = trackerObject.firstPosition;
t.lastPosition = trackerObject.lastPosition;
t.tracking = true;
trackerComponent.trackerObject.trackerList.Add(t);
}
}
}
}
}
static public void CopyRigidbody2D(Rigidbody2D originalRigidBody, Slicer2D slicer, Polygon2D id, double originArea)
{
if (originalRigidBody)
{
Rigidbody2D newRigidBody = slicer.GetRigibody();
newRigidBody.isKinematic = originalRigidBody.isKinematic;
newRigidBody.velocity = originalRigidBody.velocity;
newRigidBody.drag = originalRigidBody.drag;
newRigidBody.angularVelocity = originalRigidBody.angularVelocity;
newRigidBody.angularDrag = originalRigidBody.angularDrag;
newRigidBody.constraints = originalRigidBody.constraints;
newRigidBody.gravityScale = originalRigidBody.gravityScale;
newRigidBody.collisionDetectionMode = originalRigidBody.collisionDetectionMode;
newRigidBody.sharedMaterial = originalRigidBody.sharedMaterial;
//newRigidBody.sleepMode = originalRigidBody.sleepMode;
//newRigidBody.inertia = originalRigidBody.inertia;
// Center of Mass : Auto / Center
if (slicer.centerOfMass == Slicer2D.CenterOfMass.RigidbodyOnly)
{
newRigidBody.centerOfMass = Vector2.zero;
}
if (slicer.recalculateMass)
{
float newArea = (float)id.ToLocalSpace(slicer.transform).GetArea();
newRigidBody.mass = originalRigidBody.mass * (float)(newArea / originArea);
}
else
{
newRigidBody.mass = originalRigidBody.mass;
}
}
}
private void ComplexSlice(List <Vector2f> slice)
{
List <Slice2D> results = Slicer2D.ComplexSliceAll(slice, sliceLayer);
if (addForce == true)
{
foreach (Slice2D id in results)
{
foreach (GameObject gameObject in id.gameObjects)
{
Rigidbody2D rigidBody2D = gameObject.GetComponent <Rigidbody2D> ();
if (rigidBody2D)
{
List <Pair2f> list = Pair2f.GetList(id.collisions);
float forceVal = 1.0f / list.Count;
foreach (Pair2f p in list)
{
float sliceRotation = -Vector2f.Atan2(p.B, p.A);
Vector2 force = new Vector2(Mathf.Cos(sliceRotation) * addForceAmount, Mathf.Sin(sliceRotation) * addForceAmount);
rigidBody2D.AddForceAtPosition(forceVal * force, (p.A.Get() + p.B.Get()) / 2f);
}
}
}
}
}
}
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);
}
}
}
}
}
private bool ComplexSlice(List <Vector2D> slice)
{
if (sliceJoints)
{
ComplexSliceJoints(slice);
}
List <Slice2D> results = Slicer2D.ComplexSliceAll(slice, sliceLayer);
bool result = false;
foreach (Slice2D id in results)
{
if (id.gameObjects.Count > 0)
{
result = true;
}
if (sliceResultEvent != null)
{
sliceResultEvent(id);
}
}
if (addForce == true)
{
foreach (Slice2D id in results)
{
AddForce.ComplexSlice(id, addForceAmount);
}
}
return(result);
}
public void UpdateSliceAnimations()
{
if (animationPairs.Count < 1)
{
return;
}
if (SlashParticle.GetList().Count > 0)
{
return;
}
Pair2D animationPair = animationPairs.First();
Slicer2D.LinearSliceAll(animationPair);
Vector3 position = animationPair.A.ToVector2();
position.z = -1;
GameObject particleGameObject = Instantiate(particlePrefab, position, Quaternion.Euler(0, 0, (float)Vector2D.Atan2(animationPair.A, animationPair.B) * Mathf.Rad2Deg));
SlashParticle particle = particleGameObject.GetComponent <SlashParticle>();
particle.moveTo = animationPair.B;
animationPairs.Remove(animationPair);
}
private void PointSlice(Vector2D pos)
{
float rotation = 0;
switch (sliceRotation)
{
case SliceRotation.Random:
rotation = UnityEngine.Random.Range(0, Mathf.PI * 2);
break;
case SliceRotation.Vertical:
rotation = Mathf.PI / 2f;
break;
case SliceRotation.Horizontal:
rotation = Mathf.PI;
break;
}
List <Slice2D> results = Slicer2D.PointSliceAll(pos, rotation, sliceLayer);
foreach (Slice2D id in results)
{
if (sliceResultEvent != null)
{
sliceResultEvent(id);
}
}
}
bool ComplexSlice(List <Vector2D> slice)
{
if (sliceJoints)
{
Slicer2DJoints.ComplexSliceJoints(slice);
}
List <Slice2D> results = Slicer2D.ComplexSliceAll(slice, sliceLayer);
bool result = false;
foreach (Slice2D id in results)
{
if (id.GetGameObjects().Count > 0)
{
result = true;
}
eventHandler.Perform(id);
}
if (addForce == true)
{
foreach (Slice2D id in results)
{
Slicer2DAddForce.ComplexSlice(id, addForceAmount);
}
}
return(result);
}
private void LinearSlice(Pair2f slice)
{
List <Slice2D> results = Slicer2D.LinearSliceAll(slice, sliceLayer);
if (addForce == true)
{
float sliceRotation = Vector2f.Atan2(slice.B, slice.A);
foreach (Slice2D id in results)
{
foreach (GameObject gameObject in id.gameObjects)
{
Rigidbody2D rigidBody2D = gameObject.GetComponent <Rigidbody2D> ();
if (rigidBody2D)
{
foreach (Vector2f p in id.collisions)
{
Vector2 force = new Vector2(Mathf.Cos(sliceRotation) * addForceAmount, Mathf.Sin(sliceRotation) * addForceAmount);
rigidBody2D.AddForceAtPosition(force, p.Get());
}
}
}
}
}
cutterCount--;
}
private void UpdateComplexCut(Vector2D pos)
{
if (Input.GetMouseButtonDown(0))
{
complexSlicerPointsList.Clear();
complexSlicerPointsList.Add(pos);
mouseDown = true;
startedSlice = false;
}
if (complexSlicerPointsList.Count < 1)
{
return;
}
if (Input.GetMouseButton(0))
{
Vector2D posMove = new Vector2D(complexSlicerPointsList.Last());
bool added = false;
while ((Vector2D.Distance(posMove, pos) > minVertsDistance * visualScale))
{
float direction = Vector2D.Atan2(pos, posMove);
posMove.Push(direction, minVertsDistance * visualScale);
if (startSliceIfPossible == true && startedSlice == false)
{
if (InSlicerComponents(new Vector2D(posMove)))
{
while (complexSlicerPointsList.Count > 2)
{
complexSlicerPointsList.RemoveAt(0);
}
startedSlice = true;
}
}
complexSlicerPointsList.Add(new Vector2D(posMove));
added = true;
}
if (endSliceIfPossible == true && added)
{
if (ComplexSlice(complexSlicerPointsList) == true)
{
mouseDown = false;
complexSlicerPointsList.Clear();
}
}
}
if (mouseDown == true && Input.GetMouseButton(0) == false)
{
mouseDown = false;
startedSlice = false;
Slicer2D.ComplexCutSliceAll(complexCutLine, sliceLayer);
complexSlicerPointsList.Clear();
}
}
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()
{
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);
}
}
void Start()
{
Slicer2D slicer = GetComponent <Slicer2D>();
slicer.AddEvent(OnSlice);
slicer.AddResultEvent(AfterSlice);
}
// 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);
}
}
}
void SliceEvent(Slice2D slice)
{
FruitSlicerGameManager.instance.score += 15;
foreach (GameObject g in slice.GetGameObjects())
{
Vector3 pos = g.transform.position;
pos.z = Random.Range(pos.z, 50);
g.transform.position = pos;
Rigidbody2D rb = g.GetComponent <Rigidbody2D>();
rb.AddForce(new Vector2(Random.Range(-200, 200), Random.Range(100, 200)));
rb.AddTorque(Random.Range(-100, 100));
//PolygonCollider2D collider = g.GetComponent<PolygonCollider2D>();
//collider.isTrigger = false;
Slicer2D slicer = g.GetComponent <Slicer2D>();
slicer.enabled = false;
//ColliderLineRenderer2D lineRenderer = g.GetComponent<ColliderLineRenderer2D>();
//lineRenderer.customColor = true;
//lineRenderer.color = Color.red;
//lineRenderer.lineWidth = 0.5f;
}
}
public void OnRenderObject()
{
if (Camera.current != Camera.main)
{
return;
}
Max2D.SetLineWidth(0.25f);
Max2D.SetColor(Color.black);
Max2D.SetBorder(false);
Max2D.SetLineMode(Max2D.LineMode.Smooth);
inspectorPosition = Vector3.zero;
Vector2D pos = new Vector2D(Camera.main.ScreenToWorldPoint(Input.mousePosition));
foreach (Slicer2D slicer in Slicer2D.GetList())
{
Polygon2D poly = slicer.GetPolygon().ToWorldSpace(slicer.transform);
if (poly.PointInPoly(pos))
{
Rect rect = poly.GetBounds();
Max2D.DrawLineRectf(rect.x, rect.y, rect.width, rect.height);
Max2D.DrawLinef(rect.center.x, rect.center.y, rect.center.x, rect.center.y + rect.height / 2 + 1);
inspectorPosition = new Vector2(rect.center.x, rect.center.y + rect.height / 2);
originalSize = slicer.GetComponent <Slicer2DInspectorTracker>().originalSize;
currentSize = poly.GetArea();
sliced = slicer.sliceCounter;
}
}
}
public void Update(Vector2D pos)
{
float scroll = Input.GetAxis("Mouse ScrollWheel");
float newCutSize = cutSize + scroll;
if (newCutSize > 0.05f)
{
cutSize = newCutSize;
}
if (input.GetInputClicked())
{
linearPair.A.Set(pos);
}
if (input.GetInputHolding())
{
linearPair.B.Set(pos);
}
if (input.GetInputReleased())
{
LinearCut linearCutLine = LinearCut.Create(linearPair, cutSize * visuals.visualScale);
Slicer2D.LinearCutSliceAll(linearCutLine, sliceLayer);
}
}
public void CopyTracker(Slice2D slice, Slicer2D slicer)
{
foreach (Demo10ComplexTrackedSlicer trackerComponent in Object.FindObjectsOfType <Demo10ComplexTrackedSlicer>())
{
if (trackerComponent.trackerObject == this)
{
continue;
}
foreach (ComplexSlicerTrackerObject trackerObject in new List <ComplexSlicerTrackerObject>(trackerComponent.trackerObject.trackerList))
{
if (trackerObject.slicer != slicer)
{
continue;
}
foreach (GameObject g in slice.gameObjects)
{
ComplexSlicerTrackerObject t = trackerComponent.trackerObject.GetSlicerTracker(g.GetComponent <Slicer2D>());
if (t == null)
{
t = new ComplexSlicerTrackerObject();
t.slicer = g.GetComponent <Slicer2D>();
t.pointsList = new List <Vector2D>(trackerObject.pointsList);
t.tracking = true;
trackerComponent.trackerObject.trackerList.Add(t);
}
}
}
}
}
private void LinearSlice(Pair2D slice)
{
List <Slice2D> results = Slicer2D.LinearSliceAll(slice, null);
if (addForce == false)
{
return;
}
// Adding Physics Forces
float sliceRotation = (float)Vector2D.Atan2(slice.B, slice.A);
foreach (Slice2D id in results)
{
foreach (GameObject gameObject in id.GetGameObjects())
{
Rigidbody2D rigidBody2D = gameObject.GetComponent <Rigidbody2D> ();
if (rigidBody2D == null)
{
continue;
}
foreach (Vector2D p in id.GetCollisions())
{
Physics2DHelper.AddForceAtPosition(rigidBody2D, new Vector2(Mathf.Cos(sliceRotation) * addForceAmount, Mathf.Sin(sliceRotation) * addForceAmount), p.ToVector2());
}
}
}
}
public bool ItersectsWithMap()
{
Polygon2D edges = GetEdges().ToWorldSpace(gameObject.transform);
bool intersect = false;
foreach (Slicer2D slicer in Slicer2D.GetList())
{
Polygon2D polyB = slicer.GetPolygon().ToWorldSpace(slicer.gameObject.transform);
if (Math2D.SliceIntersectPoly(edges.pointsList, polyB))
{
intersect = true;
}
foreach (Vector2D p in edges.pointsList)
{
if (Math2D.PointInPoly(p, polyB))
{
return(true);
}
}
}
return(intersect);
}
void Update()
{
Polygon2D cameraPolygon = Polygon2D.CreateFromCamera(Camera.main);
cameraPolygon = cameraPolygon.ToRotation(Camera.main.transform.rotation.eulerAngles.z * Mathf.Deg2Rad);
cameraPolygon = cameraPolygon.ToOffset(new Vector2D(Camera.main.transform.position));
foreach (Slicer2D slicer in Slicer2D.GetListCopy())
{
if (Math2D.PolyCollidePoly(slicer.shape.GetLocal(), cameraPolygon) == false)
{
if (slicer.enabled == true)
{
lives--;
if (lives >= 0)
{
SpriteRenderer sr = livesObjects[lives].GetComponent <SpriteRenderer>();
sr.color = Color.white;
}
else
{
Debug.Log("lose");
}
}
Destroy(slicer.gameObject);
}
}
scoreText.text = score.ToString();
}
void StartAnchor()
{
bool addEvents = false;
foreach (Collider2D collider in anchorsList)
{
if (collider != null)
{
addEvents = true;
}
}
if (addEvents == false)
{
return;
}
Slicer2D slicer = GetComponent <Slicer2D> ();
if (slicer != null)
{
slicer.AddResultEvent(OnAnchorSliceResult);
slicer.AddEvent(OnAnchorSlice);
}
foreach (Collider2D collider in anchorsList)
{
anchorPolygons.Add(Polygon2DList.CreateFromGameObject(collider.gameObject)[0]);
anchorColliders.Add(collider);
}
}
static public void CopyComponents(Slicer2D slicer, GameObject gObject)
{
Component[] scriptList = slicer.gameObject.GetComponents <Component>();
foreach (Component script in scriptList)
{
if (script == null)
{
continue;
}
// Do not copy Colliders
if (script.GetType().ToString() == "UnityEngine.PolygonCollider2D" || script.GetType().ToString() == "UnityEngine.EdgeCollider2D" || script.GetType().ToString() == "UnityEngine.BoxCollider2D" || script.GetType().ToString() == "UnityEngine.CircleCollider2D" || script.GetType().ToString() == "UnityEngine.CapsuleCollider2D")
{
continue;
}
switch (slicer.textureType)
{
case TextureType.SpriteAnimation:
if (script.GetType().ToString() == "UnityEngine.SpriteRenderer" || script.GetType().ToString() == "UnityEngine.Animator")
{
continue;
}
break;
case TextureType.Sprite:
if (script.GetType().ToString() == "UnityEngine.SpriteRenderer")
{
continue;
}
break;
default:
break;
}
if (script.GetType().ToString() != "UnityEngine.Transform")
{
gObject.AddComponent(script.GetType());
System.Reflection.FieldInfo[] fields = script.GetType().GetFields();
foreach (System.Reflection.FieldInfo field in fields)
{
field.SetValue(gObject.GetComponent(script.GetType()), field.GetValue(script));
}
}
}
foreach (Behaviour childCompnent in gObject.GetComponentsInChildren <Behaviour>())
{
foreach (Behaviour child in slicer.GetComponentsInChildren <Behaviour>())
{
if (child.GetType() == childCompnent.GetType())
{
childCompnent.enabled = child.enabled;
break;
}
}
}
}
public void Update(Vector2 position, float minVertexDistance = 1f)
{
foreach (Slicer2D slicer in Slicer2D.GetList())
{
LinearSlicerTrackerObject tracker = GetSlicerTracker(slicer);
if (tracker == null)
{
tracker = new LinearSlicerTrackerObject();
tracker.slicer = slicer;
trackerList.Add(tracker);
}
Vector2D trackedPos = new Vector2D(slicer.transform.transform.InverseTransformPoint(position));
if (tracker.lastPosition != null)
{
if (slicer.GetPolygon().PointInPoly(trackedPos))
{
if (tracker.tracking == false)
{
//tracker.pointsList.Add(tracker.lastPosition);
tracker.firstPosition = tracker.lastPosition;
}
tracker.tracking = true;
//if (tracker.pointsList.Count < 1 || (Vector2D.Distance (trackedPos, tracker.pointsList.Last ()) > minVertexDistance / 4f)) {
// tracker.pointsList.Add(trackedPos);
//}
}
else if (tracker.tracking == true)
{
tracker.tracking = false;
//tracker.pointsList.Add(trackedPos);
if (tracker.firstPosition != null)
{
tracker.lastPosition = trackedPos;
Pair2D slicePair = new Pair2D(new Vector2D(slicer.transform.TransformPoint(tracker.firstPosition.ToVector2())), new Vector2D(slicer.transform.TransformPoint(tracker.lastPosition.ToVector2())));
Slice2D slice = slicer.LinearSlice(slicePair);
if (slice.gameObjects.Count > 0)
{
CopyTracker(slice, slicer);
}
;
}
trackerList.Remove(tracker);
}
}
if (tracker != null)
{
tracker.lastPosition = trackedPos;
}
}
}
public void UpdateCurrentArea()
{
currentArea = 0f;
foreach (Slicer2D slicer in Slicer2D.GetListCopy())
{
currentArea += slicer.shape.GetLocal().GetArea();
}
}
void Start()
{
foreach (Slicer2D slicer in Slicer2D.GetList())
{
startingArea += Polygon2DList.CreateFromGameObject(slicer.gameObject)[0].ToWorldSpace(slicer.transform).GetArea();
}
instance = this;
}
public void UpdateCurrentArea()
{
currentArea = 0f;
foreach (Slicer2D slicer in Slicer2D.GetList())
{
currentArea += slicer.GetPolygon().GetArea();
}
}
void Awake()
{
Slicer2D slicer = GetComponent <Slicer2D> ();
slicer.AddResultEvent(OnSliceResult);
polygon = Polygon.CreateFromCollider(connector);
}
