*/
  boolean precomputeAccurateTexturing() {
    int o0 = 0;
    int o1 = 1;
    int o2 = 2;

    PMatrix3D myMatrix = new PMatrix3D(vertices[o0][U], vertices[o0][V], 1, 0,
                                       vertices[o1][U], vertices[o1][V], 1, 0,
                                       vertices[o2][U], vertices[o2][V], 1, 0,
                                       0,               0,               0, 1);

    // A 3x3 inversion would be more efficient here,
    // given that the fourth r/c are unity
    boolean invertSuccess = myMatrix.invert();// = myMatrix.invert();

    // If the matrix inversion had trouble, let the caller know.
    // Note that this does not catch everything that could go wrong
    // here, like if the renderer is in ortho() mode (which really
    // must be caught in PGraphics3D instead of here).
    if (!invertSuccess) return false;

    float m00, m01, m02, m10, m11, m12, m20, m21, m22;
    m00 = myMatrix.m00*camX[o0]+myMatrix.m01*camX[o1]+myMatrix.m02*camX[o2];
    m01 = myMatrix.m10*camX[o0]+myMatrix.m11*camX[o1]+myMatrix.m12*camX[o2];
    m02 = myMatrix.m20*camX[o0]+myMatrix.m21*camX[o1]+myMatrix.m22*camX[o2];
    m10 = myMatrix.m00*camY[o0]+myMatrix.m01*camY[o1]+myMatrix.m02*camY[o2];
    m11 = myMatrix.m10*camY[o0]+myMatrix.m11*camY[o1]+myMatrix.m12*camY[o2];
    m12 = myMatrix.m20*camY[o0]+myMatrix.m21*camY[o1]+myMatrix.m22*camY[o2];
    m20 = -(myMatrix.m00*camZ[o0]+myMatrix.m01*camZ[o1]+myMatrix.m02*camZ[o2]);
    m21 = -(myMatrix.m10*camZ[o0]+myMatrix.m11*camZ[o1]+myMatrix.m12*camZ[o2]);
    m22 = -(myMatrix.m20*camZ[o0]+myMatrix.m21*camZ[o1]+myMatrix.m22*camZ[o2]);

    float px = m02;
    float py = m12;
    float pz = m22;

    float TEX_WIDTH = this.twidth;
    float TEX_HEIGHT = this.theight;

    float resultT0x = m00*TEX_WIDTH+m02;
    float resultT0y = m10*TEX_WIDTH+m12;
    float resultT0z = m20*TEX_WIDTH+m22;
    float result0Tx = m01*TEX_HEIGHT+m02;
    float result0Ty = m11*TEX_HEIGHT+m12;
    float result0Tz = m21*TEX_HEIGHT+m22;
    float mx = resultT0x-m02;
    float my = resultT0y-m12;
    float mz = resultT0z-m22;
    float nx = result0Tx-m02;
    float ny = result0Ty-m12;
    float nz = result0Tz-m22;

    //avec = p x n
    ax = (py*nz-pz*ny)*TEX_WIDTH; //F_TEX_WIDTH/HEIGHT?
    ay = (pz*nx-px*nz)*TEX_WIDTH;
    az = (px*ny-py*nx)*TEX_WIDTH;
    //bvec = m x p
    bx = (my*pz-mz*py)*TEX_HEIGHT;
    by = (mz*px-mx*pz)*TEX_HEIGHT;
    bz = (mx*py-my*px)*TEX_HEIGHT;
    //cvec = n x m
    cx = ny*mz-nz*my;
    cy = nz*mx-nx*mz;
    cz = nx*my-ny*mx;

    //System.out.println("a/b/c: "+ax+" " + ay + " " + az + " " + bx + " " + by + " " + bz + " " + cx + " " + cy + " " + cz);

    nearPlaneWidth = (parent.rightScreen-parent.leftScreen);
    nearPlaneHeight = (parent.topScreen-parent.bottomScreen);
    nearPlaneDepth = parent.nearPlane;

    // one pixel width in nearPlane coordinates
    xmult = nearPlaneWidth / parent.width;
    ymult = nearPlaneHeight / parent.height;
    // Extra scalings to map screen plane units to pixel units
//    newax = ax*xmult;
//    newbx = bx*xmult;
//    newcx = cx*xmult;


    //          System.out.println("nearplane: "+ nearPlaneWidth + " " + nearPlaneHeight + " " + nearPlaneDepth);
    //          System.out.println("mults: "+ xmult + " " + ymult);
    //          System.out.println("news: "+ newax + " " + newbx + " " + newcx);
    return true;
  }