3d z-sorting

/**
 * 3D sample code.
 */
public class ThreeD
{
    public static final int FACES_ALIGN = 0;
    public static final int IN_FRONT = 1;
    public static final int BEHIND = 2;
    public static final int INTERSECTS = 3;
    
    /**
     * Compare depth of two faces.
     * 
     * For this to work, the faces must first be transformed according to
     * the rotation and position of the camera, so that:
     *   (0,0,0) is the relative camera position
     *   +z is "in front" of the camera
     *   -z is behind the camera
     *   
     * Returns true if f1 is in front of f2, or false otherwise.
     * 
     */
    public boolean isInFront(Face f1, Face f2)
    {
        int r = compareFaces(f1, f2);
        if (r == IN_FRONT) {
            return false;
        }
        if (r == BEHIND) {
            return true;
        }
        if (r == FACES_ALIGN) {
            // don't care
            return true;
        }
        return isInFront(f2, f1); // reverse the faces and try again
    }
    
    /**
     * Compare two faces in terms of depth from camera.
     * 
     * For this to work, the faces must first be transformed according to
     * the rotation and position of the camera, so that:
     *   (0,0,0) is the relative camera position
     *   +z is "in front" of the camera
     *   -z is behind the camera
     *   
     * returns:
     *   FACES_ALIGN - if neither face is in front of the other
     *   IN_FRONT - if the second face (f2) is in front of the first
     *   BEHIND - if the second face is behind the first
     *   INTERSECTS - if some points of the second face are in front and some are behind,
     *                in this case, call again with f1=f2 and f2=v1
     */
    public int compareFaces(Face f1, Face f2)
    {
        // First we need to consider the first face as a plane. We create
        // two vectors from two of the vertices (note that I'm re-using the
        // Vertex class to hold vectors). These vectors will define the plane:
        Vertex f1a = vectorSub(f1.getV2(), f1.getV1());
        Vertex f2a = vectorSub(f1.getV3(), f1.getV1());
        
        // get cross product:
        Vertex cpv = vectorCP(f1a, f2a);
        
        // if the cross product is zero-magnitude, it's useless. However we
        // would only get that if the face is a line or point (i.e. if two
        // of the vertices are the same), so I'll ignore that possibility for
        // now.
        
        // Now we want the cross product vector to point towards the camera,
        // i.e. negative z.
        if (cpv.getZ() > 0) {
            cpv = new Vertex(-cpv.getX(), -cpv.getY(), -cpv.getZ());
        }
        
        // get the dot product for each of the vertices in the second face
        // to see whether the are behind or in front of the first face:
        
        double v1dp = vectorDP(cpv, vectorSub(f2.getV1(), f1.getV1()));
        double v2dp = vectorDP(cpv, vectorSub(f2.getV2(), f1.getV1()));
        double v3dp = vectorDP(cpv, vectorSub(f2.getV3(), f1.getV1()));
        
        if (v1dp == 0 && v2dp == 0 && v3dp == 0) {
            return FACES_ALIGN;
        }
        
        if (v1dp >= 0 && v2dp >= 0 && v3dp >=0) {
            return IN_FRONT;
        }
        
        if (v1dp <= 0 && v2dp <= 0 && v3dp <= 0) {
            return BEHIND;
        }
        
        return INTERSECTS;
    }
    
    /**
     * Subtract one vector/vertex from another, return a vector result
     */
    public Vertex vectorSub(Vertex v1, Vertex v2)
    {
        double dx = v1.getX() - v2.getX();
        double dy = v1.getY() - v2.getY();
        double dz = v1.getZ() - v2.getZ();
        return new Vertex(dx,dy,dz);
    }
    
    /**
     * Cross-product of two vectors, returns a vector orthogonal to
     * both the original vectors (or a zero-magnitude vector if the
     * original vectors are parallel, or if either of them are zero
     * magnitude).
     */
    public Vertex vectorCP(Vertex v1, Vertex v2)
    {
        double dx = v1.getY() * v2.getZ() - v1.getZ() * v2.getY();
        double dy = v1.getZ() * v2.getX() - v1.getX() * v2.getZ();
        double dz = v1.getX() * v2.getY() - v1.getY() * v2.getX();
        return new Vertex(dx,dy,dz);
    }
    
    public double vectorDP(Vertex v1, Vertex v2)
    {
        return v1.getX() * v2.getX()
            + v1.getY() * v2.getY()
            + v1.getZ() * v2.getZ();
    }
}