static boolean containsOrigin(List<Vector3f> simplex) {
        // If we don't have 4 points, then we can't enclose the origin in R3
        if(simplex.size() < 4)
            return false;
        
        Vector3f a = simplex.get(3); 
        Vector3f b = simplex.get(2); 
        Vector3f c = simplex.get(1); 
        Vector3f d = simplex.get(0); 

        // Compute all the edges we will use first, to avoid computing the same edge twice.
        Vector3f ac = c.minus(a);
        Vector3f ab = b.minus(a);
        Vector3f bc = c.minus(b);
        Vector3f bd = d.minus(b);
        Vector3f ad = d.minus(a);
        Vector3f ba = ab.negate();
        Vector3f ao = a.negate();
        Vector3f bo = b.negate();

        
        /* We need to find the normals of all the faces
         * of a tetrahedron
         * 
         * Tetrahedron net (unfolded)
         * A-----------------B-----------------A
         *  \               / \               /
         *   \             /   \             /
         *    \  AC x AB  /     \  AB x AD  /
         *     \         /       \         /
         *      \       /         \       /
         *       \     /  BC x BD  \     /
         *        \   /             \   /
         *         \ /               \ /
         *          C-----------------D
         *           \               /
         *            \             /
         *             \  AD x AC  /
         *              \         /
         *               \       /
         *                \     /
         *                 \   /
         *                  \ /
         *                   A
         */
        Vector3f abc = ac.cross(ab);
        Vector3f bcd = bc.cross(bd);
        Vector3f adb = ab.cross(ad);
        Vector3f acd = ad.cross(ac);

        /*
         * We don't know which way our sides are described, so we could have an inside out
         * tetrahedron.
         * 
         * So we multiple two dot products, the first tells us which way the normal is facing
         * and the second tells us which way the origin is from that face, if they are the same
         * sign then the origin and the vertex opposite that face are in the same direction.
         * 
         * Since we just want to know if they are the same sign we multiple the two dot products
         * together and see if the product is positive.
         * 
         * For the origin to be within the tetrahedron, it must be on the inside of all four faces.
         */
        return
            (abc.dotProduct(ad) * abc.dotProduct(ao) >= 0.0f) &&
            (bcd.dotProduct(ba) * bcd.dotProduct(bo) >= 0.0f) &&
            (adb.dotProduct(ac) * adb.dotProduct(ao) >= 0.0f) &&
            (acd.dotProduct(ab) * acd.dotProduct(ao) >= 0.0f);
    }