static public Vector3f findTetrahedronSimplex(List<Vector3f> simplex){
        //A is the point added last to the simplex 
        Vector3f a = simplex.get(3); 
        Vector3f b = simplex.get(2); 
        Vector3f c = simplex.get(1); 
        Vector3f d = simplex.get(0); 

        Vector3f ao = a.negate(); 
        Vector3f ab = b.minus(a); 
        Vector3f ac = c.minus(a); 
        Vector3f ad = d.minus(a); 
        Vector3f acd = ac.cross(ad); 
        Vector3f adb = ad.cross(ab); 

        //the side (positive or negative) of B, C and D relative to the planes of ACD, ADB and ABC respectively 
        int BsideOnACD = acd.dotProduct(ab) > 0.0f ? 1 : 0; 
        int CsideOnADB = adb.dotProduct(ac) > 0.0f ? 1 : 0; 

        //whether the origin is on the same side of ACD/ADB/ABC as B, C and D respectively 
        boolean ABsameAsOrigin = (acd.dotProduct(ao) > 0.0f ? 1 : 0) == BsideOnACD; 
        boolean ACsameAsOrigin = (adb.dotProduct(ao) > 0.0f ? 1 : 0) == CsideOnADB; 
        //if the origin is not on the side of B relative to ACD 
        if (!ABsameAsOrigin) { 
            //B is farthest from the origin among all of the tetrahedron's points, so remove it from the list and go on with the triangle case 
            simplex.remove(b); 
            //the new direction is on the other side of ACD, relative to B 
        } 
        //if the origin is not on the side of C relative to ADB 
        else if (!ACsameAsOrigin) { 
            //C is farthest from the origin among all of the tetrahedron's points, so remove it from the list and go on with the triangle case 
            simplex.remove(c); 
            //the new direction is on the other side of ADB, relative to C 
        } 
        //if the origin is not on the side of D relative to ABC 
        else //if (!ADsameAsOrigin) { 
            //D is farthest from the origin among all of the tetrahedron's points, so remove it from the list and go on with the triangle case 
            simplex.remove(d); 
        //the new direction is on the other side of ABC, relative to D 

        //go on with the triangle case 
        //TODO: maybe we should restrict the depth of the recursion, just like we restricted the number of iterations in BodiesIntersect? 
        return findTriangleSimplex(simplex);
    }