BOOLEAN.C

Go to the documentation of this file.

/* --
OpenFX version 2.0 - Modelling, Animation and Rendering Package
Copyright (C) 2000 - 2007 OpenFX Development Team
-- */

/*  BOOLEAN.C  */

#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <windows.h>

#include "struct.h"
#include "dstruct.h"

#define DLG_CUT                     600
#define DLG_CUT_SPLIT_Y             601
#define DLG_CUT_SPLIT_N             602
#define DLG_CUT_BOTH                603
#define DLG_CUT_WORKPIECE           604

#define IDX_MESSAGE1                700

//FILE *debug;

#include "boolean.h"

#define DESELECTED 0
#define SELECTED   1
#define HIDDEN     2
#define INEDITOR   3

static HWND      hParent;
static HINSTANCE hThisInstance;


#if __WATCOMC__
int APIENTRY LibMain(HANDLE hDLL, DWORD dwReason, LPVOID lpReserved){
#else
BOOL WINAPI DllMain(HANDLE hDLL, DWORD dwReason, LPVOID lpReserved){
#endif
  switch (dwReason) {
    case DLL_PROCESS_ATTACH: {
      hThisInstance=hDLL;
      if(hDLL == NULL)MessageBox( GetFocus()," NULL instance",NULL, MB_OK);
      break;
    }
    case DLL_PROCESS_DETACH:
      break;
  }
  return TRUE;
}

#if __SC__
#pragma startaddress(DllMain)
#endif

static BOOL CALLBACK BooleanDlgProc(HWND hwnd, UINT msg,
                             WPARAM wparam, LPARAM lparam){
 BOOL err;
 int i;
 static struct bp {BOOL sp,al;} *dp;
 switch( msg ) {
   case WM_INITDIALOG:
     dp=(struct bp *)lparam;
     if(dp->sp)SendDlgItemMessage(hwnd,DLG_CUT_SPLIT_Y,BM_SETCHECK,TRUE,0);
     else      SendDlgItemMessage(hwnd,DLG_CUT_SPLIT_N,BM_SETCHECK,TRUE,0);
     if(dp->al)SendDlgItemMessage(hwnd,DLG_CUT_BOTH,BM_SETCHECK,TRUE,0);
     else      SendDlgItemMessage(hwnd,DLG_CUT_WORKPIECE,BM_SETCHECK,TRUE,0);
     CentreDlgOnS(hwnd);
     return (TRUE);
   case WM_COMMAND:
      switch(LOWORD(wparam)){
        case IDCANCEL:
          EndDialog(hwnd,FALSE);
          return(TRUE);
        case IDOK:
          if(SendDlgItemMessage(hwnd,DLG_CUT_SPLIT_Y,BM_GETCHECK,0,0))
             dp->sp=TRUE; else dp->sp=FALSE;
          if(SendDlgItemMessage(hwnd,DLG_CUT_BOTH,BM_GETCHECK,0,0))
             dp->al=TRUE; else dp->al=FALSE;
          EndDialog(hwnd,TRUE);
          return(TRUE);
        default:
          break;
      }
      break;
    default: break;
 }
 return(FALSE);
}

BOOL _Xmodeler
 (HWND parent_window,HWND info_window,X__STRUCTURE *lpevi){
 HCURSOR hSave;
 int type,split;
 struct bp {BOOL sp,al;} d;
 lpEVI=lpevi;
 hParent=parent_window;
 d.sp=TRUE; d.al=TRUE;
 if(DialogBoxParam(hThisInstance,MAKEINTRESOURCE(DLG_CUT),hParent,
             (DLGPROC)BooleanDlgProc,(LPARAM)&d) == FALSE)return FALSE;
 if(d.al)type=0;  else type=1;
 if(d.sp)split=1; else split=0;
 hSave=SetCursor(LoadCursor(NULL,IDC_WAIT));
 IntersectObject(type,split);
 SetCursor(hSave);
 return TRUE;
}

static short Del_Swap(vector p, long v1l, long v2l, long v3l){
 /* test to see if edge common to triangle pair  v1,v2,v3  and v1,v2,p */
 /* should be swapped so as to keep the triangles as near equilateral  */
 /* as possible.                                                       */
 vertex *v1,*v2,*v3;
 double cosa,cosb,sina,sinb,sinab;
 vector vp3,v13,v23,va,vb,v1p,v2p;
 v1=(MainVp+v1l); v2=(MainVp+v2l); v3=(MainVp+v3l);
 VECSUB((double)v1->xyz,(double)v3->xyz,v13) O_normalize(v13);
 VECSUB((double)v2->xyz,(double)v3->xyz,v23) O_normalize(v23);
 VECSUB((double)v1->xyz,p,v1p) O_normalize(v1p);
 VECSUB((double)v2->xyz,p,v2p) O_normalize(v2p);
 cosa=DOT(v13,v23);
 cosb=DOT(v1p,v2p);
 if(cosa >= 0.0 && cosb >= 0.0)return 0;     /* a < 90 and b < 90 */
 if(cosa <  0.0 && cosb <  0.0)return 1;
 CROSS(v13,v23,va) sina=va[0]*va[0]+va[1]*va[1]+va[2]*va[2];
 if(sina < 1.e-10)return 0; sina = sqrt(sina);
 CROSS(v2p,v1p,vb) sinb=vb[0]*vb[0]+vb[1]*vb[1]+vb[2]*vb[2];
 if(sinb < 1.e-10)return 0; sinb = sqrt(sinb);
 sinab=sina*cosb+sinb*cosa;
 if(sinab < 0.0)return 1;
 return 0;
}

static long BoolAddVertex(vector v, short status){
 vertex *vv;
 if(!UpdateVertexHeap(Nvert+1)){
   MessageBeep(MB_OK);
   return Nvert-1;
 }
 CreateVertex();
 vv=(MainVp+Nvert-1);
 vv->xyz[0]=(long)v[0];
 vv->xyz[1]=(long)v[1];
 vv->xyz[2]=(long)v[2];
 vv->id=0; vv->status=status;
 if(status == DESELECTED){NvertSelect--; NvertDeselect++;}
 return Nvert-1;
}

static workface *add_small_face(long a, long b, long c,
                                long f, long i, workface *w,
                                long *nface){
  long nf;
  nf = *nface;
  if((w=(workface *)X__Realloc(w,(nf+1)*(long)sizeof(workface)))
       == NULL)return NULL;
  if(!UpdateFaceHeap(Nface+1))return NULL;
  CreateFace(a,b,c);
  CopyFaceProp((MainFp+f),(MainFp+Nface-1));
  w[nf].f=Nface-1;  /* nb:      f = w[i].f */
  VECCOPY(w[i].n,w[nf].n)
  (*nface)++;
  return w;
}

static long Del_Edgeid(long v1, long v2, workface *w, long k,
                       long *fa1, long *fa2, long *e1, long *e2){
 face *f;
 f=(MainFp+w[k].f);
 if((f->V[0] == v1 && f->V[1] == v2) ||
    (f->V[0] == v2 && f->V[1] == v1)){
   *fa1=w[k].fa[1]; *fa2=w[k].fa[2];
   *e1=w[k].ea[1]; *e2=w[k].ea[2];
   return f->V[2];
 }
 else if((f->V[1] == v1 && f->V[2] == v2) ||
         (f->V[1] == v2 && f->V[2] == v1)){
   *fa1=w[k].fa[2]; *fa2=w[k].fa[0];
   *e1=w[k].ea[2]; *e2=w[k].ea[0];
   return f->V[0];
 }
 else if((f->V[2] == v1 && f->V[0] == v2) ||
         (f->V[2] == v2 && f->V[0] == v1)){
   *fa1=w[k].fa[0]; *fa2=w[k].fa[1];
   *e1=w[k].ea[0]; *e2=w[k].ea[1];
   return f->V[1];
 }
 MessageBox(NULL,"Algorithm confused",NULL,MB_OK);
 return -1;
}

static workface *AddDelaunayTriangulation(vector p2, workface *bf1, long bi,
                          long nns,long *nf, workface *w,
                          long *nwe, workedge **we){
 short code,id;
 long i,j,k,l,m,t,n,nn,*Dstack=NULL,Dss=0,fa1,fa2;
 workedge *wee;
 workface *bf;
 vector pa,pb,pc;
 long vp,w0,w1,w2,vo,vt;
 long f1;
 long e0,e1,e2,ep;
 n= *nf;
 /* nns is pointer to original top of work face list before adding new
    faces caused by point p2 being inserted in a work face. */
 for(i=nns;i<=n;i++){ /* find which face this intersects    */
   if(i == n){bf=bf1;   j=bi;} /* use an extra face for the original */
   else      {bf=&w[i]; j=i; }
   f1=bf->f;
   w0=(MainFp+f1)->V[0]; w1=(MainFp+f1)->V[1]; w2=(MainFp+f1)->V[2];
   POINT2VECTOR((MainVp+w0)->xyz,pa)
   POINT2VECTOR((MainVp+w1)->xyz,pb)
   POINT2VECTOR((MainVp+w2)->xyz,pc)
   if(EdgePierceFace(p2,pa,pb,pc,&code,&id) && code == 0){
     vp=BoolAddVertex(p2,DESELECTED);
     if((wee=(workedge *)X__Realloc(*we,(*nwe + 3)*(long)sizeof(workedge)))
               == NULL)return NULL;
     *we=wee;
     if(!UpdateEdgeHeap(Nedge+3))return NULL;
     CreateEdge(vp,w0);
     e0 = *nwe;     wee[e0].e=Nedge-1; wee[e0].t = -1; wee[e0].b=0;
     wee[e0].ea[0] = wee[e0].ea[0] = -1;
     CreateEdge(vp,w1);
     e1 = *nwe + 1; wee[e1].e=Nedge-1; wee[e1].t = -1; wee[e1].b=0;
     wee[e1].ea[0] = wee[e1].ea[1] = -1;
     CreateEdge(vp,w2);
     e2 = *nwe + 2; wee[e2].e=Nedge-1; wee[e2].t = -1; wee[e2].b=0;
     wee[e2].ea[0] = wee[e2].ea[1] = -1;
     *nwe = *nwe + 3;
     if((w=add_small_face(vp,w0,w1,f1,j,w,nf))==NULL)return NULL;
     if((w=add_small_face(vp,w2,w0,f1,j,w,nf))==NULL)return NULL;
     (MainFp+f1)->V[0]=vp;       /* modify this face       */
     nn = *nf;
     w[nn-2].fa[0]=nn-1;         /* adjacency in new faces */
     w[nn-2].fa[1]=w[j].fa[0];
     w[nn-2].fa[2]=j;
     w[nn-1].fa[0]=j;
     w[nn-1].fa[1]=w[j].fa[2];
     w[nn-1].fa[2]=nn-2;
     if((k=w[j].fa[0]) >= 0){   /* change adjacency in adjacent */
       for(l=0;l<3;l++)if(w[k].fa[l] == j)w[k].fa[l]=nn-2;
     }
     if((k=w[j].fa[2]) >= 0){
       for(l=0;l<3;l++)if(w[k].fa[l] == j)w[k].fa[l]=nn-1;
     }
     w[j].fa[0]=nn-2;           /*  change adjacency in this face */
     w[j].fa[2]=nn-1;
     w[nn-2].ea[0]=e0;
     w[nn-2].ea[1]=w[j].ea[0];
     w[nn-2].ea[2]=e1;
     w[nn-1].ea[0]=e2;
     w[nn-1].ea[1]=w[j].ea[2];
     w[nn-1].ea[2]=e0;
     w[j].ea[0]=e1;
     w[j].ea[2]=e2;
     if(Dstack == NULL){
       if((Dstack=(long *)X__Malloc(sizeof(long)*(3)))
                 == NULL)return NULL;
     }
     else {
       if((Dstack=(long *)X__Realloc(Dstack,sizeof(long)*(Dss+3)))
                 == NULL)return NULL;
     }
     if(w[j].fa[1] >= 0)   { Dstack[Dss] = j;    Dss++;}
     if(w[nn-2].fa[1] >= 0){ Dstack[Dss] = nn-2; Dss++;}
     if(w[nn-1].fa[1] >= 0){ Dstack[Dss] = nn-1; Dss++;}
     while(Dss > 0){
       Dss--;
       j=Dstack[Dss]; k=w[j].fa[1];
       if(Dss > 0){
         if((Dstack=(long *)X__Realloc(Dstack,sizeof(long)*(Dss))) == NULL){
           return NULL;  /* pop off top of stack */
         }
       }
       if((vo=Del_Edgeid((MainFp+(w[j].f))->V[1],
                         (MainFp+(w[j].f))->V[2],w,k,
                         &fa1,&fa2,&e1,&e2)) < 0)return NULL;
       if(Del_Swap(p2,(MainFp+(w[j].f))->V[1],(MainFp+(w[j].f))->V[2],vo)){
         e0=w[j].ea[1];
         if((m=w[j].fa[2]) >= 0){   /* change adjacency in adjacent */
           for(l=0;l<3;l++)if(w[m].fa[l] == j)w[m].fa[l]=k;
         }
         if(fa1 >= 0){
           for(l=0;l<3;l++)if(w[fa1].fa[l] == k)w[fa1].fa[l]=j;
         }
         (MainEp+wee[e0].e)->V[0]=vp;
         (MainEp+wee[e0].e)->V[1]=vo; /* reverse edge */
         vt=(MainFp+(w[j].f))->V[2];
         (MainFp+(w[j].f))->V[2]=vo;   /* update face j */
         w[j].fa[1]=fa1; t=w[j].fa[2]; w[j].fa[2]=k;
         w[j].ea[1]=e1; ep=w[j].ea[2]; w[j].ea[2]=e0;
         (MainFp+(w[k].f))->V[0]=vp;
         (MainFp+(w[k].f))->V[1]=vo;
         (MainFp+(w[k].f))->V[2]=vt; /* face k */
         w[k].fa[0]=j; w[k].fa[1]=fa2; w[k].fa[2]=t;
         w[k].ea[0]=e0; w[k].ea[1]=e2; w[k].ea[2]=ep;
         if((Dstack=(long *)X__Realloc(Dstack,sizeof(long)*(Dss+2))) == NULL){
           return NULL;  /* push both onto stackstack */
         }
         if(w[j].fa[1] >= 0){Dstack[Dss] = j; Dss++;}
         if(w[k].fa[1] >= 0){Dstack[Dss] = k; Dss++;}
       }
     }
     if(Dstack != NULL)X__Free(Dstack);
     return w; /* intersection found */
   }
 }
 return w;
}

static workface *split_edge(vector p2, long edgeID,
                            workface *w, workedge **e,
                            long *nface, long *nedge, long *vid){
 /* split faces attached to edge edgeID - keep adjacency information */
 long nf,i,j,k,l,m,fid,f1id,f2id,faid,e1id,e2id,a0,a1,a2,e0,e1,e2,fai[2],fx;
 long s,vp,q1,q2;
 face *f;
 workedge *be;
 long ep;
 nf=*nface;
 be = *e;
 ep=be[edgeID].e;
 if(!UpdateVertexHeap(Nvert+1))return NULL;
 vp=BoolAddVertex(p2,DESELECTED);
 /* identify this new vertex */
 (MainVp+vp)->id=(long)(*vid); *vid = (*vid) + 1;
 q1=(MainEp+ep)->V[0]; q2=(MainEp+ep)->V[1];
 if(!UpdateEdgeHeap(Nedge+1))return NULL;
 CreateEdge(vp,(MainEp+ep)->V[1]); (MainEp+ep)->V[1]=vp;
 if((be=(workedge *)X__Realloc(be,((*nedge)+1)*(long)sizeof(workedge)))
       == NULL)return NULL;
 /* new edge is not internal */
 be[*nedge].e=Nedge-1; be[*nedge].t=0;  be[*nedge].b=0;
 *e=be; e1id = *nedge;
 (*nedge)++;
 f1id=be[edgeID].ea[0]; f2id=be[edgeID].ea[1];
 fid=f1id;
 for(i=0;i<2;i++){
   if(fid >= 0){
     fx=w[fid].f; f=(MainFp+fx);
     if     (f->V[0] == q1 && f->V[1] == q2){ s=f->V[2]; k=1; l=0; m=2; }
     else if(f->V[0] == q2 && f->V[1] == q1){ s=f->V[2]; k=2; l=0; m=1; }
     else if(f->V[1] == q1 && f->V[2] == q2){ s=f->V[0]; k=2; l=1; m=0; }
     else if(f->V[1] == q2 && f->V[2] == q1){ s=f->V[0]; k=0; l=1; m=2; }
     else if(f->V[2] == q1 && f->V[0] == q2){ s=f->V[1]; k=0; l=2; m=1; }
     else if(f->V[2] == q2 && f->V[0] == q1){ s=f->V[1]; k=1; l=2; m=0; }
     else return NULL;
     a0=w[fid].fa[k]; a1=w[fid].fa[l]; a2=w[fid].fa[m]; /* consistent */
     e0=w[fid].ea[k]; e1=w[fid].ea[l]; e2=w[fid].ea[m]; /* numbering  */
     f->V[0]=s; f->V[1]=vp; f->V[2]=q1; /* shrink original face */
     if(!UpdateEdgeHeap(Nedge+1))return NULL;
     CreateEdge(s,vp);         /* offset vertex to vertex at p2 */
     if((be=(workedge *)X__Realloc(be,sizeof(workedge)*((*nedge) + 1))) == NULL)
        return NULL;
     be[*nedge].e=Nedge-1;
     be[*nedge].t=1;  /* this is an internal edge in phase 2 */
     be[*nedge].b=0; *e=be;
     e2id = *nedge;
     (*nedge)++;
     if((w=add_small_face(s,q2,vp,fx,fid,w,nface)) == NULL)return NULL;
     faid = (*nface) - 1;
     w[fid].fa[0]=faid; w[fid].fa[1]=a1; w[fid].fa[2]=a2;
     w[fid].ea[0]=e2id; w[fid].ea[1]=e1; w[fid].ea[2]=e2;
     w[faid].fa[0]=a0; w[faid].fa[1]=a1; w[faid].fa[2]=fid;
     w[faid].ea[0]=e0; w[faid].ea[1]=e1id; w[faid].ea[2]=e2id;
     if(a0 >= 0)for(j=0;j<3;j++){ /* fix up adjacent face */
       if(w[a0].fa[j] == fid)w[a0].fa[j]=faid;
     }
     be[e2id].ea[0]=fid; be[e2id].ea[1]=faid;
     for(j=0;j<2;j++){ /* fix up edge adjacency */
       if(be[e0].ea[j] == fid)be[e0].ea[j]=faid;
     }
     be[e1id].ea[i]=faid;
     fai[i]=faid;
   }
   else be[e1id].ea[i] = -1; /* extra bit of cut edge has no other side */
   fid=f2id;
 }
 if(f1id >= 0 && f2id >= 0){   /* fix adjacent info face in new faces   */
   w[fai[0]].fa[1] = fai[1];
   w[fai[1]].fa[1] = fai[0];
 }
 return w;
}

static void switch_adjacent_faces(long edgeID, workface *w, long nf,
                                   workedge *we, long ne){
 /* switch diagonal edgeID in two adjacent faces and tidy up */
 long i,fid1,fid2,k,l,m;
 long a0,a1,a2,e0,e1,e2,b0,b1,b2,d0,d1,d2;
 long q1,q2,s1=-1,s2=-1;
 face *f1,*f2;
 edge *e;
 e=(MainEp+we[edgeID].e);
 q1=e->V[0]; q2=e->V[1];
 fid1=we[edgeID].ea[0]; fid2=we[edgeID].ea[1];
 f1=(MainFp+w[fid1].f); f2=(MainFp+w[fid2].f);
 if     (f1->V[0] == q1 && f1->V[1] == q2){ s1=f1->V[2]; k=1; l=0; m=2; }
 else if(f1->V[0] == q2 && f1->V[1] == q1){ s1=f1->V[2]; k=2; l=0; m=1; }
 else if(f1->V[1] == q1 && f1->V[2] == q2){ s1=f1->V[0]; k=2; l=1; m=0; }
 else if(f1->V[1] == q2 && f1->V[2] == q1){ s1=f1->V[0]; k=0; l=1; m=2; }
 else if(f1->V[2] == q1 && f1->V[0] == q2){ s1=f1->V[1]; k=0; l=2; m=1; }
 else if(f1->V[2] == q2 && f1->V[0] == q1){ s1=f1->V[1]; k=1; l=2; m=0; }
 /* numbering starts at s1 - clockwise */
 a0=w[fid1].fa[k]; a1=w[fid1].fa[l]; a2=w[fid1].fa[m]; /* consistent */
 e0=w[fid1].ea[k]; e1=w[fid1].ea[l]; e2=w[fid1].ea[m]; /* numbering  */
 if     (f2->V[0] == q1 && f2->V[1] == q2){ s2=f2->V[2]; k=1; l=0; m=2; }
 else if(f2->V[0] == q2 && f2->V[1] == q1){ s2=f2->V[2]; k=2; l=0; m=1; }
 else if(f2->V[1] == q1 && f2->V[2] == q2){ s2=f2->V[0]; k=2; l=1; m=0; }
 else if(f2->V[1] == q2 && f2->V[2] == q1){ s2=f2->V[0]; k=0; l=1; m=2; }
 else if(f2->V[2] == q1 && f2->V[0] == q2){ s2=f2->V[1]; k=0; l=2; m=1; }
 else if(f2->V[2] == q2 && f2->V[0] == q1){ s2=f2->V[1]; k=1; l=2; m=0; }
 /* for second face opposite winding */
 b0=w[fid2].fa[m]; b1=w[fid2].fa[l]; b2=w[fid2].fa[k]; /* consistent */
 d0=w[fid2].ea[m]; d1=w[fid2].ea[l]; d2=w[fid2].ea[k]; /* numbering  */
 if(s1 < 0 || s2 < 0){
   MessageBeep(MB_OK);
   return;
 }
 e->V[0]=s1; e->V[1]=s2;     /* opposite edge same face adjacency    */
 f1->V[0]=s1; f1->V[1]=s2; f1->V[2]=q1;
 w[fid1].fa[0]=fid2; w[fid1].fa[1]=b0; w[fid1].fa[2]=a2;
 w[fid1].ea[0]=edgeID; w[fid1].ea[1]=d0; w[fid1].ea[2]=e2;
 f2->V[0]=s1; f2->V[1]=q2; f2->V[2]=s2;
 w[fid2].fa[0]=a0; w[fid2].fa[1]=b2; w[fid2].fa[2]=fid1;
 w[fid2].ea[0]=e0; w[fid2].ea[1]=d2; w[fid2].ea[2]=edgeID;
 /* reset adjacency information in adjacent faces - a0 and b0 */
 if(a0 >= 0)for(i=0;i<3;i++){
   if(w[a0].fa[i] == fid1)w[a0].fa[i]=fid2;
 }
 if(b0 >= 0)for(i=0;i<3;i++){
   if(w[b0].fa[i] == fid2)w[b0].fa[i]=fid1;
 }
 /* and for edge e0 and d0 */
 for(i=0;i<2;i++){
   if(we[e0].ea[i] == fid1)we[e0].ea[i]=fid2;
   if(we[d0].ea[i] == fid2)we[d0].ea[i]=fid1;
 }
}

static int can_switch_faces(long edgeID, workface *w, workedge *we){
 /* test to see if faces adjacent to edge edgeID can be swapped    */
 /* they can be swapped if edge "edgeID" would remain internal to  */
 /* both faces after any swappping takes place - use vector cross  */
 /* product for edges adjacent to q1 and q2 (not e) and test that  */
 /* crosses point in same direction ie. c1 dot c2 > 0. Note all    */
 /* vectors lie in the same plane as they originated in the same   */
 /* original triangular face.                                      */
 long fid1,fid2;
 long q1,q2,s1=-1,s2=-1;
 face *f1,*f2;
 edge *e;
 vector vs1q1,vs2q1,vs1q2,vs2q2,va,vb;
 e=(MainEp+we[edgeID].e);
 q1=e->V[0]; q2=e->V[1];
 fid1=we[edgeID].ea[0]; fid2=we[edgeID].ea[1];
 f1=(MainFp+w[fid1].f); f2=(MainFp+w[fid2].f);
 if     (f1->V[0] == q1 && f1->V[1] == q2)s1=f1->V[2];
 else if(f1->V[0] == q2 && f1->V[1] == q1)s1=f1->V[2];
 else if(f1->V[1] == q1 && f1->V[2] == q2)s1=f1->V[0];
 else if(f1->V[1] == q2 && f1->V[2] == q1)s1=f1->V[0];
 else if(f1->V[2] == q1 && f1->V[0] == q2)s1=f1->V[1];
 else if(f1->V[2] == q2 && f1->V[0] == q1)s1=f1->V[1];
 if     (f2->V[0] == q1 && f2->V[1] == q2)s2=f2->V[2];
 else if(f2->V[0] == q2 && f2->V[1] == q1)s2=f2->V[2];
 else if(f2->V[1] == q1 && f2->V[2] == q2)s2=f2->V[0];
 else if(f2->V[1] == q2 && f2->V[2] == q1)s2=f2->V[0];
 else if(f2->V[2] == q1 && f2->V[0] == q2)s2=f2->V[1];
 else if(f2->V[2] == q2 && f2->V[0] == q1)s2=f2->V[1];
 if(s1 < 0 || s2 < 0){
   MessageBeep(MB_OK);
   return 0; /* should never happen */
 }
 VECSUB((double)(MainVp+s1)->xyz,(double)(MainVp+q1)->xyz,vs1q1)
        O_normalize(vs1q1);
 VECSUB((double)(MainVp+s2)->xyz,(double)(MainVp+q1)->xyz,vs2q1)
        O_normalize(vs2q1);
 VECSUB((double)(MainVp+s1)->xyz,(double)(MainVp+q2)->xyz,vs1q2)
        O_normalize(vs1q2);
 VECSUB((double)(MainVp+s2)->xyz,(double)(MainVp+q2)->xyz,vs2q2)
        O_normalize(vs2q2);
 CROSS(vs2q1,vs1q1,va)
 CROSS(vs1q2,vs2q2,vb)
 if(DOT(va,vb) > 0.0)return 1; /* OK  */
 return 0;                     /* Bad */
}

static int lastID,NF,NE;
static workface *WF;
static workedge *WE;

static void SetConnectingID(long id){
 long eid;
 WF[id].id=lastID;
 if(WF[id].ea[0] >= 0 && WE[WF[id].ea[0]].b == 0 &&
   WF[id].fa[0] >= 0 && WF[WF[id].fa[0]].id < 0)
   SetConnectingID(WF[id].fa[0]);
 if(WF[id].ea[1] >= 0 && WE[WF[id].ea[1]].b == 0 &&
   WF[id].fa[1] >= 0 && WF[WF[id].fa[1]].id < 0)
   SetConnectingID(WF[id].fa[1]);
 if(WF[id].ea[2] >= 0 && WE[WF[id].ea[2]].b == 0 &&
   WF[id].fa[2] >= 0 && WF[WF[id].fa[2]].id < 0)
   SetConnectingID(WF[id].fa[2]);
}

static void FindBitsAndPieces(workface *wf, long nf,
                             workedge *we, long ne, long pid){
 face *f;
 edge *e;
 vertex *vp,*Vp,*v0,*v1,*v2;
 long LastVp;
 long c,i,id,nvs,k,inc,Nvert1,Nface1,Nedge1;
 char str[16],pass1[]="Work",pass2[]="Tool";
 double x,y,z;
 lastID=0;
 NF=nf; NE=ne;
 WF=wf; WE=we;
 for(i=0;i<nf;i++)wf[i].id = -1;
 while(1){ /* keep going until all the bits have been processed */
   for(id=0;id<nf;id++){
     if(wf[id].id == -1)goto PROCESSIT;
   }
   break;      /* no bits have been found - so breakout */
   PROCESSIT:
   SetConnectingID(id);
   lastID++;
 }
 /* now split up the bits and pieces by copying and deleting old workpiece */
 if(lastID < 1)return; /* no bits found so don't do any cutting */
#if 0
for(i=0;i<nf;i++){
f=(MainFp+wf[i].f);
if     (wf[i].id == 0){ f->color[0]=255; f->color[1]=  0; f->color[2]=  0;}
else if(wf[i].id == 1){ f->color[0]=  0; f->color[1]=255; f->color[2]=  0;}
else if(wf[i].id == 2){ f->color[0]=  0; f->color[1]=  0; f->color[2]=255;}
else if(wf[i].id == 3){ f->color[0]=255; f->color[1]=255; f->color[2]=  0;}
else if(wf[i].id == 4){ f->color[0]=  0; f->color[1]=255; f->color[2]=255;}
else if(wf[i].id == 5){ f->color[0]=255; f->color[1]=  0; f->color[2]=255;}
}
return;
#endif
 LastVp=Nvert;
 for(id=0;id<lastID;id++){
   vp=MainVp; for(c=0;c<Nvert;c++){vp->id=0; vp++;}/* flag */
   for(i=0;i<nf;i++){ /* flag all vertices for faces in bit "id" */
     if(wf[i].id == id){ /* this bit */
       f=(MainFp+wf[i].f);
       (MainVp+(f->V[0]))->id=1;
       (MainVp+(f->V[1]))->id=1;
       (MainVp+(f->V[2]))->id=1;
     }
   }
   x=y=z=0.0;
   /* assign copy IDs to vertices and count */
   nvs=0; vp=MainVp; for(c=0;c<Nvert;c++){
     if(vp->id == 1){
       x += (double)vp->xyz[0];
       y += (double)vp->xyz[1];
       z += (double)vp->xyz[2];
       nvs++;
     }
     vp++;
   }
   CreateSkeleton(FirstSp); /* For each "bit" create a Skeleton node */
   ZeroSkeletonBoundingBox(MainSp);
   if(pid == 1)sprintf(str,"%s-%ld",pass1,id+1);
   else        sprintf(str,"%s-%ld",pass2,id+1);
   MainSp->xyz[0]=(long)(x/(double)nvs);
   MainSp->xyz[1]=(long)(y/(double)nvs);
   MainSp->xyz[2]=(long)(z/(double)nvs);
   strcpy(MainSp->name,str);
   for(Nedge1=0,i=0;i<ne;i++){ /* count edges and faces */
     inc=0;
     if((k=we[i].ea[0]) >= 0 && wf[k].id == id)inc=1;
     if((k=we[i].ea[1]) >= 0 && wf[k].id == id)inc=1;
     if(inc == 1)Nedge1++;
   }
   for(Nface1=0,i=0;i<nf;i++){if(wf[i].id == id)Nface1++;}
   if(nvs > 0 && Nedge1 > 0 && Nface1 > 0 &&
      UpdateVertexHeap(Nvert+nvs)  &&  /* make space */
      UpdateEdgeHeap(Nedge+Nedge1) &&
      UpdateFaceHeap(Nface+Nface1)){
     Nvert1=Nvert; nvs=0; vp=MainVp; for(c=0;c<Nvert1;c++){
       if(vp->id == 1){
         CreateVertex();
         Vp=(MainVp+Nvert-1);
         Vp->sp=MainSp;
         VECCOPY(vp->xyz,Vp->xyz)
         vp->id=(long)Nvert-1;
         Vp->status=DESELECTED;
         NvertSelect--; NvertDeselect++;
         nvs++;
       }
       else vp->id = -1;
       vp++;
     }
     for(i=0;i<nf;i++){ /* duplicate faces             */
       if(wf[i].id == id){ /* face is part of this bit */
         f=(MainFp+wf[i].f);
         v0=(MainVp+(f->V[0])); v1=(MainVp+(f->V[1])); v2=(MainVp+(f->V[2]));
         CreateFace(v0->id,v1->id,v2->id);
         CopyFaceProp(f,(MainFp+Nface-1));
       }
     }
     for(i=0;i<ne;i++){ /* duplicate edges */
       inc=0;
       if((k=we[i].ea[0]) >= 0 && wf[k].id == id)inc=1;
       if((k=we[i].ea[1]) >= 0 && wf[k].id == id)inc=1;
       if(inc == 1){ /* this is an edge in this part */
         e=(MainEp+we[i].e);
         v0=(MainVp+(e->V[0])); v1=(MainVp+(e->V[1]));
         CreateEdge(v0->id,v1->id);
       }
     }
   }
 }
 vp=MainVp; for(c=0;c<LastVp;c++){ /* flag vertices for deletion */
   if(vp->status == SELECTED){
     vp->status=INEDITOR; NvertSelect--; NvertDeselect++;

   }
   else if(vp->status == DESELECTED){
     vp->status=SELECTED; NvertSelect++; NvertDeselect--;
   }
   vp++;
 }
 EraseVertex(1);
 vp=MainVp; for(c=0;c<Nvert;c++){
   if(vp->status == INEDITOR){
     vp->status=SELECTED; NvertSelect++; NvertDeselect--;
   }
   vp++;
 }
 return;
}

static int FindAdjFaces(workface *wf, long nf, workedge *we, long ne){
 edge *e;
 face *f;
 vertex *vp;
 vtxadj *vl=NULL;
 long c,nvl=0;
 long *fl,i,j,k,id,id0,id1,id2,fjd,fkd,n,m,kk,nl[3],ml[3];
 vp=MainVp; for(c=0;c<Nvert;c++){
   if(vp->status == DESELECTED){ /* work vertex */
     vp->id=nvl;
     nvl++;
   }
   else vp->id = -10; /* just for fun */
   vp++;
 }
 if((vl=(vtxadj *)X__Malloc(nvl*sizeof(vtxadj))) == NULL)return 0;
 for(i=0;i<nvl;i++){
   vl[i].nf=0; vl[i].ne=0;
   vl[i].flist=NULL; vl[i].elist=NULL;
 }
 for(i=0;i<nf;i++){ /* make list of work faces attached to each vertex */
   f=(MainFp+wf[i].f);
   for(j=0;j<3;j++){
     id=(MainVp+(f->V[j]))->id;
     fl=vl[id].flist;
     n=vl[id].nf;
     if(fl == NULL){
       if((fl=(long *)X__Malloc(sizeof(long))) == NULL)return 0;
     }
     else{
       if((fl=(long *)X__Realloc(fl,(n+1)*sizeof(long))) == NULL)return 0;
     }
     fl[n]=i;
     vl[id].flist=fl;
     vl[id].nf=n+1;
   }
 }
 for(i=0;i<nf;i++){ /* find faces that are adjacent to face i */
   f=(MainFp+wf[i].f);
   id0=(MainVp+(f->V[0]))->id;
   id1=(MainVp+(f->V[1]))->id;
   id2=(MainVp+(f->V[2]))->id;
   nl[0]=id0; ml[0]=id1;
   nl[1]=id1; ml[1]=id2;
   nl[2]=id2; ml[2]=id0;
   for(kk=0;kk<3;kk++){
     wf[i].fa[kk] = -1;
     if((n=vl[nl[kk]].nf) > 0 && (m=vl[ml[kk]].nf) > 0){
       for(j=0;j<n;j++){
         fjd=vl[nl[kk]].flist[j];
         for(k=0;k<m;k++){
           fkd=vl[ml[kk]].flist[k];
           if(fkd == fjd && fkd != i){
             wf[i].fa[kk]=fkd;
             goto ENDF;
           }
         }
       }
     }
     ENDF:;
   }
 }
 for(i=0;i<ne;i++){ /* find faces that are adjacent to edge i */
   e=(MainEp+we[i].e);
   id0=(MainVp+(e->V[0]))->id; id1=(MainVp+(e->V[1]))->id;
   kk=0; we[i].ea[0] = we[i].ea[1] = -1;
   if((n=vl[id0].nf) > 0 && (m=vl[id1].nf) > 0){
     for(j=0;j<n;j++){
       fjd=vl[id0].flist[j];
       for(k=0;k<m;k++){
         fkd=vl[id1].flist[k];
         if(fkd == fjd){
           we[i].ea[kk]=fkd;
           kk++;
           if(kk == 2)goto ENDEE;  /* terminate when we have two */
         }
       }
     }
     ENDEE:;
   }
 }
 for(i=0;i<ne;i++){ /* make list of work edges attached to each vertex */
   e=(MainEp+we[i].e);
   for(j=0;j<2;j++){
     id=(MainVp+(e->V[j]))->id;
     fl=vl[id].elist;
     n=vl[id].ne;
     if(fl == NULL){
       if((fl=(long *)X__Malloc(sizeof(long))) == NULL)return 0;
     }
     else {
       if((fl=(long *)X__Realloc(fl,(n+1)*sizeof(long))) == NULL)return 0;
     }
     fl[n]=i;
     vl[id].elist=fl;
     vl[id].ne=n+1;
   }
 }
 for(i=0;i<nf;i++){ /* find edges that are adjacent to face i */
   f=(MainFp+wf[i].f);
   id0=(MainVp+(f->V[0]))->id;
   id1=(MainVp+(f->V[1]))->id;
   id2=(MainVp+(f->V[2]))->id;
   nl[0]=id0; ml[0]=id1;
   nl[1]=id1; ml[1]=id2;
   nl[2]=id2; ml[2]=id0;
   for(kk=0;kk<3;kk++){
     wf[i].ea[kk] = -1;
     if((n=vl[nl[kk]].ne) > 0 && (m=vl[ml[kk]].ne) > 0){
       for(j=0;j<n;j++){
         fjd=vl[nl[kk]].elist[j];
         for(k=0;k<m;k++){
           fkd=vl[ml[kk]].elist[k];
           if(fkd == fjd){
             wf[i].ea[kk]=fkd;
             goto ENDE;
           }
         }
       }
     }
     ENDE:;
   }
 }
 for(i=0;i<nvl;i++){
   if(vl[i].flist != NULL)X__Free(vl[i].flist);
   if(vl[i].elist != NULL)X__Free(vl[i].elist);
 }
 X__Free(vl);
 return nvl;
}

static void IntersectObject(int work_only, int split){
 /* workface is the face being worked on */
 /* tool face is the face doing the cutting */
 workedge *we,*wee;
 tooledge *te,*xe;
 workface *w;
 toolface *t,*x;
 face *ff1;
 long f1;
 vertex *vpp,*v0,*v1,*v2;
 long vp,w0,w1,w2;
 edge *ep;
 short xn;
 long e0,e1,e2;
 long c,i,j,k,l,nwf,nns,passID,LastVtxID,StartVertex;
 vector du,dv,n,pa,pb,pc,p0,p1,p2;
 long n_tool_face=0,n_work_face=0,n_tool_edge=0,n_work_edge=0,
      x_tool_face=0,x_tool_edge=0,n_hidden_face=0,n_bad_face=0;
 unsigned char key,ekey,first_time=1;
 if(NvertSelect == 0 || NvertDeselect == 0)return;
 if(NvertSelect > 32000)return;
 if((ff1=MainFp) == NULL)return;
 StartVertex=Nvert;
//debug=fopen("D:debug","w");
 vpp=MainVp; for(i=0;i<Nvert;i++){
   vpp->id=0; vpp++;
 }
 t=NULL; w=NULL; te=NULL; we=NULL; x=NULL; xe=NULL;
 for(c=0;c<Nface;c++){ /* find number of work and tool faces */
   v0=(MainVp+ff1->V[0]); v1=(MainVp+ff1->V[1]); v2=(MainVp+ff1->V[2]);
   if(v0->status == SELECTED &&
      v1->status == SELECTED &&
      v2->status == SELECTED)n_tool_face++;
   else if(v0->status == DESELECTED &&
           v1->status == DESELECTED &&
           v2->status == DESELECTED)n_work_face++;
   else if(v0->status == HIDDEN &&
           v1->status == HIDDEN &&
           v2->status == HIDDEN)n_hidden_face++;
   else  n_bad_face++;
   ff1++;
 }
 if(n_bad_face > 0){
   char str[256];
   LoadString(hThisInstance,IDX_MESSAGE1,str,255);
   MessageBox(NULL,str,NULL,MB_OK);
   return;
 }
 if((t=(toolface *)X__Malloc(n_tool_face*(long)sizeof(toolface)))
       == NULL)goto BERR;
 if((w=(workface *)X__Malloc(n_work_face*(long)sizeof(workface)))
       == NULL)goto BERR;
 x_tool_face=n_work_face;
 if((x=(toolface *)X__Malloc(x_tool_face*(long)sizeof(toolface)))
       == NULL)goto BERR;
 n_work_face=0; n_tool_face=0; x_tool_face=0;
 for(ff1=MainFp,c=0;c<Nface;c++){
  v0=(MainVp+ff1->V[0]); v1=(MainVp+ff1->V[1]); v2=(MainVp+ff1->V[2]);
  POINT2VECTOR(v0->xyz,p0)
  POINT2VECTOR(v1->xyz,p1)
  POINT2VECTOR(v2->xyz,p2)
  VECSUB(p1,p0,dv)
  VECSUB(p2,p0,du)
  if(v0->status == SELECTED &&
     v1->status == SELECTED &&
     v2->status == SELECTED){
    CROSS(dv,du,n)
    if(O_normalize(n) == FAIL){
      VECSUB(p0,p1,dv)
      VECSUB(p2,p1,du)
      CROSS(dv,du,n)
      if(O_normalize(n) == FAIL){
        VECSUB(p0,p2,dv)
        VECSUB(p1,p2,du)
        CROSS(dv,du,n)
        if(O_normalize(n) == FAIL)goto BERR2;
      }
    }
    t[n_tool_face].f=c;
    VECCOPY(v0->xyz,t[n_tool_face].p0)  /* note VECCOPY is a macro */
    VECCOPY(v1->xyz,t[n_tool_face].p1)  /* OK for POINTS as well   */
    VECCOPY(v2->xyz,t[n_tool_face].p2)
    VECCOPY(n,t[n_tool_face].n)
    n_tool_face++;
  }
  else if(v0->status == DESELECTED &&
          v1->status == DESELECTED &&
          v2->status == DESELECTED){
   w[n_work_face].f=c;
    for(i=0;i<3;i++){
      w[n_work_face].fa[i] = -1;
      w[n_work_face].ea[i] = -1;
    }
    CROSS(dv,du,n)
    if(O_normalize(n) == FAIL){
      VECSUB(p0,p1,dv)
      VECSUB(p2,p1,du)
      CROSS(dv,du,n)
      if(O_normalize(n) == FAIL){
        VECSUB(p0,p2,dv)
        VECSUB(p1,p2,du)
        CROSS(dv,du,n)
        if(O_normalize(n) == FAIL)goto BERR2;
      }
    }
    VECCOPY(n,w[n_work_face].n)
    VECCOPY(v0->xyz,x[x_tool_face].p0)  /* make copy for use by when */
    VECCOPY(v1->xyz,x[x_tool_face].p1)  /* this becomes the tool     */
    VECCOPY(v2->xyz,x[x_tool_face].p2)
    VECCOPY(n,x[x_tool_face].n)
    x[x_tool_face].f=c;  /* this is not really needed */
    x_tool_face++;
    n_work_face++;
  }
  ff1++;
 }
 for(ep=MainEp,c=0;c<Nedge;c++){
   v0=(MainVp+ep->V[0]); v1=(MainVp+ep->V[1]);
   if(v0->status == SELECTED && v1->status == SELECTED)n_tool_edge++;
   else if(v0->status == DESELECTED && v1->status == DESELECTED){
     n_work_edge++;
     x_tool_edge++;
   }
   ep++;
 }
 if((te=(tooledge *)X__Malloc(n_tool_edge*(long)sizeof(tooledge)))
      == NULL)goto BERR;
 if((we=(workedge *)X__Malloc(n_work_edge*(long)sizeof(workedge)))
      == NULL)goto BERR;
 if((xe=(tooledge *)X__Malloc(x_tool_edge*(long)sizeof(tooledge)))
      == NULL)goto BERR;
 n_tool_edge=0; n_work_edge=0; x_tool_edge=0;
 for(ep=MainEp,c=0;c<Nedge;c++){ /* get all tool edges */
   v0=(MainVp+ep->V[0]); v1=(MainVp+ep->V[1]);
   if(v0->status == SELECTED && v1->status == SELECTED){
     POINT2VECTOR(v0->xyz,te[n_tool_edge].p0)
     POINT2VECTOR(v1->xyz,te[n_tool_edge].p1)
     te[n_tool_edge].e=c;
     n_tool_edge++;
   }
   else if(v0->status == DESELECTED && v1->status == DESELECTED){
     we[n_work_edge].e=c;    /* get all the workface edges - these      */
     we[n_work_edge].t=0;    /* are the original workface edges, pass 1 */
     we[n_work_edge].b=0;    /* will add lots of new edges              */
     we[n_work_edge].ea[0] = we[n_work_edge].ea[1] = -1;
     n_work_edge++;
     POINT2VECTOR(v0->xyz,xe[x_tool_edge].p0) /* make copy of work  */
     POINT2VECTOR(v1->xyz,xe[x_tool_edge].p1) /* edges for use when */
     xe[x_tool_edge].e=c;                     /* this becomes tool  */
     x_tool_edge++;
   }
   ep++;
 }
 if(n_work_face == 0 || n_tool_face == 0)goto QUIT;
 passID=1;
 SECONDCUT:
 nwf=n_work_face;
 for(i=0;i<nwf;i++){ /* make intersection in work face due to tool */
   f1=w[i].f;
   w0=(MainFp+f1)->V[0]; w1=(MainFp+f1)->V[1]; w2=(MainFp+f1)->V[2];
   POINT2VECTOR((MainVp+w0)->xyz,pa)
   POINT2VECTOR((MainVp+w1)->xyz,pb)
   POINT2VECTOR((MainVp+w2)->xyz,pc)
   nns=n_work_face;
   /* find tool edges that intersects workface i (any of the original wfs) */
   for(j=0;j<n_tool_edge;j++){
     if(EdgeThroughFace(pa,pb,pc,w[i].n,te[j].p0,te[j].p1,p2,0)){
       if(nns == n_work_face){ /* first subdivision  1->3 faces */
         vp=BoolAddVertex(p2,DESELECTED);
         if((wee=(workedge *)X__Realloc(we,(n_work_edge+3)*(long)sizeof(workedge)))
               == NULL)goto BERR;
         we=wee;
         if(!UpdateEdgeHeap(Nedge+3))goto BERR;
         CreateEdge(vp,w0);  /* id this edge as a phase 1 added edge */
         e0=n_work_edge;   we[e0].e=Nedge-1;  we[e0].t = -1;  we[e0].b=0;
         we[e0].ea[0] = we[e0].ea[1] = -1;
         CreateEdge(vp,w1);
         e1=n_work_edge+1; we[e1].e=Nedge-1;  we[e1].t = -1;  we[e1].b=0;
         we[e1].ea[0] = we[e1].ea[1] = -1;
         CreateEdge(vp,w2);
         e2=n_work_edge+2; we[e2].e=Nedge-1;  we[e2].t = -1;  we[e2].b=0;
         we[e2].ea[0] = we[e2].ea[1] = -1;
         n_work_edge+=3;
         if((w=add_small_face(vp,w0,w1,f1,i,w,&n_work_face))==NULL)goto BERR;
         if((w=add_small_face(vp,w2,w0,f1,i,w,&n_work_face))==NULL)goto BERR;
         (MainFp+f1)->V[0]=vp;   /* modify this face                   */
         /* fix up adjacency info */
         w[n_work_face - 2].fa[0]=n_work_face-1;
         w[n_work_face - 2].fa[1]=w[i].fa[0];
         w[n_work_face - 2].fa[2]=i;
         w[n_work_face - 1].fa[0]=i;
         w[n_work_face - 1].fa[1]=w[i].fa[2];
         w[n_work_face - 1].fa[2]=n_work_face-2;
         if((k=w[i].fa[0]) >= 0){   /* change adjacency in adjacent */
           for(l=0;l<3;l++)if(w[k].fa[l] == j)w[k].fa[l]=n_work_face-2;
         }
         if((k=w[i].fa[2]) >= 0){
           for(l=0;l<3;l++)if(w[k].fa[l] == j)w[k].fa[l]=n_work_face-1;
         }
         w[i].fa[0]=n_work_face-2;
         w[i].fa[2]=n_work_face-1;
         w[n_work_face - 2].ea[0]=e0;
         w[n_work_face - 2].ea[1]=w[i].ea[0];
         w[n_work_face - 2].ea[2]=e1;
         w[n_work_face - 1].ea[0]=e2;
         w[n_work_face - 1].ea[1]=w[i].ea[2];
         w[n_work_face - 1].ea[2]=e0;
         w[i].ea[0]=e1;
         w[i].ea[2]=e2;
       }
       else{
         /* add vertext at p2 in wf(i) or any of it's subdivisions -
            then go on to optimize the triangulation of any faces internal
            to original wf(i) */
         if((w=AddDelaunayTriangulation(p2,&w[i],i,nns,&n_work_face,w,
                &n_work_edge,&we)) == NULL)goto BERR;
       }
     }
   }
   if(GetAsyncKeyState(VK_ESCAPE) & 0x8000){
     MessageBeep(MB_OK);
     goto QUIT;
   }
 }
 LastVtxID=FindAdjFaces(w,n_work_face,we,n_work_edge);
 /* iterative procedure for more optimal triangulation */
 for(i=0;i<n_tool_face;i++){ /* check original workface edge into tool */
   POINT2VECTOR(t[i].p0,pa)
   POINT2VECTOR(t[i].p1,pb)
   POINT2VECTOR(t[i].p2,pc)
   VECCOPY(t[i].n,n)
   nns=n_work_edge;
   for(j=0;j<nns;j++){
     if(we[j].t != 0)continue;  /* only original workface edges */
     ep=(MainEp+we[j].e);
     POINT2VECTOR((MainVp+(ep->V[0]))->xyz,p0)
     POINT2VECTOR((MainVp+(ep->V[1]))->xyz,p1)
     if((xn=EdgeThroughFace(pa,pb,pc,n,p0,p1,p2,2)) == 1){
       if((w=split_edge(p2,j,w,&we,&n_work_face,&n_work_edge,&LastVtxID))
             == NULL || we == NULL)goto BERR;
     }
     else if(xn == 2){ /* this is a boundary edge */
       we[j].b=1;
     }
   }
   if(GetAsyncKeyState(VK_ESCAPE) & 0x8000){
     MessageBeep(MB_OK);
     goto QUIT;
   }
 }
 for(i=0;i<n_tool_face;i++){ /* check workface edge into tool */
   POINT2VECTOR(t[i].p0,pa)
   POINT2VECTOR(t[i].p1,pb)
   POINT2VECTOR(t[i].p2,pc)
   VECCOPY(t[i].n,n)
   ITERATE: nns=0;
   for(j=0;j<n_work_edge;j++){  /* no more edges required  */
     if(we[j].t == 0)continue;  /* skip any original edges */
     if(we[j].b)continue;       /* ship boundary edges     */
     ep=(MainEp+we[j].e);
     POINT2VECTOR((MainVp+(ep->V[0]))->xyz,p0)
     POINT2VECTOR((MainVp+(ep->V[1]))->xyz,p1)
     if((xn=EdgeThroughFace(pa,pb,pc,n,p0,p1,p2,2)) == 1){
       if(can_switch_faces(j,w,we)){
         switch_adjacent_faces(j,w,n_work_face,we,n_work_edge);
         POINT2VECTOR((MainVp+(ep->V[0]))->xyz,p0)
         POINT2VECTOR((MainVp+(ep->V[1]))->xyz,p1)
         if(EdgeThroughFace(pa,pb,pc,n,p0,p1,p2,2) == 2){
           we[j].b=1; /* swapped edge is boundary */
         }
       }
       else{
         nns=1; /* raise flag => can't swap - try again later */
       }
     }
     else if(xn == 2){ /* this is a boundary edge */
       we[j].b=1;
     }
   }
   if(GetAsyncKeyState(VK_ESCAPE) & 0x8000){
     MessageBeep(MB_OK);
     goto QUIT;
   }
   if(nns)goto ITERATE;
 }
 if(split)FindBitsAndPieces(w,n_work_face,we,n_work_edge,passID);
 if(first_time && (! work_only)){ /* swap the tool and workface - use old workface as tool */
   first_time=0;
   X__Free(we); we=NULL; n_work_edge=0;
   n_work_edge=n_tool_edge;  /* make new work edges from the tool edges */
   if((we=(workedge *)X__Malloc(n_work_edge*(long)sizeof(workedge)))
           == NULL)goto BERR;
   for(i=0;i<n_tool_edge;i++){
       we[i].e=te[i].e;
       we[i].t=0; we[i].b=0;
       we[i].ea[0] = we[i].ea[1] = -1;
   }
   X__Free(te); te=xe;xe=NULL; n_tool_edge=x_tool_edge; /* new tool edges */
   X__Free(w); w=NULL; n_work_face=0;
   n_work_face=n_tool_face;
   if((w=(workface *)X__Malloc(n_work_face*(long)sizeof(workface)))
          == NULL)goto BERR;
   for(i=0;i<n_tool_face;i++){ /* make new work faces from the tool faces */
     w[i].f=t[i].f;
     for(j=0;j<3;j++){
       w[i].fa[j] = -1;
       w[i].ea[j] = -1;
     }
     VECCOPY(t[i].n,w[i].n)
   }
   X__Free(t);  t=x;  x=NULL;  n_tool_face=x_tool_face; /* new tool faces */
   vpp=MainVp; for(c=0;c<Nvert;c++){
     if(vpp->status == SELECTED){
       vpp->status=DESELECTED; NvertSelect--; NvertDeselect++;
     }
     else if(vpp->status == DESELECTED){
       vpp->status=SELECTED; NvertSelect++; NvertDeselect--;
     }
     vpp++;
   }
   passID=2;
   goto SECONDCUT;
 }
 goto QUIT;
 BERR2:
 MessageBox(NULL,"Normal - Problem",NULL,MB_OK); goto QUIT;
 BERR:
 MessageBox(NULL,"Memory Error",NULL,MB_OK);
 QUIT:
 if(t != NULL)X__Free(t);
 if(w != NULL)X__Free(w);
 if(te != NULL)X__Free(te);
 if(we != NULL)X__Free(we);
 if(x != NULL)X__Free(x);
 if(xe != NULL)X__Free(xe);
//fclose(debug);
 return;
}