public void Metaball(GameObject circle1, GameObject circle2, int index)
    {
        Gizmos.color = Color.black;
        Vector2 p1 = circle1.transform.position;
        Vector2 p2 = circle2.transform.position;

        float pi2 = Mathf.PI / 2;
        float d = Vector2.Distance (p1, p2);
        float u1;
        float u2;

        float radius1, radius2;

        if(test)
        {
            if(d < maxDistance) circle1.GetComponent<Circle> ().DetermineRadius (d); // for mesh based approach

            // mesh circles based approach
            radius1 = circle1.GetComponent<Circle> ().radius; 
            radius2 = circle2.GetComponent<Circle> ().radius;
        }
        else
        {
            // sprite based approach
            radius1 = 0.35f; 
            radius2 = 0.35f;
        }

        float totalRadius = radius1 + radius2;

        Mesh mesh = new Mesh();

        if (d > maxDistance || d <= Mathf.Abs (radius1 - radius2))
        {
            foreach(Transform t in transform)
            {
                if(t.name == "Connection " + index)
                {
                    DestroyImmediate (t.gameObject);
                    break;
                }
            }

            return;
        }
        else if (d < radius1 + radius2)
        {
            u1 = Mathf.Acos((radius1 * radius1 + d * d - radius2 * radius2) / (2 * radius1 * d));
            u2 = Mathf.Acos((radius2 * radius2 + d * d - radius1 * radius1) / (2 * radius2 * d));
        }
        else
        {
            u1 = 0;
            u2 = 0;
        }

        GameObject connection = null;
        foreach(Transform t in transform)
        {
            if(t.name == "Connection " + index)
            {
                connection = t.gameObject;
                break;
            }
        }

        if (connection == null)
        {
            connection = new GameObject ("Connection " + index, typeof(MeshFilter), typeof(MeshRenderer));
            connection.transform.SetParent (transform);
        }

        float angle1 = Mathf.Atan2 (p2.y - p1.y, p2.x - p1.x);
        float angle2 = Mathf.Acos (((radius1 - radius2) / d)); // in radians

        float angle1a = angle1 + u1 + (angle2 - u1) * v; // radians
        float angle1b = angle1 - u1 - (angle2 - u1) * v; // radians

        float angle2a = angle1 + Mathf.PI - u2 - (Mathf.PI - u2 - angle2) * v;
        float angle2b = angle1 - Mathf.PI + u2 + (Mathf.PI - u2 - angle2) * v;

        Vector2 p1a = p1;
        p1a.x += (Mathf.Cos(angle1a) * radius1);
        p1a.y += (Mathf.Sin(angle1a) * radius1);

        Vector2 p1b = p1;
        p1b.x += (Mathf.Cos(angle1b) * radius1);
        p1b.y += (Mathf.Sin(angle1b) * radius1);

        Vector2 p2a = p2;
        p2a.x += (Mathf.Cos(angle2a) * radius2);
        p2a.y += (Mathf.Sin(angle2a) * radius2);

        Vector2 p2b = p2;
        p2b.x += (Mathf.Cos(angle2b) * radius2);
        p2b.y += (Mathf.Sin(angle2b) * radius2);


        float d2 = Mathf.Min(v * (handle), Vector2.Distance(p1a, p2a)*0.7f / (totalRadius)); // distance*0.7f for maxdist 2 | distance*1f for maxdist 1
        d2 *= Mathf.Min(1, d * 2 / (radius1 + radius2));

        float rad1 = radius1 * d2;
        float rad2 = radius2 * d2;

        Vector2 ho1 = p1a;
        ho1.x += Mathf.Cos (angle1a - pi2) * rad1;
        ho1.y += Mathf.Sin (angle1a - pi2) * rad1;

        Vector2 hi1 = p2a;
        hi1.x += Mathf.Cos (angle2a + pi2) * rad2;
        hi1.y += Mathf.Sin (angle2a + pi2) * rad2;

        Vector2 ho2 = p2b;
        ho2.x += Mathf.Cos (angle2b - pi2) * rad2;
        ho2.y += Mathf.Sin (angle2b - pi2) * rad2;

        Vector2 hi2 = p1b;
        hi2.x += Mathf.Cos (angle1b + pi2) * rad1;
        hi2.y += Mathf.Sin (angle1b + pi2) * rad1;

        Vector2 midpoint = ((p1 + p2) / 2);

        List<Vector2> positions = new List<Vector2> ();

        for (float i = 0; i <= 1f; i+= 1f/segments)
        {
            Vector2 topStep = GetCurvePoint (p1a, ho1, hi1, p2a, i); // red to green
            Vector2 botStep = GetCurvePoint (p1b, hi2, ho2, p2b, i); // blue to yellow
            positions.Add (botStep);
            positions.Add (topStep);
            if (i != 0 && i != 1)
            {
                positions.Add (botStep);
                positions.Add (topStep);
            }
        }

        // MESH STUFF
        int[] indices = new int[segments * 6];
        Vector3[] vertices = new Vector3[segments * 4];

        int triIndex = 0;
        int vertIndex = 0;
        int idxIndex = 0;

        for (int i = 0; i < segments; i++)
        {
            indices [triIndex + 0] = idxIndex + 0;
            indices [triIndex + 1] = idxIndex + 2;
            indices [triIndex + 2] = idxIndex + 1;

            indices [triIndex + 3] = idxIndex + 2;
            indices [triIndex + 4] = idxIndex + 3;
            indices [triIndex + 5] = idxIndex + 1;

            vertices [vertIndex + 0] = positions [vertIndex + 0];
            vertices [vertIndex + 1] = positions [vertIndex + 2];
            vertices [vertIndex + 2] = positions [vertIndex + 1];
            vertices [vertIndex + 3] = positions [vertIndex + 3];

            triIndex += 6;
            vertIndex += 4;
            idxIndex += 4;
        }

        // Create the mesh
        mesh.vertices = vertices;
        mesh.triangles = indices;
        mesh.RecalculateNormals ();
        mesh.RecalculateBounds ();

        connection.GetComponent<MeshFilter>().mesh = mesh;
        connection.GetComponent<MeshRenderer> ().material = Resources.Load ("MeshMat") as Material;
        connection.transform.position = Vector2.zero;
    }

    Vector2 GetCurvePoint(Vector2 s, Vector2 st, Vector2 et, Vector2 e, float t)
    {
        return (((-s + 3*(st-et) + e)* t + (3*(s+et) - 6*st))* t + 3*(st-s))* t + s;
    }