/// <summary>
    /// This method destroys the mesh of an gameobject!
    /// This algorithm works by splitting the mesh into smaller objects by slicing the gameobject
    /// by different planes, which will be generated randomly, but all Planes will intersect at one
    /// point specified by the raycastHit.
    /// TODO: Refactoring!
    /// </summary>
    /// <param name="raycastHit">The center point of the destruction</param>
    /// <param name="explosionForce">The force of the explosion</param>
    /// <param name="explosionRadius">The distance from the explosion center</param>
    /// <returns>a list of all destruchtion-fragments</returns>
    public List<Destructor> DestroyGeometry(RaycastHit raycastHit, float explosionForce, float explosionRadius)
    {
        List<Destructor> destructionObjects = new List<Destructor>();

        Vector3 hitpoint = raycastHit.point;
        Vector3 n;
        Plane randomPlane;
        Mesh startMesh = this.GetComponent<MeshFilter>().mesh;

        List<Mesh> destructionParts = new List<Mesh>();
        List<Mesh> currentDestructionParts = new List<Mesh>();
        destructionParts.Add(startMesh);

        uvMapper = uvMapperObject.GetComponent<UVMapper>();

        if (uvMapper != null)
        {
          MeshSlicer slicer = new MeshSlicer(uvMapper);
          //Iterating over all jet existing mesh-fractures.
          //The algorithm uses old created fratures to create new.
          for (int i = 0; i < fractureCount; i++)
          {
        // A random vetor which is used to generate a new random slicing plane.
        n = GenerateRandomVector();
        randomPlane = new Plane(n, hitpoint);

        // Iterating over all yet existing destruction parts and slicing them by the plane
        foreach (Mesh mesh in destructionParts)
        {
          currentDestructionParts.AddRange(slicer.SliceByPlane(mesh, randomPlane, this.transform));
        }
        // the new created destruction parts are the base for the next iteration
        destructionParts = currentDestructionParts;
        currentDestructionParts = new List<Mesh>();
          }

          GameObject destructedObject;
          MeshFilter destructedObjectMeshFilter;
          MeshRenderer destructedObjectMeshRenderer;
          Mesh destructedObjectMesh;
          Vector3 meshMidPoint;
          Mesh currentMesh;
          Vector3 newMeshMidpoint;

          // Creating new Gameobjects by using the meshes generated in the previous step.
          foreach (Mesh mesh in destructionParts)
          {
        if (mesh.vertices.Length > 0 && mesh.triangles.Length > 0)
        {
          // Initializing a new gameobject and bringing its pivot to the center of the objects mesh.
          meshMidPoint = transform.TransformPoint(MeshComponents.GetVerticesMidpoint(mesh.vertices));
          destructedObject = (GameObject)GameObject.Instantiate(this.gameObject, meshMidPoint, Quaternion.identity);
          destructedObjectMeshFilter = destructedObject.GetComponent<MeshFilter>();
          currentMesh = mesh.Translate(DevideVectors(destructedObjectMeshFilter.transform.InverseTransformDirection(transform.position - destructedObject.transform.position), destructedObject.transform.lossyScale));
          newMeshMidpoint = transform.TransformPoint(MeshComponents.GetVerticesMidpoint(currentMesh.vertices));

          // Adding the generated mesh-geometrie to the new created gameobject
          destructedObjectMesh = destructedObjectMeshFilter.mesh;
          destructedObjectMeshRenderer = destructedObject.GetComponent<MeshRenderer>();
          destructedObjectMesh.Clear();
          destructedObjectMeshFilter.mesh = currentMesh;

          //Updating the collider of the gameobject
          ChangeColliderToMeshCollider(destructedObject);
          destructedObject.GetComponent<MeshCollider>().sharedMesh = currentMesh;

          //Adding some explosiontforce to the gameobject foe vfx
          destructedObject.GetComponent<Rigidbody>().AddExplosionForce(explosionForce, raycastHit.point, explosionRadius);

          destructionObjects.Add(destructedObject.GetComponent<Destructor>());
        }
          }
          //After all new fractureparts are generated -> destroy the source.
          DestroyImmediate(this.gameObject);
        }

        return destructionObjects;
    }
    /// <summary>
    /// This method slices the mesh of the Gameobject by the specified plane.
    /// </summary>
    /// <param name="plane">The plane which shall seperate the objects mesh</param>
    public void SliceByPlane(Plane plane)
    {
        uvMapper = uvMapperObject.GetComponent<UVMapper>();

        if (uvMapper != null)
        {
          MeshSlicer slicer = new MeshSlicer(uvMapper);
          MeshFilter meshFilter = this.GetComponent<MeshFilter>();
          Mesh mesh = meshFilter.mesh;
          Mesh[] slicedMeshes = slicer.SliceByPlane(mesh, plane, this.transform);

          meshFilter.mesh.Clear();

          if (slicedMeshes[0].vertices.Length > 0 && slicedMeshes[0].triangles.Length > 0)
          {

        //Setting the mesh of the gameobject which shall be splitted(Fracture1).
        meshFilter.mesh = slicedMeshes[0];

        if (slicedMeshes[1].vertices.Length > 0 && slicedMeshes[1].triangles.Length > 0)
        {
          // copying the the gameobject which should be drestroyed(source)
          GameObject copy = (GameObject)GameObject.Instantiate(this.gameObject);

          // setting the mesh of the copy
          MeshFilter meshFilter2 = copy.GetComponent<MeshFilter>();
          meshFilter2.mesh.Clear();
          meshFilter2.mesh = slicedMeshes[1];

          //Updating the collider of the copied gameobject
          copy.GetComponent<MeshCollider>().sharedMesh = meshFilter2.mesh;
        }
          }
          else if (slicedMeshes[1].vertices.Length > 0 && slicedMeshes[1].triangles.Length > 0)
          {
        meshFilter.mesh = slicedMeshes[1];
          }

          //Updating the collider of this gameobject
          DestroyImmediate(this.GetComponent<MeshCollider>());
          MeshCollider collider1 = this.gameObject.AddComponent<MeshCollider>();
          collider1.convex = true;

        }
    }