UTILITY.C

Go to the documentation of this file.

/* --
OpenFX - Modelling, Animation and Rendering Package
-- */


/* file UTILITY.C  utility files for the designer */

// Include the code to generate the primitive shapes

#define MODULE_UTILS 1

#include "design.h"

char *TruncateTextString(char *input, char *output, long length){
 if(strlen(input) < length)return input;
 strncpy(output,input,3); output[3]='\0';
 strcat(output,"....\\");
 strcat(output,FileInPath(input));
 if(strlen(output) > length)return FileInPath(input);
 return output;
}

static long VertexHeapSize=0,EdgeHeapSize=0,FaceHeapSize=0;

void EraseAll(short what){  /* What = 1 = all  =0  VEFS only */
 char filename[MAX_DIR];
 long i,j;
 if(MainFp != NULL)X__Free(MainFp); MainFp=NULL;
 if(MainVp != NULL)X__Free(MainVp); MainVp=NULL;
 if(MainEp != NULL)X__Free(MainEp); MainEp=NULL;
 Nvert=0; Nface=0; Nedge=0; NvertSelect=0; NvertDeselect=0;
 VertexHeapSize=0,EdgeHeapSize=0,FaceHeapSize=0;
 if(Bcurves != NULL && N_Bcurves > 0){
   for(i=0;i<N_Bcurves;i++){
     if(Bcurves[i].Vc != NULL)X__Free(Bcurves[i].Vc);
     if(Bcurves[i].Vp != NULL)X__Free(Bcurves[i].Vp);
   }
   X__Free(Bcurves); Bcurves=NULL; N_Bcurves=0;
 }
 EraseAllSkeleton();
 EraseAllNurbs();
 if(what == 0)return;
 if(nImaps > 0){
   for(i=0;i<nImaps;i++){
     if(iMap[i].s && iMap[i].S != NULL)X__Free(iMap[i].S);
     iMap[i].S=NULL; iMap[i].s=0;
     if(iMap[i].r && iMap[i].R != NULL)X__Free(iMap[i].R);
     iMap[i].R=NULL; iMap[i].r=0;
     if(iMap[i].b && iMap[i].B != NULL)X__Free(iMap[i].B);
     iMap[i].B=NULL; iMap[i].b=0;
     if(iMap[i].t && iMap[i].T != NULL)X__Free(iMap[i].T);
     iMap[i].T=NULL; iMap[i].t=0;
     UnloadRamImage(&(iMap[i].si));
     UnloadRamImage(&(iMap[i].ri));
     UnloadRamImage(&(iMap[i].bi));
     UnloadRamImage(&(iMap[i].ti));
   }
   nImaps=0; nLockediMaps=0;
 }
 if(nMats > 0){ // need to free 
   for(i=0;i<nMats;i++)for(j=0;j<4;j++){
    if(iMat[i].Shader[j].in_use && iMat[i].Shader[j].parameters != NULL)X__Free(iMat[i].Shader[j].parameters);
    if(iMat[i].Shader[j].in_use && iMat[i].Shader[j].xname != NULL)X__Free(iMat[i].Shader[j].xname);
   }
 }
 nMats=0; 
 if(w_frame.p != NULL)X__Free(w_frame.p); w_frame.p=NULL; w_frame.Np=0;
 if(w_frame.e != NULL)X__Free(w_frame.e); w_frame.e=NULL; w_frame.Ne=0;
 ShadowFlag=NO;
 MirrorFlag = -1;
 CheckMenuItem(GetMenu(ghwnd_main),IDM_ATTRIBUTES_SHADOW,MF_UNCHECKED);
 ObjectAxis.Origin.xyz[0]=ObjectAxis.Origin.xyz[1]=ObjectAxis.Origin.xyz[2]=0;
 ObjectAxis.Offset.xyz[0]=ObjectAxis.Offset.xyz[1]=ObjectAxis.Offset.xyz[2]=0;
 GetTriview(TRUE);
 grid_size=UNIT;
 NpointerX=0; NpointerY=0; NpointerZ=0;
 sprintf(filename,"%sW_$.SCR",TempPath);
 remove(filename);
 sprintf(filename,"%sW_$.MFX",TempPath);
 remove(filename);
 EDIT_ACTION=NO;
}

void EraseAllSkeleton(void){
 skel *temps;
 long i;
 if(Nvert > 0)for(i=0;i<Nvert;i++){
   (MainVp+i)->sp=NULL;
 }
 while(MainSp != NULL)
 { temps=MainSp->last; X__Free(MainSp); MainSp=temps;
 } Nskel=0;
 CreateSkeleton(NULL); /* leave at least a root node for skeleton */
 FirstSp=MainSp;
 current_skeleton=FirstSp;
 FirstSp->xyz[0]=FirstSp->xyz[1]=FirstSp->xyz[2]=0;
 UpdateSkTreeView();
}

void Delete_Bcurve(void){
  long i,j,n,flag=1;
  long *v;
  vertex *Vp;
  if(Bcurves == NULL || N_Bcurves == 0)return;
  for(i=0;i<N_Bcurves;i++){
    Bcurves[i].flag=0;
    if((v=Bcurves[i].Vc) != NULL)for(j=0;j<Bcurves[i].Nc;j++){
      if(Vp->status == SELECTED){Bcurves[i].flag=1; flag=0; break;}
    }
    if((v=Bcurves[i].Vp) != NULL)for(j=0;j<Bcurves[i].Np;j++){
      Vp=(MainVp+v[j]);
      if(Vp->status == SELECTED){Bcurves[i].flag=1; flag=0; break;}
    }
  }
  if(flag)return;   /* nothing to delete */
  n=N_Bcurves-1;
  for(i=n;i>=0;i--){
    if(Bcurves[i].flag){
      if(Bcurves[i].Vc != NULL)X__Free(Bcurves[i].Vc);
      if(Bcurves[i].Vp != NULL)X__Free(Bcurves[i].Vp);
      if(i < N_Bcurves-1){ /* shift the list if necessary */
        for(j=i;j<N_Bcurves-1;j++){
          Bcurves[j].Nc = Bcurves[j+1].Nc; Bcurves[j].Vc = Bcurves[j+1].Vc;
          Bcurves[j].Np = Bcurves[j+1].Np; Bcurves[j].Vp = Bcurves[j+1].Vp;
          strcpy(Bcurves[j].name,Bcurves[j+1].name);
        }
      }
      N_Bcurves--;
    }
  }
  /* this will reduce memory so no need to check but do it anyway */
  Bcurves = (bezier_curve *)X__Realloc(Bcurves,sizeof(bezier_curve)*N_Bcurves);
  if(Bcurves == NULL)N_Bcurves=0; /* just silently loose everything */
  /* some RAM may be lost permanently but if Bcurves is NULL then we have */
  /* so little RAM left that we will have to close down anyway */
}

void Delete_MapLock(void){
 long i;
 vertex *vp0,*vp1,*vp2;
 if(nLockediMaps == 0)return;
 for(i=0;i<nImaps;i++){
   if(iMap[i].Lock){
     vp0=(MainVp+iMap[i].Vlock[0]);
     vp1=(MainVp+iMap[i].Vlock[1]);
     vp2=(MainVp+iMap[i].Vlock[2]);
     if(vp0->status == SELECTED ||
        vp1->status == SELECTED ||
        vp2->status == SELECTED){
       iMap[i].Lock=0;
       nLockediMaps--;
     }
   }
 }
 if(nLockediMaps < 0)nLockediMaps=0;
}

void RecalibrateMapLocks(void){
 long i,j;
 if(nLockediMaps == 0)return;
 for(i=0;i<nImaps;i++){
   if(iMap[i].Lock){
     for(j=0;j<3;j++){
       iMap[i].P[j] = (MainVp+iMap[i].Vlock[0])->xyz[j];
       iMap[i].X[j] = (MainVp+iMap[i].Vlock[1])->xyz[j];
       iMap[i].Y[j] = (MainVp+iMap[i].Vlock[2])->xyz[j];
     }
   }
 }
}

short EraseSkeleton(skel *thisone){
 skel *sp,*sptemp;
 if(thisone == FirstSp){ /* cannot delete the main node */
   SendPrgmQuery(IDQ_NODELETESKROOT,0);
   return 0;
 }
// NB this will be needed later         thisone->at->offset=0;
 current_skeleton=thisone->at;
 sp=MainSp;
 while(sp != NULL){ /* reset any bones attached to this one */
   if(sp->at == thisone)sp->at = thisone->at;
   sp=sp->last;
 }
 sp=MainSp;
 while(sp != NULL){
   if(sp == thisone){ /* delete this bone */
     if(sp == MainSp){
       MainSp=sp->last;
       if(MainSp != NULL)MainSp->next=NULL;
       X__Free(sp); sp=MainSp;
     }
     else{
       (sp->next)->last=sp->last;
       if(sp->last != NULL)(sp->last)->next=sp->next;
       sptemp=sp->last;
       X__Free(sp);
       sp=sptemp;
     }
     Nskel--;
     return 1;
   }
   sp=sp->last;
 }
 return 0;
}

int EraseEdge(int mem_update){
 int idid=NO;
 long  i,NewC;
 face *fp;
 edge *ep;
 vertex *V0,*V1,*V2;
 NewC=Nface; fp=MainFp; if(MainFp != NULL)for(i=0;i<Nface;i++){
   V0=(MainVp+fp->V[0]); V1=(MainVp+fp->V[1]); V2=(MainVp+fp->V[2]);
   if(  (V0->status == SELECTED && V1->status == SELECTED)
      ||(V1->status == SELECTED && V2->status == SELECTED)
      ||(V2->status == SELECTED && V0->status == SELECTED) ){
     if(i < Nface-1)CopyMemory(fp,(MainFp+NewC-1),sizeof(face));
     NewC--;
   }
   else fp++;
 }
 if(NewC != Nface){
   idid=YES;
   Nface=NewC;
   if(mem_update)UpdateFaceHeap(Nface);
 }
 NewC=Nedge; ep=MainEp; if(MainEp != NULL)for(i=0;i<Nedge;i++){
   V0=(MainVp+ep->V[0]); V1=(MainVp+ep->V[1]);
   if(V0->status == SELECTED  && V1->status == SELECTED){
     if(i < Nedge-1)CopyMemory(ep,(MainEp+NewC-1),sizeof(edge));
     NewC--;
   }
   else ep++;
 }
 if(NewC != Nedge){
   idid=YES;
   Nedge=NewC;
   if(mem_update)UpdateEdgeHeap(Nedge);
 }
 return idid;
}

int EraseVertex(int mem_update){
 int idid=NO;
 long  i,k,NewC;
 vertex *vp,*vo;
 face   *fp;
 edge   *ep;
 vertex *V0,*V1,*V2;
 NewC=Nface; fp=MainFp; if(MainFp != NULL)for(i=0;i<Nface;i++){
   V0=(MainVp+fp->V[0]); V1=(MainVp+fp->V[1]); V2=(MainVp+fp->V[2]);
   if(   V0->status == SELECTED
      || V1->status == SELECTED
      || V2->status == SELECTED ){
     if(i < Nface-1)CopyMemory(fp,(MainFp+NewC-1),sizeof(face));
     NewC--;
   }
   else fp++;
 }
 if(NewC != Nface){
   idid=YES;
   Nface=NewC;
   if(mem_update)UpdateFaceHeap(Nface);
 }
 NewC=Nedge; ep=MainEp; if(MainEp != NULL)for(i=0;i<Nedge;i++){
   V0=(MainVp+ep->V[0]); V1=(MainVp+ep->V[1]);
   if(V0->status == SELECTED  || V1->status == SELECTED){
     if(i < Nedge-1)CopyMemory(ep,(MainEp+NewC-1),sizeof(edge));
     NewC--;
   }
   else ep++;
 }
 if(NewC != Nedge){
   idid=YES;
   Nedge=NewC;
   if(mem_update)UpdateEdgeHeap(Nedge);
 }
 Delete_Bcurve(); Delete_MapLock();
 NewC=Nvert; vp=MainVp; if(MainVp != NULL)for(i=0,k=0;i<Nvert;i++){
   if(vp->status == SELECTED){
     NvertSelect--;
     if(i < Nvert-1){
       vo=(MainVp+NewC-1);
       CopyMemory(vp,vo,sizeof(vertex));
       vo->id=k; /* indicate where moved vertex is going */
     }
     NewC--;
   }
   else {
     vp++; k++;
   }
 }
 if(NewC != Nvert){
   idid=YES;
   Nvert=NewC;
   /* re-vector the face/edge data structures */
   if(Nface > 0 && MainFp != NULL)for(i=0,fp=MainFp;i<Nface;i++,fp++){
     if(fp->V[0] >= Nvert)fp->V[0]=(MainVp+fp->V[0])->id;
     if(fp->V[1] >= Nvert)fp->V[1]=(MainVp+fp->V[1])->id;
     if(fp->V[2] >= Nvert)fp->V[2]=(MainVp+fp->V[2])->id;
   }
   if(Nedge > 0 && MainEp != NULL)for(i=0,ep=MainEp;i<Nedge;i++,ep++){
     if(ep->V[0] >= Nvert)ep->V[0]=(MainVp+ep->V[0])->id;
     if(ep->V[1] >= Nvert)ep->V[1]=(MainVp+ep->V[1])->id;
   }
   if(mem_update)UpdateVertexHeap(Nvert);
 }
 return idid;
}

void EraseVertexMapping(void){
 int i;
 vertex *vp;
 if(MainVp != NULL && Nvert > 0)for(vp=MainVp,i=0;i<Nvert;i++,vp++){
   if(vp->gp == 1){
     vp->gp = 0;
   }
 }
}

void CreateEdge(long v1, long v2){
if(Nedge+1 > EdgeHeapSize)MessageBeep(MB_OK);
 if(Nedge+1 > EdgeHeapSize)UpdateEdgeHeap(Nedge+1);
 (MainEp+Nedge)->V[0]=v1;
 (MainEp+Nedge)->V[1]=v2;
 Nedge++;
}

void CreateFace(long v1, long v2, long v3){
 face  *temp;
if(Nface+1 > FaceHeapSize)MessageBeep(MB_OK);
 if(Nface+1 > FaceHeapSize)UpdateFaceHeap(Nface+1);
 temp=(MainFp+Nface);
 temp->V[0]=v1;
 temp->V[1]=v2;
 temp->V[2]=v3;
 temp->color[0]=FaceColour[0];
 temp->color[1]=FaceColour[1];
 temp->color[2]=FaceColour[2];
 temp->imagemap=-1;
 temp->material=-1;
 temp->gp=FALSE;
 temp->x[0]=temp->x[1]=temp->x[2]=0.0; 
 temp->y[0]=temp->y[1]=temp->y[2]=0.0;
 temp->bSmooth=FALSE;
 Nface++;
}

void CreateVertex(void){
 vertex  *temp;
if(Nvert+1 > VertexHeapSize)MessageBeep(MB_OK);
 if(Nvert+1 > VertexHeapSize)UpdateVertexHeap(Nvert+1);
 temp=(MainVp+Nvert);
 temp->xyz[0]=NpointerX;
 temp->xyz[1]=NpointerY;
 temp->xyz[2]=NpointerZ;
 temp->status=SELECTED;
 temp->sp =  NULL;
 temp->gp = 0;
 temp->x=0.0; temp->y=0.0;
 Nvert++;
 NvertSelect++;
}

BOOL UpdateVertexHeap(long n){
 vertex *temp;
 if(n == VertexHeapSize)return TRUE;
 if(n == 0){
   if(MainVp != NULL)X__Free(MainVp);
   temp=NULL;
 }
 else if(VertexHeapSize == 0){
   if((temp=(vertex *)X__Malloc(n*sizeof(vertex))) == NULL)longjmp(j_buf,0);
 }
 else{
   if((temp=(vertex *)X__Realloc(MainVp,n*sizeof(vertex))) == NULL)longjmp(j_buf,0);
 }
 MainVp=temp;
 VertexHeapSize=n;
 return TRUE;
}

BOOL UpdateEdgeHeap(long n){
 edge *temp;
 if(n == EdgeHeapSize)return TRUE;
 if(n == 0){
   if(MainEp != NULL)X__Free(MainEp);
   temp=NULL;
 }
 else if(EdgeHeapSize == 0){
   if((temp=(edge *)X__Malloc(n*sizeof(edge))) == NULL)longjmp(j_buf,0);
 }
 else{
   if((temp=(edge *)X__Realloc(MainEp,n*sizeof(edge))) == NULL)longjmp(j_buf,0);
 }
 MainEp=temp;
 EdgeHeapSize=n;
 return TRUE;
}

BOOL UpdateFaceHeap(long n){
 face *temp;
 if(n == FaceHeapSize)return TRUE;
 if(n == 0){
   if(MainFp != NULL)X__Free(MainFp);
   temp=NULL;
 }
 else if(FaceHeapSize == 0){
   if((temp=(face *)X__Malloc(n*sizeof(face))) == NULL)longjmp(j_buf,0);
 }
 else{
   if((temp=(face *)X__Realloc(MainFp,n*sizeof(face))) == NULL)longjmp(j_buf,0);
 }
 MainFp=temp;
 FaceHeapSize=n;
 return TRUE;
}

void CreateSkeleton(skel *at){
 skel *temp;
 int i,j;
 if(( temp=(skel *)X__Malloc(sizeof(skel)) ) == NULL)longjmp(j_buf,0);
 if(MainSp != NULL)MainSp->next=temp;
 temp->last=MainSp;
 temp->xyz[0]=NpointerX;
 temp->xyz[1]=NpointerY;
 temp->xyz[2]=NpointerZ;
 temp->next=NULL;
 temp->at=at;
 temp->id=0;
 temp->offset=0;
 temp->weight=1.0;
 temp->wrange=1.0;
 temp->wzone=0.1;
 temp->u[0]=1.0; temp->u[1]=0.0; temp->u[2]=0.0;
 temp->v[0]=0.0; temp->v[1]=1.0; temp->v[2]=0.0;
 temp->w[0]=0.0; temp->w[1]=0.0; temp->w[2]=1.0;
 temp->lParam=0; /* used as user available data */
 for(i=0;i<8;i++){
   temp->bx[i][0]=NpointerX;
   temp->bx[i][1]=NpointerY;
   temp->bx[i][2]=NpointerZ;
 }
 for(i=0;i<4;i++)for(j=0;j<4;j++){
   temp->t[i][j]=0.0;
   if(i == j)temp->t[i][j]=1.0;
 }
 MainSp=temp;
 Nskel++;
 if(Nskel == 1)strcpy(temp->name,"Root");
 else sprintf(temp->name,"%ld",Nskel-1);
}

short intriview(vertex  *vp){
 if(vp->status == HIDDEN)return 0;
 if( ((vp->xyz[0] > TVpointX) && (vp->xyz[0] < TVpointX+TVsizeX))
  && ((vp->xyz[1] > TVpointY) && (vp->xyz[1] < TVpointY+TVsizeY))
  && ((vp->xyz[2] > TVpointZ) && (vp->xyz[2] < TVpointZ+TVsizeZ))
   )return 1;
 return 0;
}

int EraseIndicatedEdge(void){
 int i,sh1,sh2,sv1,sv2,npx,npy;
 double x,y,z,mu,a,b,c,d,dmin;
 edge     *ep,*epid;
 vertex   *vp,*vp1,*vp2;
 if(Nedge == 0 || MainEp == NULL || MainVp == NULL)return NO;
 dmin=(double)TVsizeX*(double)TVsizeX;
 epid=NULL;
 for(ep=MainEp,i=0;i<Nedge;i++,ep++){
   vp1=(MainVp+ep->V[0]); vp2=(MainVp+ep->V[1]);
   if(intriview(vp1) || intriview(vp2)){
     GetWindowCoords(ActiveView,
                     vp1->xyz[0],vp1->xyz[1],vp1->xyz[2],&sh1,&sv1);
     GetWindowCoords(ActiveView,
                     vp2->xyz[0],vp2->xyz[1],vp2->xyz[2],&sh2,&sv2);
     a=(double)(sh2-sh1); b=(double)(sv2-sv1);
     GetWindowCoords(ActiveView,
                     NpointerX,NpointerY,NpointerZ,&npx,&npy);
     if((sh2-sh1) != 0 ||  (sv2-sv1) != 0){
       x=(double)npx; y=(double)npy;
       mu=(a*(x-(double)sh1) + b*(y-(double)sv1))/(a*a+b*b);
       if(mu > 0.0001 && mu < 0.9999){
         x=a*mu+(double)sh1; y=b*mu+(double)sv1;
         sh1=(short)x; sv1=(short)y;
         if(abs(npx-sh1) < 3 && abs(npy-sv1) < 3){/* in 2D range */
           a=(double)(vp2->xyz[0]-vp1->xyz[0]);
           b=(double)(vp2->xyz[1]-vp1->xyz[1]);
           c=(double)(vp2->xyz[2]-vp1->xyz[2]);
           mu=(a*((double)NpointerX-(double)(vp1->xyz[0]))
              +b*((double)NpointerY-(double)(vp1->xyz[1]))
              +c*((double)NpointerZ-(double)(vp1->xyz[2])))/(a*a+b*b+c*c);
           x=a*mu+(double)(vp1->xyz[0]);
           y=b*mu+(double)(vp1->xyz[1]);
           z=c*mu+(double)(vp1->xyz[2]);
           d=(x-(double)NpointerX)*(x-(double)NpointerX)
            +(y-(double)NpointerY)*(y-(double)NpointerY)
            +(z-(double)NpointerZ)*(z-(double)NpointerZ);
           if(d < dmin){/* closest in 3D */
             dmin=d;
             epid=ep;
           }
         }
       }
     }
   }
 }
 if(epid == NULL)return NO;
 vp1=(MainVp+epid->V[0]); vp2=(MainVp+epid->V[1]);
 sh1=(int)vp1->status; sh2=(int)vp2->status;
 for(i=0,vp=MainVp;i<Nvert;i++){
   if(vp->status == SELECTED)vp->status = INEDITOR;
   vp++;
 }
 vp1->status=SELECTED;
 vp2->status=SELECTED;
 EraseEdge(1);
 for(i=0,vp=MainVp;i<Nvert;i++){
   if(vp->status == INEDITOR)vp->status = SELECTED;
   vp++;
 }
 vp1->status=(unsigned char)sh1; vp2->status=(unsigned char)sh2;
 return YES;
}

int EraseIndicatedVertex(void){
 vertex *vp,*vps;
 double d,dmin;
 int i,sho,svo,npx,npy;
 if(Nvert == 0 || MainVp == NULL)return NO;
 dmin=(double)TVsizeX*(double)TVsizeX;
 vps=NULL;
 GetWindowCoords(ActiveView,NpointerX,NpointerY,NpointerZ,&npx,&npy);
 for(vp=MainVp,i=0;i<Nvert;i++,vp++){
   if(intriview(vp)){
     GetWindowCoords(ActiveView,vp->xyz[0],vp->xyz[1],vp->xyz[2],&sho,&svo);
     if( (sho > npx-4) && (sho < npx+4)
      && (svo > npy-4) && (svo < npy+4)){
       d=(double)(vp->xyz[0]-NpointerX)*(double)(vp->xyz[0]-NpointerX)
        +(double)(vp->xyz[1]-NpointerY)*(double)(vp->xyz[1]-NpointerY)
        +(double)(vp->xyz[2]-NpointerZ)*(double)(vp->xyz[2]-NpointerZ);
       if(d < dmin){
         dmin=d;
         vps=vp;
       }
     }
   }
 }
 if(vps == NULL)return NO;
 if(vps->status==DESELECTED){NvertDeselect--; NvertSelect++;}
 for(vp=MainVp,i=0;i<Nvert;i++,vp++){
  if(vp->status == SELECTED)vp->status = INEDITOR;
 }
 vps->status=SELECTED;
 EraseVertex(1);
 if(MainVp == NULL || Nvert == 0)return YES;
 for(vp=MainVp,i=0;i<Nvert;i++,vp++){
   if(vp->status == INEDITOR)vp->status = SELECTED;
 }
 return YES;
}

BOOL CheckFaceExists(long v1, long v2, long v3, long limit){
 long i;
 face *fp;
 if(Nface == 0)return FALSE;
 fp=(MainFp+Nface-1); for(i=Nface-1;i>=limit;i--){
   if(   ((fp->V[0] == v1) && (fp->V[1] == v2) && (fp->V[2] == v3))
      || ((fp->V[0] == v1) && (fp->V[1] == v3) && (fp->V[2] == v2))
      || ((fp->V[0] == v2) && (fp->V[1] == v3) && (fp->V[2] == v1))
      || ((fp->V[0] == v2) && (fp->V[1] == v1) && (fp->V[2] == v3))
      || ((fp->V[0] == v3) && (fp->V[1] == v1) && (fp->V[2] == v2))
      || ((fp->V[0] == v3) && (fp->V[1] == v2) && (fp->V[2] == v1))
     )return TRUE;
   fp--;
 }
 return FALSE;
}

BOOL CheckEdgeExists(long v1, long v2, long limit){
 int i;
 edge *ep;
 if(Nedge == 0)return FALSE;
 ep=(MainEp+Nedge-1); for(i=Nedge-1;i>=limit;i--){
   if(   ((ep->V[0] == v1) && (ep->V[1] == v2))
      || ((ep->V[0] == v2) && (ep->V[1] == v1)) )return TRUE;

   ep--;
 }
 return FALSE;
}

void CopyFaceProp(face *fin, face *fout){
  fout->color[0] = fin->color[0];
  fout->color[1] = fin->color[1];
  fout->color[2] = fin->color[2];
  fout->bSmooth = fin->bSmooth;
  fout->material=fin->material;
  fout->imagemap=fin->imagemap;
  fout->gp=fin->gp;
  fout->x[0]=fin->x[0]; fout->y[0]=fin->y[0];
  fout->x[1]=fin->x[1]; fout->y[1]=fin->y[1];
  fout->x[2]=fin->x[2]; fout->y[2]=fin->y[2];
}

int IdentifyIndicatedFace(void){
 int i,sh1,sh2,sv1,sv2,sh3,sv3,npx,npy,shmin,shmax,svmin,svmax;
 double dv1[2],dv2[2],dv3[2];
 double l,dv12,dv23,dv31,t1,t2,t3,ta;
 face     *fp;
 vertex   *vp,*vp1,*vp2,*vp3;
 if(Nface == 0 || MainFp == NULL || MainVp == NULL)return -1;
 //dmin=(double)TVsizeX*(double)TVsizeX;
 for(fp=MainFp,i=0;i<Nface;i++,fp++){
   vp1=(MainVp+fp->V[0]); vp2=(MainVp+fp->V[1]); vp3=(MainVp+fp->V[2]);
   if(intriview(vp1) && intriview(vp2) && intriview(vp3) &&
      vp1->status == SELECTED && vp2->status == SELECTED && vp3->status == SELECTED){
     GetWindowCoords(ActiveView,
                     vp1->xyz[0],vp1->xyz[1],vp1->xyz[2],&sh1,&sv1);
     GetWindowCoords(ActiveView,
                     vp2->xyz[0],vp2->xyz[1],vp2->xyz[2],&sh2,&sv2);
     GetWindowCoords(ActiveView,
                     vp3->xyz[0],vp3->xyz[1],vp3->xyz[2],&sh3,&sv3);
     GetWindowCoords(ActiveView,
                     NpointerX,NpointerY,NpointerZ,&npx,&npy);
     shmin=min(sh1,min(sh2,sh3));
     shmax=max(sh1,max(sh2,sh3));
     svmin=min(sv1,min(sv2,sv3));
     svmax=max(sv1,max(sv2,sv3));
     if(npx > shmin && npx < shmax && npy > svmin && npy < svmax){ // inside face bounding box
       // determine if vectors from cursor to vertices have any angle > 90 => inside
       dv1[0]=(double)sh1-(double)npx; dv1[1]=(double)sv1-(double)npy;
       dv2[0]=(double)sh2-(double)npx; dv2[1]=(double)sv2-(double)npy;
       dv3[0]=(double)sh3-(double)npx; dv3[1]=(double)sv3-(double)npy;
       l=sqrt(DOT2(dv1,dv1)); dv1[0] /= l; dv1[1] /= l;
       l=sqrt(DOT2(dv2,dv2)); dv2[0] /= l; dv2[1] /= l;
       l=sqrt(DOT2(dv3,dv3)); dv3[0] /= l; dv3[1] /= l;
       dv12=DOT2(dv2,dv1); t1=acos(dv12)*180.0/PI;
       dv23=DOT2(dv3,dv2); t2=acos(dv23)*180.0/PI;
       dv31=DOT2(dv1,dv3); t3=acos(dv31)*180.0/PI;
       ta=t1+t2+t3; 
       //{char ttt[256]; sprintf(ttt,"Inside face box=%ld (%4.1lf %4.1lf %4.1lf ) [%6.1lf]",i,t1,t2,t3,ta); MessageBox(NULL,ttt,"Testing",MB_OK);}
       if(ta > 359.8)return i;
     }
   }
 }
 return -1;
}


// Primitive creation code

static void Line(void);
static void Helix(int);
static void Plot3D(void);
static BOOL MakeLatLongSphere(long, long, long);
static BOOL MakeTorus(long, long, double, long);

static short LastNumberSides=12;

void SpecialFunction(int item){
 switch(item){
   case IDM_ACTIONS_SPECIAL_3DPLOT:    Plot3D(); break;
   case IDM_ACTIONS_SPECIAL_HELIX:     Helix(0); break;
   case IDM_ACTIONS_SPECIAL_SPIRAL:    Helix(1); break;
   case IDM_ACTIONS_SPECIAL_3DSPIRAL:  Helix(2); break;
   case IDM_ACTIONS_SPECIAL_LINE:      Line();   break;
   case IDM_ACTIONS_SPECIAL_BUTTERFLY:
     AddPolygon(0,TVsizeX/4,ActiveView);  // Added /4
     DrawModel();
     break;
   default: break;
 }
 UpdateCounters();
}

static void Helix(int choice){/* 0 = Helix. 1 = Spiral. 2 = 3D Spiral */
 struct np {int type,n,r;} d;
 double fx, fy, alpha, radius=2000.00;
 vertex  *Vp=NULL;
 int range,i,spiral=0,Npoints;
 if((double)TVsizeX / (double)4000 <= 1.00) {
   SendPrgmQuery(IDQ_SCALETOOSMALL,0);
   return;
 }
 if(choice == 1 || choice == 2) {
   d.type=spiral;
   d.n=20;
   d.r=500;
   if(DialogBoxParam(ghinst_main,MAKEINTRESOURCE(DLG_SPIRAL),ghwnd_main,
            (DLGPROC)SpiralsDlgProc,(LPARAM)&d) != OK)return;
   spiral=d.type;
   Npoints=d.n;
   range=d.r;
 }
 else{ /* choice = 0  Helices  range 800 */
   Npoints=RequestNumEntry(20,5,90,"No of Vertices"," Vertices");
   range=800;
 }
 if(Npoints <= 0)return;
 if(!UpdateVertexHeap(Nvert+Npoints)){
   SendPrgmQuery(IDQ_NOMEM2,0);
   return;
 }
 if(!UpdateEdgeHeap(Nedge+Npoints-1)){
   SendPrgmQuery(IDQ_NOMEM2,0);
   return;
 }
 for(i=0;i<Npoints;i++) {
   alpha=(range/Npoints)*i;
   alpha=alpha*0.0175;
   fx=cos(alpha)*radius;
   fy=sin(alpha)*radius;
   CreateVertex();
   Vp=(MainVp+Nvert-1);
   Vp->xyz[0]=(long)fx;
   Vp->xyz[1]=(long)fy;
   Vp->xyz[0]*=TVsizeX/4000;
   Vp->xyz[1]*=TVsizeY/4000;
   Vp->xyz[0]+=NpointerX;
   Vp->xyz[1]+=NpointerY;
   if(choice == 0){ /* helices */
     Vp->xyz[2]=(long)(alpha*2000);
     Vp->xyz[2]*=TVsizeZ/4000;
   }
   else if(choice == 2){  /* 3D Spiral */
     Vp->xyz[2]=(long)(radius);
     Vp->xyz[2]*=TVsizeZ/4000;
   }
   if(i > 0)CreateEdge(Nvert-1,Nvert-2);
   if(choice == 1 || choice == 2) {        // For 3D and normal spirals.
     if(spiral == 0) radius-=2000/Npoints;  // Archimedean spiral.
     else if(spiral == 1) radius*=1.05;     // Logarithmic spiral.
   }
 }
 DrawModel();
}

void AddPolygon(int ns, long radius, int axis){
 double fx, fy, alpha;
 char x,y,z;
 int i,Npoints,fv;
 long px,py;
 vertex *Vp=NULL;
 if((double)TVsizeX / (double)4000 <= 1.00) {
   SendPrgmQuery(IDQ_SCALETOOSMALL,0);
   return;
 }
 if(ns == 0)Npoints=RequestNumEntry(LastNumberSides,4,90,
                                    "No of Sides"," Sides");
 else Npoints=ns;
 if(Npoints <= 0)return;
 LastNumberSides=Npoints;
 switch(axis) {
  case TRITOP:   x=0; y=1; z=2; px=NpointerX; py=NpointerY; break;
  case TRIFRONT: x=0; y=2; z=1; px=NpointerX; py=NpointerZ; break;
  case TRIRIGHT: x=1; y=2; z=0; px=NpointerY; py=NpointerZ; break;
  default: return; break;
 }
 if(!UpdateVertexHeap(Nvert+Npoints)){
   SendPrgmQuery(IDQ_NOMEM2,0);
   return;
 }
 if(!UpdateEdgeHeap(Nedge+Npoints)){
   SendPrgmQuery(IDQ_NOMEM2,0);
   return;
 }
 for(i=0; i<Npoints; ++i) {
   alpha=(360.0/(double)Npoints)*(double)i;
   alpha*=0.0175;
   fx=cos(alpha)*(double)radius;
   fy=sin(alpha)*(double)radius;
   CreateVertex();
   Vp=(MainVp+Nvert-1);
   Vp->xyz[x]=(long)fx;
   Vp->xyz[y]=(long)fy;
   Vp->xyz[x]+=px;
   Vp->xyz[y]+=py;
   if(i == 0)fv=Nvert-1;
   else CreateEdge(Nvert-1,Nvert-2);
 }
 CreateEdge(Nvert-1,fv);
}

static void Plot3D(void){
 struct np {int t,x,y;} d;
 long double fx, fy, fz;
 int choice, gridx=15, gridz=15, range=360, count, zcount;
 int  vp,tvp,fvp = -1;
 vertex *Vp;
 if((double)TVsizeX / (double)12000 <= 1.00) {
   SendPrgmQuery(IDQ_SCALETOOSMALL,0);
   return;
 }
 d.t=0; d.x=15; d.y=15;
 if(DialogBoxParam(ghinst_main,MAKEINTRESOURCE(DLG_FPLOT),ghwnd_main,
            (DLGPROC)FunctionPlotDlgProc,(LPARAM)&d) != OK)return;
 choice=d.t;
 gridx=d.x;
 gridz=d.y;
 if(gridx < 0 || gridz < 0)return;
 if(!UpdateVertexHeap(Nvert+gridx*gridz)){
   SendPrgmQuery(IDQ_NOMEM2,0);
   return;
 }
 if(!UpdateEdgeHeap(Nedge+(gridx-1)*gridz+(gridz-1)*gridx+
                          (gridx-1)*(gridz-1))){
   SendPrgmQuery(IDQ_NOMEM2,0);
   return;
 }
 if(!UpdateFaceHeap(Nface+(gridx-1)*(gridz-1)*2)){
   SendPrgmQuery(IDQ_NOMEM2,0);
   return;
 }
 for(zcount=0; zcount<gridz; ++zcount) {
   fz=(range/gridz)*zcount;
   fz=fz*0.0175;
   vp = -1;
   for(count=0; count<gridx; ++count) {
     fx=(range/gridx)*count;
     fx=fx*0.0175;          // Degrees to radians.
     switch(choice) {
       case 0: fy=0;                                   break;
       case 1: fy=sin(fx);                             break;
       case 2: fy=tan(fx);                             break;
       case 3: fy=exp(-1*(pow(fx-PI,2)+pow(fz-PI,2))); break;
       case 4: fy=sin(fx)*sin(fz);                     break;
       case 5: fy=sin(fx*fz);                          break;
       case 6: fy=sin(fx)*sin(3*fz);                   break;
       case 7: fy=sin(fx)+cos(fz);                     break;
       default: break;
     }
     CreateVertex();
     Vp=(MainVp+Nvert-1);
     Vp->xyz[0]=(long)(fx*2000.00);
     Vp->xyz[2]=(long)(fy*2000.00);
     Vp->xyz[1]=(long)(fz*2000.00);
     Vp->xyz[0]*=TVsizeX/12000;    // Scale curve.
     Vp->xyz[1]*=TVsizeY/12000;
     Vp->xyz[2]*=TVsizeZ/12000;
     Vp->xyz[0]+=NpointerX;
     Vp->xyz[1]+=NpointerY;
     if(vp >= 0)CreateEdge(vp,Nvert-1);
     if(fvp < 0)fvp=Nvert-1;
     vp=Nvert-1;
   }
 }
 for(range=0; range<gridz-1; ++range) {
   for(count=0; count<gridx; ++count) {
     tvp=fvp+gridx;
     CreateEdge(tvp,fvp);
     if(count<gridx-1) {
       CreateEdge(tvp,fvp+1);
       CreateFace(tvp,fvp+1,fvp);
       CreateFace(tvp+1,fvp+1,tvp);
     }
     fvp++;
   }
 }
 DrawModel();
}

static void Line(void){
 int Npoints=8, c;
 long i;
 double r=1.3;
 char response[16];
 vertex *Vp=NULL;
 if(Read1Int1Real("Create Line","Number of Vertices","Spacing Ratio",
     &Npoints,2,90,&r,-2.0,2.0,ghwnd_main) == FAIL)return;
 if(Npoints < 0) return;
 if(r>2.00 || r<-2.00 || r==0.00){
   SendPrgmQuery(IDQ_BADRATIO,0);
   return;
 }
 if(!UpdateVertexHeap(Nvert+Npoints)){
   SendPrgmQuery(IDQ_NOMEM2,0);
   return;
 }
 if(!UpdateEdgeHeap(Nedge+Npoints-1)){
   SendPrgmQuery(IDQ_NOMEM2,0);
   return;
 }
 i=TVpointX/Npoints;
 for(c=0; c<Npoints; ++c) {
  CreateVertex();
  Vp=(MainVp+Nvert-1);
  Vp->xyz[0]=i;
  Vp->xyz[1]=NpointerY;
  Vp->xyz[2]=NpointerZ;
  if(c != 0)CreateEdge(Nvert-1,Nvert-2);
  i = (long)((double)i*r);
 }
 DrawModel();
}

static void RotatePointXY(point p, int angle){
 double theta,ctheta,stheta,dx,dy;
 theta = (double)angle*PI/180.0;
 ctheta=cos(theta);
 stheta=sin(theta);
 dx=(double)(p[0]-NpointerX);
 dy=(double)(p[1]-NpointerY);
 p[0]=NpointerX+(long)(ctheta*dx-stheta*dy);
 p[1]=NpointerY+(long)(stheta*dx+ctheta*dy);
}

void UpdatePrimitiveStructure(long primitivetype, int view,
                              long xmin, long ymin, long zmin,
                              long xmax, long ymax, long zmax,
                              long xc,   long yc,   long zc){
 int i,ml,mw;
 PrimStruct.ml=1; PrimStruct.mw=1;
 PrimStruct.lr=(double)(xc-lrulerx)/ruler;
 PrimStruct.fb=(double)(yc-lrulery)/ruler;
 PrimStruct.ud=(double)(zc-lrulerz)/ruler;
 PrimStruct.length=(double)labs(ymax-ymin)/ruler;
 PrimStruct.width=(double)labs(xmax-xmin)/ruler;
 PrimStruct.height=(double)labs(zmax-zmin)/ruler;
 if     (view == TRITOP  )PrimStruct.radius=max(PrimStruct.length,PrimStruct.width)/2.0;
 else if(view == TRIFRONT)PrimStruct.radius=max(PrimStruct.width,PrimStruct.height)/2.0;
 else if(view == TRIRIGHT)PrimStruct.radius=max(PrimStruct.length,PrimStruct.height)/2.0;
 switch (primitivetype){
   case 0: /* rectangle */
     if(view == TRITOP){
       if(xmin > xmax)mw = -1; else mw = 1;
       if(ymin > ymax)ml = -1; else ml = 1;
       PrimStruct.width=(double)labs(xmax-xmin)/ruler;
       PrimStruct.length=(double)labs(ymax-ymin)/ruler;
     }
     else if(view == TRIFRONT){
       if(xmin > xmax)mw = -1; else mw = 1;
       if(zmin > zmax)ml = -1; else ml = 1;
       PrimStruct.width=(double)labs(xmax-xmin)/ruler;
       PrimStruct.length=(double)labs(zmax-zmin)/ruler;
     }
     else if(view == TRIRIGHT){
       if(ymin > ymax)mw = -1; else mw = 1;
       if(zmin > zmax)ml = -1; else ml = 1;
       PrimStruct.width=(double)labs(ymax-ymin)/ruler;
       PrimStruct.length=(double)labs(zmax-zmin)/ruler;
     }
     PrimStruct.ml=ml;
     PrimStruct.mw=mw;
     break;
   case 1: /* cube      */
     break;
   case 2: /* polygon  */
     break;
   case 3: /* tube     */
     if     (view == TRITOP  )PrimStruct.length=(double)labs(zmax-zmin)/ruler;
     else if(view == TRIFRONT)PrimStruct.length=(double)labs(ymax-ymin)/ruler;
     else if(view == TRIRIGHT)PrimStruct.length=(double)labs(xmax-xmin)/ruler;
     break;
   case 4: /* disk     */
     break;
   case 5: /* cylinder */
     if     (view == TRITOP  )PrimStruct.length=(double)labs(zmax-zmin)/ruler;
     else if(view == TRIFRONT)PrimStruct.length=(double)labs(ymax-ymin)/ruler;
     else if(view == TRIRIGHT)PrimStruct.length=(double)labs(xmax-xmin)/ruler;
     break;
   case 6: /* cone     */
     if     (view == TRITOP  )PrimStruct.length=(double)labs(zmax-zmin)/ruler;
     else if(view == TRIFRONT)PrimStruct.length=(double)labs(ymax-ymin)/ruler;
     else if(view == TRIRIGHT)PrimStruct.length=(double)labs(xmax-xmin)/ruler;
     break;
   case 7: /* sphere   */
     break;
   case 8: /* sphere2  */
     break;
   default: break;
 }
 return;
}

static BOOL MakeTorus(long npoly, long nring, double prop, long view){
 //double prop=0.5;   // 0.1 -> 1.0
 long radius,view1;
 if     (view == TRITOP){
   radius=prop*(TVsizeZ/4);
   NpointerX=TVpointX+TVsizeX-radius;
   view1=TRIFRONT;
 }
 else if(view == TRIFRONT){
   radius=prop*(TVsizeY/4);
   NpointerX=TVpointX+TVsizeY-radius;
   view1=TRITOP;
 }
 else if(view == TRIRIGHT){
   radius=prop*(TVsizeX/4);
   NpointerY=TVpointY+TVsizeX-radius;
   view1=TRITOP;
 }
 AddPolygon(npoly,radius,view1);
 NpointerX=TVpointX+TVsizeX/2;
 NpointerY=TVpointY+TVsizeY/2;
 NpointerZ=TVpointZ+TVsizeZ/2;
 Spin(1,nring,TRUE,view);
 return TRUE;
}

static BOOL MakeLatLongSphere(long nlat, long nlong, long view){
 long i,j,radius,*lastrow;
 double dv,angle=0.0,dangle=PI/(double)(nlat-1);
// dv=(double)TVsizeZ/2;
 if     (view == TRITOP  )dv=(double)TVsizeZ/2;
 else if(view == TRIFRONT)dv=(double)TVsizeY/2;
 else if(view == TRIRIGHT)dv=(double)TVsizeX/2;
 if((lastrow=(long *)X__Malloc(nlong*sizeof(long))) == NULL)return FALSE;
 for(i=0;i<nlat;i++){
//   NpointerZ=TVpointZ+TVsizeZ/2+(long)(dv*cos(angle));
   if     (view == TRITOP  )NpointerZ=TVpointZ+TVsizeZ/2+(long)(dv*cos(angle));
   else if(view == TRIFRONT)NpointerY=TVpointY+TVsizeY/2+(long)(dv*cos(angle));
   else if(view == TRIRIGHT)NpointerX=TVpointX+TVsizeX/2+(long)(dv*cos(angle));
   if(i == 0){
     if(!UpdateVertexHeap(Nvert+1))return FALSE;
     CreateVertex();
   }
   else if(i == (nlat-1)){
     if(!UpdateVertexHeap(Nvert+1))return FALSE;
     CreateVertex();
     if(!UpdateEdgeHeap(Nedge+nlong))return FALSE;
     if(!UpdateFaceHeap(Nface+nlong))return FALSE;
     for(j=Nvert-nlong-1;j<Nvert-1;j++){
       CreateEdge(j,Nvert-1);
       if(j == Nvert-nlong-1)CreateFace(j,Nvert-2,Nvert-1);
       else                  CreateFace(j,j-1,Nvert-1);
     }
   }
   else {
     radius=(long)(dv*sin(angle));
     AddPolygon(nlong,radius,view);
     if(i == 1){
       if(!UpdateEdgeHeap(Nedge+nlong))return FALSE;
       if(!UpdateFaceHeap(Nface+nlong))return FALSE;
       for(j=Nvert-nlong;j<Nvert;j++){
         CreateEdge(j,Nvert-nlong-1);
         if(j == Nvert-nlong)CreateFace(j,Nvert-nlong-1,Nvert-1);
         else                CreateFace(j,Nvert-nlong-1,j-1);
       }
     }
     else {
       if(!UpdateEdgeHeap(Nedge+2*nlong))return FALSE;
       if(!UpdateFaceHeap(Nface+2*nlong))return FALSE;
       for(j=Nvert-nlong;j<Nvert;j++){
         CreateEdge(j,j-nlong);
         if(j == Nvert-nlong){
           CreateEdge(j,j-1);
           CreateFace(j,j-nlong,j-1);
           CreateFace(j,j-1,j+nlong-1);
         }
         else{
           CreateEdge(j,j-nlong-1);
           CreateFace(j,j-nlong,j-nlong-1);
           CreateFace(j,j-nlong-1,j-1);
         }
       }
     }
   }
   angle += dangle;
 }
 X__Free(lastrow);
 return TRUE;
}

void BuildPrimitive(long primitivetype, int view){
 vertex *Vp;
 long n_face_list,*face_list,last_face;
 long n,x,y,z,tvx,tvy,tvz,tvpx,tvpy,tvpz;
 long v1,v2,v3,v4,v5,v6,v7,v8,opx,opy,opz,dx,dy,dz,LastMainFp,
      LastMainEp,LastMainVp,radius,height,vs[12];
 int i,j,fp,vp;
 int fid[30]={0,6,5,
              6,0,1,
              1,7,6,
              7,1,2,
              2,8,7,
              8,2,3,
              3,9,8,
              9,3,4,
              4,5,9,
              5,4,0};
 face *Fp;
 x=NpointerX; y=NpointerY; z=NpointerZ;
 tvx=TVsizeX; tvy=TVsizeY; tvz=TVsizeZ;
 tvpx=TVpointX; tvpy=TVpointY; tvpz=TVpointZ;
 LastMainFp=Nface;
 LastMainEp=Nedge;
 LastMainVp=Nvert;
 vp=0; Vp=MainVp; while(vp < Nvert){
   if(Vp->status == SELECTED)Vp->status=INEDITOR;
    vp++; Vp++;
 }
 switch (primitivetype){
   case 0: /* rectangle */
     opx=(long)(PrimStruct.lr*ruler)+lrulerx;
     opy=(long)(PrimStruct.fb*ruler)+lrulery;
     opz=(long)(PrimStruct.ud*ruler)+lrulerz;
     dx=(long)(PrimStruct.width*ruler)*PrimStruct.mw;
     dy=(long)(PrimStruct.length*ruler)*PrimStruct.ml;
     if(!UpdateVertexHeap(Nvert+4))goto ABRT;
     if(!UpdateEdgeHeap(Nedge+5))goto ABRT;
     if(!UpdateFaceHeap(Nface+2))goto ABRT;
     CreateVertex(); v1=Nvert-1;  CreateVertex(); v2=Nvert-1;
     CreateVertex(); v3=Nvert-1;  CreateVertex(); v4=Nvert-1;
     CreateEdge(v1,v2); CreateEdge(v2,v3);
     CreateEdge(v3,v4); CreateEdge(v4,v1);
     CreateEdge(v1,v3);
     CreateFace(v1,v3,v2); CreateFace(v1,v4,v3);
     fp=LastMainFp; while(fp < Nface){
       for(i=0;i<3;i++)(MainFp+fp)->color[i]=PrimStruct.fc[i];
       fp++;
     }
     if(view == TRITOP){
       (MainVp+v1)->xyz[2]=(MainVp+v2)->xyz[2]=
       (MainVp+v3)->xyz[2]=(MainVp+v4)->xyz[2]=opz;
       (MainVp+v1)->xyz[0]=(MainVp+v4)->xyz[0]=opx;
       (MainVp+v2)->xyz[0]=(MainVp+v3)->xyz[0]=opx+dx;
       (MainVp+v1)->xyz[1]=(MainVp+v2)->xyz[1]=opy;
       (MainVp+v3)->xyz[1]=(MainVp+v4)->xyz[1]=opy+dy;
     }
     else if(view == TRIFRONT){
       (MainVp+v1)->xyz[1]=(MainVp+v2)->xyz[1]=
       (MainVp+v3)->xyz[1]=(MainVp+v4)->xyz[1]=opy;
       (MainVp+v1)->xyz[0]=(MainVp+v4)->xyz[0]=opx;
       (MainVp+v2)->xyz[0]=(MainVp+v3)->xyz[0]=opx+dx;
       (MainVp+v1)->xyz[2]=(MainVp+v2)->xyz[2]=opz;
       (MainVp+v3)->xyz[2]=(MainVp+v4)->xyz[2]=opz+dy;
     }
     else if(view == TRIRIGHT){
       (MainVp+v1)->xyz[0]=(MainVp+v2)->xyz[0]=
       (MainVp+v3)->xyz[0]=(MainVp+v4)->xyz[0]=opx;
       (MainVp+v1)->xyz[1]=(MainVp+v4)->xyz[1]=opy;
       (MainVp+v2)->xyz[1]=(MainVp+v3)->xyz[1]=opy+dx;
       (MainVp+v1)->xyz[2]=(MainVp+v2)->xyz[2]=opz;
       (MainVp+v3)->xyz[2]=(MainVp+v4)->xyz[2]=opz+dy;
     }
     break;
   case 1: /* cube      */
     opx=(long)(PrimStruct.lr*ruler)+lrulerx;
     opy=(long)(PrimStruct.fb*ruler)+lrulery;
     opz=(long)(PrimStruct.ud*ruler)+lrulerz;
     dx=(long)(PrimStruct.width*ruler)/2;
     dy=(long)(PrimStruct.length*ruler)/2;
     dz=(long)(PrimStruct.height*ruler)/2;
     if(!UpdateVertexHeap(Nvert+8))goto ABRT;
     if(!UpdateEdgeHeap(Nedge+18))goto ABRT;
     if(!UpdateFaceHeap(Nface+12))goto ABRT;
     CreateVertex(); v1=Nvert-1; CreateVertex(); v2=Nvert-1;
     CreateVertex(); v3=Nvert-1; CreateVertex(); v4=Nvert-1;
     CreateVertex(); v5=Nvert-1; CreateVertex(); v6=Nvert-1;
     CreateVertex(); v7=Nvert-1; CreateVertex(); v8=Nvert-1;
     CreateEdge(v1,v2); CreateEdge(v2,v3);   /* top */
     CreateEdge(v3,v4); CreateEdge(v4,v1);
     CreateEdge(v1,v3);
     CreateEdge(v5,v6); CreateEdge(v6,v7);   /* bottom */
     CreateEdge(v7,v8); CreateEdge(v8,v5);
     CreateEdge(v5,v7);
     CreateEdge(v1,v5); CreateEdge(v2,v6);   /* sides */
     CreateEdge(v3,v7); CreateEdge(v4,v8);
     CreateEdge(v1,v6); CreateEdge(v2,v7);   /* side diagonal */
     CreateEdge(v3,v8); CreateEdge(v4,v5);
     CreateFace(v1,v2,v3); CreateFace(v1,v3,v4); /* top */
     CreateFace(v5,v7,v6); CreateFace(v5,v8,v7); /* bottom */
     CreateFace(v1,v6,v2); CreateFace(v1,v5,v6); /* sides */
     CreateFace(v2,v7,v3); CreateFace(v2,v6,v7);
     CreateFace(v3,v8,v4); CreateFace(v3,v7,v8);
     CreateFace(v4,v5,v1); CreateFace(v4,v8,v5);
     (MainVp+v1)->xyz[2]=(MainVp+v2)->xyz[2]=
     (MainVp+v3)->xyz[2]=(MainVp+v4)->xyz[2]=opz+dz;
     (MainVp+v1)->xyz[0]=(MainVp+v4)->xyz[0]=opx+dx;
     (MainVp+v2)->xyz[0]=(MainVp+v3)->xyz[0]=opx-dx;
     (MainVp+v1)->xyz[1]=(MainVp+v2)->xyz[1]=opy+dy;
     (MainVp+v3)->xyz[1]=(MainVp+v4)->xyz[1]=opy-dy;
     (MainVp+v5)->xyz[2]=(MainVp+v6)->xyz[2]=
     (MainVp+v7)->xyz[2]=(MainVp+v8)->xyz[2]=opz-dz;
     (MainVp+v5)->xyz[0]=(MainVp+v8)->xyz[0]=opx+dx;
     (MainVp+v6)->xyz[0]=(MainVp+v7)->xyz[0]=opx-dx;
     (MainVp+v5)->xyz[1]=(MainVp+v6)->xyz[1]=opy+dy;
     (MainVp+v7)->xyz[1]=(MainVp+v8)->xyz[1]=opy-dy;
     fp=LastMainFp; while(fp < Nface){
       for(i=0;i<3;i++)(MainFp+fp)->color[i]=PrimStruct.fc[i];
       fp++;
     }
     break;
   case 2: /* polygon  */
     NpointerX=opx=(long)(PrimStruct.lr*ruler)+lrulerx;
     NpointerY=opy=(long)(PrimStruct.fb*ruler)+lrulery;
     NpointerZ=opz=(long)(PrimStruct.ud*ruler)+lrulerz;
     radius=(long)(PrimStruct.radius*ruler);
     AddPolygon(PrimStruct.nsides,radius,view);
     break;
   case 3: /* tube     */
     NpointerX=opx=(long)(PrimStruct.lr*ruler)+lrulerx;
     NpointerY=opy=(long)(PrimStruct.fb*ruler)+lrulery;
     NpointerZ=opz=(long)(PrimStruct.ud*ruler)+lrulerz;
     radius=(long)(PrimStruct.radius*ruler);
     height=(long)(PrimStruct.length*ruler)/2;
     n=PrimStruct.nsteps;
     if     (view == TRITOP  )NpointerZ -= height;
     else if(view == TRIFRONT)NpointerY -= height;
     else if(view == TRIRIGHT)NpointerX -= height;
     last_face=Nface;
     AddPolygon(PrimStruct.nsides,radius,view);
     j=height*2/n;
     for(i=0;i<n;i++){
       CreateAttachedCopy(1);
       vp=LastMainVp; while(vp < Nvert){
         Vp=(MainVp+vp);
         if(Vp->status == SELECTED){
           if(view == TRITOP  )Vp->xyz[2] = NpointerZ+j*(i+1);
           if(view == TRIFRONT)Vp->xyz[1] = NpointerY+j*(i+1);
           if(view == TRIRIGHT)Vp->xyz[0] = NpointerX+j*(i+1);
         }
         vp++;
       }
     }
     n_face_list=0;
     fp=LastMainFp; while(fp < Nface){
       for(i=0;i<3;i++)(MainFp+fp)->color[i]=PrimStruct.fc[i];
       (MainFp+fp)->bSmooth=TRUE;
       n_face_list++;
       fp++;
     }
     if(n_face_list > 0 &&
       (face_list = (long *)X__Malloc(n_face_list*sizeof(long))) != NULL){
       for(j=0,i=last_face;i<Nface;i++,j++)face_list[j]=i;
       if(j == n_face_list){
         OrientateFaceNormals(face_list[0],n_face_list,face_list);
         if(view == TRIFRONT)ReverseFaceOrientation(n_face_list,face_list);
       }
       X__Free(face_list);
     }
     break;
   case 4: /* disk     */
     NpointerX=opx=(long)(PrimStruct.lr*ruler)+lrulerx;
     NpointerY=opy=(long)(PrimStruct.fb*ruler)+lrulery;
     NpointerZ=opz=(long)(PrimStruct.ud*ruler)+lrulerz;
     radius=(long)(PrimStruct.radius*ruler);
     AddPolygon(PrimStruct.nsides,radius,view);
     if(Nvert <= LastMainVp)break;
     AutoFillFace(LastMainVp);
     fp=LastMainFp; while(fp < Nface){
       for(i=0;i<3;i++)(MainFp+fp)->color[i]=PrimStruct.fc[i];
       fp++;
     }
     break;
   case 5: /* cylinder */
     NpointerX=opx=(long)(PrimStruct.lr*ruler)+lrulerx;
     NpointerY=opy=(long)(PrimStruct.fb*ruler)+lrulery;
     NpointerZ=opz=(long)(PrimStruct.ud*ruler)+lrulerz;
     radius=(long)(PrimStruct.radius*ruler);
     height=(long)(PrimStruct.length*ruler)/2;
     n=PrimStruct.nsteps;
     if     (view == TRITOP  )NpointerZ -= height;
     else if(view == TRIFRONT)NpointerY -= height;
     else if(view == TRIRIGHT)NpointerX -= height;
     last_face=LastMainFp;
     AddPolygon(PrimStruct.nsides,radius,view);
     if(Nvert <= LastMainVp)break;

     AutoFillFace(LastMainVp);
//     (MainVp+Nvert-1)->status=SELECTED;
//     NvertSelect++; NvertDeselect--;
     j=height*2/n;
     for(i=0;i<n;i++){
       CreateAttachedCopy(1);
       vp=LastMainVp; while(vp < Nvert){
         Vp=(MainVp+vp);
         if(Vp->status == SELECTED){
           if(view == TRITOP  )Vp->xyz[2] = NpointerZ+j*(i+1);
           if(view == TRIFRONT)Vp->xyz[1] = NpointerY+j*(i+1);
           if(view == TRIRIGHT)Vp->xyz[0] = NpointerX+j*(i+1);
         }
         vp++;
       }
     }
     if     (view == TRITOP  )NpointerZ += height*2;
     else if(view == TRIFRONT)NpointerY += height*2;
     else if(view == TRIRIGHT)NpointerX += height*2;
     AutoFillFace(LastMainVp);
     (MainVp+Nvert-1)->status=SELECTED;
     NvertSelect++; NvertDeselect--;

     n_face_list=0;
     fp=LastMainFp; while(fp < Nface){
       for(i=0;i<3;i++)(MainFp+fp)->color[i]=PrimStruct.fc[i];
       (MainFp+fp)->bSmooth=TRUE; /* assume smoothing */
       n_face_list++;
       fp++;
     }
     if(n_face_list > 0 &&
       (face_list = (long *)X__Malloc(n_face_list*sizeof(long))) != NULL){
       for(j=0,i=last_face;i<Nface;i++,j++)face_list[j]=i;
       if(j == n_face_list){
         OrientateFaceNormals(face_list[0],n_face_list,face_list);
         if(TRIFRONT != view)ReverseFaceOrientation(n_face_list,face_list);
       }
       X__Free(face_list);
     }
     break;
   case 6: /* cone     */
     NpointerX=opx=(long)(PrimStruct.lr*ruler)+lrulerx;
     NpointerY=opy=(long)(PrimStruct.fb*ruler)+lrulery;
     NpointerZ=opz=(long)(PrimStruct.ud*ruler)+lrulerz;
     radius=(long)(PrimStruct.radius*ruler);
     height=(long)(PrimStruct.length*ruler)/2;
     if     (view == TRITOP  )NpointerZ -= height;
     else if(view == TRIFRONT)NpointerY -= height;
     else if(view == TRIRIGHT)NpointerX -= height;
     AddPolygon(PrimStruct.nsides,radius,view);
     if(Nvert <= LastMainVp)break;
     AutoFillFace(LastMainVp);
     AutoFillFace(LastMainVp);
     Vp=(MainVp+Nvert-1);
     if(view == TRITOP  )Vp->xyz[2] = NpointerZ+height*2;
     if(view == TRIFRONT)Vp->xyz[1] = NpointerY+height*2;
     if(view == TRIRIGHT)Vp->xyz[0] = NpointerX+height*2;
     Vp->status=SELECTED;
     NvertSelect++; NvertDeselect--;
     fp=LastMainFp; while(fp < Nface){
       for(i=0;i<3;i++)(MainFp+fp)->color[i]=PrimStruct.fc[i];
       (MainFp+fp)->bSmooth=TRUE; /* assume smoothing */
       fp++;
     }
     break;
   case 7: /* sphere   */
     NpointerX=opx=(long)(PrimStruct.lr*ruler)+lrulerx;
     NpointerY=opy=(long)(PrimStruct.fb*ruler)+lrulery;
     NpointerZ=opz=(long)(PrimStruct.ud*ruler)+lrulerz;
     radius=(long)(PrimStruct.radius*ruler);
     TVsizeZ=TVsizeX=TVsizeY=radius*2;
     TVpointX=opx-radius;
     TVpointY=opy-radius;
     TVpointZ=opz-radius;
     if(!UpdateVertexHeap(Nvert+12))goto ABRT;
     if(!UpdateEdgeHeap(Nedge+30))goto ABRT;
     if(!UpdateFaceHeap(Nface+20))goto ABRT;
     for(i=0;i<12;i++){
       CreateVertex(); vs[i]=Nvert-1;
       if(i < 10)(MainVp+vs[i])->xyz[0]=TVpointX;
     }
     (MainVp+vs[10])->xyz[2]=TVpointZ;
     (MainVp+vs[11])->xyz[2]=TVpointZ+TVsizeZ;
     for(i=0;i<5;i++){
       (MainVp+vs[i])->xyz[2]=TVpointZ+TVsizeZ/4;
       (MainVp+vs[i+5])->xyz[2]=TVpointZ+(TVsizeZ*3)/4;
       RotatePointXY((MainVp+vs[i+5])->xyz,i*72);
       RotatePointXY((MainVp+vs[i])->xyz,i*72+36);
     }
     for(i=0;i<4;i++){
       CreateEdge(vs[i],vs[i+1]); CreateEdge(vs[i+5],vs[i+6]);
       CreateEdge(vs[i],vs[i+5]); CreateEdge(vs[i],vs[i+6]);
       CreateEdge(vs[i],vs[10]);  CreateEdge(vs[i+5],vs[11]);
     }
     CreateEdge(vs[4],vs[0]);  CreateEdge(vs[9],vs[5]);
     CreateEdge(vs[4],vs[5]);  CreateEdge(vs[4],vs[9]);
     CreateEdge(vs[4],vs[10]); CreateEdge(vs[9],vs[11]);
     for(i=0;i<30;i+=3){
       CreateFace(vs[fid[i]],vs[fid[i+1]],vs[fid[i+2]]);
     }
     for(i=0;i<4;i++){
       CreateFace(vs[10],vs[i+1],vs[i]);
       CreateFace(vs[11],vs[i+5],vs[i+6]);
     }
     CreateFace(vs[10],vs[0],vs[4]);
     CreateFace(vs[11],vs[9],vs[5]);
     Explode(0);
     if(PrimStruct.faces > 20){
       Subdivide(LastMainFp,LastMainEp,0);
       Explode(0);
       if(PrimStruct.faces > 80){
         Subdivide(LastMainFp,LastMainEp,0);
         Explode(0);
         if(PrimStruct.faces > 320){
           Subdivide(LastMainFp,LastMainEp,0);
           Explode(0);
         }
       }
     }
     fp=LastMainFp; while(fp < Nface){
       Fp=(MainFp+fp);
       for(i=0;i<3;i++)Fp->color[i]=PrimStruct.fc[i];
       if(PrimStruct.smooth)Fp->bSmooth=TRUE;
       else        Fp->bSmooth=FALSE;
       fp++;
     }
     break;
   case 8: /* second segmented sphere  */
   case 9: /* torus */
     NpointerX=opx=(long)(PrimStruct.lr*ruler)+lrulerx;
     NpointerY=opy=(long)(PrimStruct.fb*ruler)+lrulery;
     NpointerZ=opz=(long)(PrimStruct.ud*ruler)+lrulerz;
     radius=(long)(PrimStruct.radius*ruler);
     TVsizeZ=TVsizeX=TVsizeY=radius*2;
     TVpointX=opx-radius;
     TVpointY=opy-radius;
     TVpointZ=opz-radius;
     if(primitivetype == 8){
       if(!MakeLatLongSphere(PrimStruct.nvert,PrimStruct.nhorz,
                             view))goto ABRT;
     }
     if(primitivetype == 9){
       if(!MakeTorus(PrimStruct.nvert,PrimStruct.nhorz,
                     PrimStruct.torus_ratio,view))goto ABRT;
     }
     fp=LastMainFp; while(fp < Nface){
       Fp=(MainFp+fp);
       for(i=0;i<3;i++)Fp->color[i]=PrimStruct.fc[i];
       if(PrimStruct.smooth)Fp->bSmooth=TRUE;
       else        Fp->bSmooth=FALSE;
       fp++;
     }
     break;
   default: break;
 }
 vp=0; Vp=MainVp; while(vp < LastMainVp){
   if(Vp->status == INEDITOR)Vp->status=SELECTED;
   vp++; Vp++;
 }
 vp=LastMainVp; Vp=(MainVp+LastMainVp); while(vp < Nvert){
   if(Vp->status == DESELECTED){
     Vp->status=SELECTED;
     NvertSelect++;
     NvertDeselect--;
   }
   vp++; Vp++;
 }
 NpointerX=x; NpointerY=y; NpointerZ=z;
 TVsizeX=tvx; TVsizeY=tvy; TVsizeZ=tvz;
 TVpointX=tvpx; TVpointY=tvpy; TVpointZ=tvpz;
 DrawModel();
 UpdateCounters();
 if(ghwndOpenGLview == NULL)Draw3dView(0,0);
 else PostMessage(ghwndOpenGLview,(WM_USER+2),0,0); // update
 return;
 ABRT:
 vp=0; Vp=MainVp; while(vp < LastMainVp){ /* reset status */
   if(Vp->status == INEDITOR)Vp->status=SELECTED;
   vp++; Vp++;
 }
 return;
}

void ExecutePrimitivesMenu(HWND hWnd){
  long idata[9]={IDBM_MENU1_1,IDBM_MENU1_2,IDBM_MENU1_3,
                 IDBM_MENU1_4,IDBM_MENU1_5,IDBM_MENU1_6,
                 IDBM_MENU1_7,IDBM_MENU1_8,IDBM_MENU1_9
                };
  long icommand[9]={
                    IDM_PRIMITIVE_QADD_1,
                    IDM_PRIMITIVE_QADD_2,
                    IDM_PRIMITIVE_QADD_3,
                    IDM_PRIMITIVE_QADD_4,
                    IDM_PRIMITIVE_QADD_5,
                    IDM_PRIMITIVE_QADD_6,
                    IDM_PRIMITIVE_QADD_7,
                    IDM_PRIMITIVE_QADD_8,
                    IDM_PRIMITIVE_QADD_9
                   };
  int i;
  POINT pt;
  HMENU hMenu=CreatePopupMenu();
  HBITMAP hBitmap[9];
  RECT rc;
  UINT align=TPM_LEFTALIGN;
  GetWindowRect(GetDlgItem(ghwndTools,10),&rc);
  if(bToolpannelLeft){pt.x=rc.right; align=TPM_LEFTALIGN; }
  else               {pt.x=rc.left;  align=TPM_RIGHTALIGN;}
  pt.y=rc.top;
//  GetCursorPos(&pt);
  for(i=0;i<9;i++){
    hBitmap[i]=LoadBitmap(ghinst_main,MAKEINTRESOURCE(idata[i]));
    AppendMenu(hMenu,MF_ENABLED|MF_BITMAP,icommand[i],(LPCSTR)hBitmap[i]);
    if(i == 6)
      AppendMenu(hMenu,MF_SEPARATOR,0,NULL);
  }
  TrackPopupMenu(hMenu,align | TPM_LEFTBUTTON,
                        pt.x,pt.y,0,hWnd,NULL);
  DestroyMenu(hMenu);
  for(i=0;i<9;i++){
    if(hBitmap[i] != NULL)DeleteObject(hBitmap);
  }
  InvalidateRect(ghwndTools,NULL,FALSE);
}

void AddSinglePrimitive(long command){
 long i;
 EDIT_ACTION=YES;
 memset(&PrimStruct,0,sizeof(PRIMITIVE));
 PrimStruct.nsides=12;
 PrimStruct.smooth=1;
 PrimStruct.faces=320;
 PrimStruct.nsteps=2;
 for(i=0;i<3;i++)PrimStruct.fc[i]=FaceColour[i];
 UpdatePrimitiveStructure(0,ActiveView,
                          TVcentreX-max(TVsizeX,TVsizeY)/8,
                          TVcentreY-max(TVsizeX,TVsizeY)/8,
                          TVcentreZ-max(TVsizeX,TVsizeY)/8,
                          TVcentreX+max(TVsizeX,TVsizeY)/8,
                          TVcentreY+max(TVsizeX,TVsizeY)/8,
                          TVcentreZ+max(TVsizeX,TVsizeY)/8,
                          NpointerX,NpointerY,NpointerZ);
  switch (command){
    case IDM_PRIMITIVE_QADD_1:  // cube
      BuildPrimitive(1,ActiveView);
      break;
    case IDM_PRIMITIVE_QADD_2:  // sphere
      BuildPrimitive(7,ActiveView);
      break;
    case IDM_PRIMITIVE_QADD_3:  // rectangle
      BuildPrimitive(0,ActiveView);
      break;
    case IDM_PRIMITIVE_QADD_4:  // cylinder
      BuildPrimitive(5,ActiveView);
      break;
    case IDM_PRIMITIVE_QADD_5:  // cone
      BuildPrimitive(6,ActiveView);
      break;
    case IDM_PRIMITIVE_QADD_6:  // polygon
      BuildPrimitive(2,ActiveView);
      break;
    case IDM_PRIMITIVE_QADD_7:  // tube
      BuildPrimitive(3,ActiveView);
      break;
    default: break;
 }
}

// end of Primitive creation code

void MakeAutoWireFrame(void){
 HCURSOR lhcurSave;
 vertex *vp,*vf,*V0,*V1;
 edge *ep;
 int e1[12]={0,1,2,3,4,5,6,7,0,1,2,3};
 int e2[12]={1,2,3,0,5,6,7,4,4,5,6,7};
 int i,k,ki,ei,flag,kount;
 int type=0;
 long xmin,ymin,zmin,xmax,ymax,zmax;
 if(w_frame.p != NULL || w_frame.e != NULL ||
       w_frame.Np > 0 || w_frame.Ne > 0 ){
   SendPrgmQuery(IDQ_WIREEXISTS,0);
   return;
 }
 if(Nvert < 1 || Nedge < 1 || MainVp == NULL || MainEp == NULL)return;
 EDIT_ACTION=YES;
 lhcurSave=SetCursor(ghcurWait);
 if(type == 0){
   vp=MainVp;
   vf=NULL;
   for(vp=MainVp,i=0;i<Nvert;i++,vp++)vp->id=0;
   kount=0;
   while(TRUE){
     flag=0;
     for(vp=MainVp,i=0;i<Nvert;i++,vp++){
       if(vp->id == 0){
         vf=vp;
         kount++;
         goto GOTNEXT;
       }
     }
     goto NOMORE;
     GOTNEXT:
     vp=vf;
     vp->id=kount;
     flag=1;
     while(flag){
       flag=0;
       ep=MainEp; for(i=0;i<Nedge;i++){
         V0=(MainVp+ep->V[0]);
         V1=(MainVp+ep->V[1]);
         if(V0->id == kount && V1->id == 0 && V1->status != HIDDEN){
           V1->id = kount; flag=1;
         }
         if(V1->id == kount && V0->id == 0 && V0->status != HIDDEN){
           V0->id = kount; flag=1;
         }
         ep++;
       }
     }
   }
   NOMORE: /* now make up the bounding boxes */
   if(kount > 0 && kount < 100){
     if((w_frame.p=(point *)X__Malloc(8*kount*sizeof(point))) == NULL){
       SendPrgmQuery(IDQ_NOMEM1,0);
       goto XXIT;
     }
     w_frame.Np=kount*8;
     if((w_frame.e=(twoLongs *)X__Malloc(12*kount*sizeof(twoLongs))) == NULL){
       if(w_frame.p != NULL)X__Free(w_frame.p);
       w_frame.p=NULL;
       SendPrgmQuery(IDQ_NOMEM1,0);
       goto XXIT;
     }
     w_frame.Ne=kount*12;
     for(k=0;k<kount;k++){ /* do each bound */
       xmax=ymax=zmax = -MAXUNIT;
       xmin=ymin=zmin =  MAXUNIT;
       for(vp=MainVp,i=0;i<Nvert;i++,vp++){
         if(vp->id == k+1){
           if(vp->xyz[0] > xmax)xmax=vp->xyz[0];
           if(vp->xyz[0] < xmin)xmin=vp->xyz[0];
           if(vp->xyz[1] > ymax)ymax=vp->xyz[1];
           if(vp->xyz[1] < ymin)ymin=vp->xyz[1];
           if(vp->xyz[2] > zmax)zmax=vp->xyz[2];
           if(vp->xyz[2] < zmin)zmin=vp->xyz[2];
         }
       }
       ki=k*8;
       w_frame.p[ki  ][0] = xmin;
       w_frame.p[ki  ][1] = ymin;
       w_frame.p[ki  ][2] = zmin;
       w_frame.p[ki+1][0] = xmax;
       w_frame.p[ki+1][1] = ymin;
       w_frame.p[ki+1][2] = zmin;
       w_frame.p[ki+2][0] = xmax;
       w_frame.p[ki+2][1] = ymax;
       w_frame.p[ki+2][2] = zmin;
       w_frame.p[ki+3][0] = xmin;
       w_frame.p[ki+3][1] = ymax;
       w_frame.p[ki+3][2] = zmin;
       w_frame.p[ki+4][0] = xmin;
       w_frame.p[ki+4][1] = ymin;
       w_frame.p[ki+4][2] = zmax;
       w_frame.p[ki+5][0] = xmax;
       w_frame.p[ki+5][1] = ymin;
       w_frame.p[ki+5][2] = zmax;
       w_frame.p[ki+6][0] = xmax;
       w_frame.p[ki+6][1] = ymax;
       w_frame.p[ki+6][2] = zmax;
       w_frame.p[ki+7][0] = xmin;
       w_frame.p[ki+7][1] = ymax;
       w_frame.p[ki+7][2] = zmax;
       ei=k*12;
       for(i=0;i<12;i++){
         w_frame.e[ei+i][0] = ki+e1[i];
         w_frame.e[ei+i][1] = ki+e2[i];
       }
     }
   }
   else SendPrgmQuery(IDQ_WIRETOOBIG,0);
 }
 XXIT:
 SetCursor(lhcurSave);
}

int MakeWireFrame(void){
 long vp,ep;
 vertex *Vp,*V0,*V1;
 edge *Ep;
 long i,w_size=0;
 if(NvertSelect == 0){
   SendPrgmQuery(IDQ_TOOFEWVERTICES,0);
   return FAIL;
 }
 if(NvertSelect > 400){
   SendPrgmQuery(IDQ_WIRETOOBIG,0);
   return FAIL;
 }
 ep=0; Ep=MainEp; while(ep < Nedge){
   if((MainVp+Ep->V[0])->status == SELECTED &&
      (MainVp+Ep->V[1])->status == SELECTED)w_size++;
   ep++; Ep++;
 }
 if(w_size == 0){
   SendPrgmQuery(IDQ_TOOFEWVERTICES,0);
   return FAIL;
 }
 if((w_frame.p=(point *)X__Malloc(NvertSelect*sizeof(point))) == NULL){
   SendPrgmQuery(IDQ_NOMEM1,0);
   return FAIL;
 }
 EDIT_ACTION=YES;
 i=0; vp=0; Vp=MainVp; while(vp < Nvert){
   if(Vp->status == SELECTED){
     w_frame.p[i][0] = Vp->xyz[0];
     w_frame.p[i][1] = Vp->xyz[1];
     w_frame.p[i][2] = Vp->xyz[2];
     Vp->id=i; i++;
   }
   vp++; Vp++;
 }
 if(i != NvertSelect){
   if(w_frame.p != NULL)X__Free(w_frame.p);
   w_frame.p=NULL;
   SendPrgmQuery(IDQ_TOOFEWVERTICES,0);
   return FAIL;
 }
 w_frame.Np=i;
 if((w_frame.e=(twoLongs *)X__Malloc(w_size*sizeof(twoLongs))) == NULL){
   if(w_frame.p != NULL)X__Free(w_frame.p);
   w_frame.p=NULL;
   SendPrgmQuery(IDQ_NOMEM1,0);
   return FAIL;
 }
 w_frame.Ne=w_size;
 i=0; ep=0; Ep=MainEp; while(ep < Nedge){
   V0=(MainVp+Ep->V[0]); V1=(MainVp+Ep->V[1]);
   if(V0->status == SELECTED && V1->status == SELECTED){
     w_frame.e[i][0] = V0->id;
     w_frame.e[i][1] = V1->id;
     i++;
   }
   ep++; Ep++;
 }
 if(i != w_size){
   if(w_frame.p != NULL)X__Free(w_frame.p); w_frame.p=NULL; w_frame.Np=0;
   if(w_frame.e != NULL)X__Free(w_frame.e); w_frame.e=NULL; w_frame.Ne=0;
   SendPrgmQuery(IDQ_TOOFEWVERTICES,0);
   return FAIL;
 }
 return OK;
}

void ClearWireFrame(void){
 long i;
 long *vtemp;
 if(w_frame.p == NULL || w_frame.e == NULL){
   SendPrgmQuery(IDQ_WIRENOEXISTS,0);
   return;
 }
 EDIT_ACTION=YES;
 X__Free(w_frame.p); w_frame.p=NULL; w_frame.Np=0;
 X__Free(w_frame.e); w_frame.e=NULL; w_frame.Ne=0;
}

void UnMakeWireFrame(void){
 long i;
 long *vtemp;
 if(w_frame.p == NULL || w_frame.e == NULL){
   SendPrgmQuery(IDQ_WIRENOEXISTS,0);
   return;
 }
 if((vtemp=(long *)X__Malloc(w_frame.Np*sizeof(long))) == NULL){
   return;
 }
 EDIT_ACTION=YES;
 if(!UpdateVertexHeap(Nvert+w_frame.Np)){
   SendPrgmQuery(IDQ_NOMEM1,0);
   return;
 }
 if(!UpdateEdgeHeap(Nedge+w_frame.Ne)){
   SendPrgmQuery(IDQ_NOMEM1,0);
   return;
 }
 for(i=0;i<w_frame.Np;i++){
   CreateVertex();
   vtemp[i]=Nvert-1;
   (MainVp+Nvert-1)->xyz[0]=w_frame.p[i][0];
   (MainVp+Nvert-1)->xyz[1]=w_frame.p[i][1];
   (MainVp+Nvert-1)->xyz[2]=w_frame.p[i][2];
 }
 for(i=0;i<w_frame.Ne;i++)CreateEdge(vtemp[w_frame.e[i][0]],
                                     vtemp[w_frame.e[i][1]]);
 X__Free(vtemp);
 X__Free(w_frame.p); w_frame.p=NULL; w_frame.Np=0;
 X__Free(w_frame.e); w_frame.e=NULL; w_frame.Ne=0;
 DrawModel();
 UpdateCounters();
}

void Nudge(int command){
 vertex *vp;
 long i,dx,dy,dz;
 int sx,sy,step=1;
 if(tool == ROTATOR){
   int axis;
   double angle;
   if     (GetAsyncKeyState(VK_SHIFT  ) & 0x8000)angle = 5.0;
   else                                          angle = 1.0;
   if(command == IDM_PAN_LEFT || command == IDM_PAN_RIGHT){
     Save_Undo(1);
     if(command == IDM_PAN_RIGHT)angle *= -1.0;
     ActionRotate(ActiveView,angle,0);
     do_NOT_abort=TRUE;
     DrawModel();
     do_NOT_abort=FALSE;
   }
   return;
 }
 dx=NpointerX; dy=NpointerY; dz=NpointerZ;
 GetWindowCoords(ActiveView,NpointerX,NpointerY,NpointerZ,&sx,&sy);
 if(GetAsyncKeyState(VK_SHIFT  ) & 0x8000)step=5;
 if(command == IDM_PAN_LEFT) sx -= step; /* use PAN commands as ID's */
 if(command == IDM_PAN_RIGHT)sx += step;
 if(command == IDM_PAN_UP)   sy -= step;
 if(command == IDM_PAN_DOWN) sy += step;
 Draw3dCursor();
 GetWorldCoords(ActiveView,&NpointerX,&NpointerY,&NpointerZ,sx,sy);
 Draw3dCursor();
 if(coords_visible)UpdateRuler(0);
 if(tool == GRABBER){
   dx=NpointerX-dx; dy=NpointerY-dy; dz=NpointerZ-dz;
   vp=MainVp; for(i=0;i<Nvert;i++){
     if(vp->status == SELECTED){
       vp->xyz[0] += dx;
       vp->xyz[1] += dy;
       vp->xyz[2] += dz;
     }
     vp++;
   }
   RecalibrateAllBezier(); RecalibrateMapLocks();
   do_NOT_abort=TRUE;
   DrawModel();
   do_NOT_abort=FALSE;
 }
}

void LoadUtility(char *program, char *class, int message, char *arguments){
 BOOL n=FALSE;
 int result;
 char modulename[255];
 HWND hWnd=NULL;
 if((class == NULL) || ((hWnd=FindWindow(class,NULL)) == NULL)){
   strcpy(modulename,gszHomeDir);strcat(modulename,program);
   if(arguments != NULL){strcat(modulename,"  "); strcat(modulename,arguments);}
   result=WinExec(modulename,SW_SHOW);
   n=TRUE;
   if(result < 32){
     return;
   }
   if(class != NULL)hWnd=FindWindow(class,NULL);
 }
 if(hWnd != NULL && IsWindow(hWnd)){
   SetForegroundWindow(hWnd);
   BringWindowToTop(hWnd);
   ShowWindow(hWnd,SW_SHOW);
   if(n)PostMessage(hWnd,WM_COMMAND,message,0);
 }
 return;
}

int SelectDirectoryName(char *szfile, char *szdir,
                        char *szTitle, char *szfilter,
                        HWND parent){
 int i;
 OPENFILENAME ofn;
 char szFilter[80],szdummy[MAX_FILE];
 szdummy[0]='\0';
 strcpy(szFilter,szfilter);
 i=0; while(szFilter[i] != '\0'){
   if(szFilter[i] == '|')szFilter[i]='\0'; i++;
 }
 memset(&ofn,0,sizeof(OPENFILENAME));
 ofn.lStructSize=sizeof(OPENFILENAME);
 ofn.hwndOwner=parent;
 ofn.lpstrFilter=szFilter;
 ofn.nFilterIndex=1;
 ofn.lpstrFile=szfile;              /* will contain file + path */
 ofn.nMaxFile=MAX_FILE;
 ofn.lpstrFileTitle=szdummy;         /* file name only */
 ofn.nMaxFileTitle=MAX_FILE;
 ofn.lpstrInitialDir=szdir;
 ofn.lpstrTitle=szTitle;
 ofn.hInstance=ghinst_main;
 ofn.lpfnHook=NULL;
 ofn.lpTemplateName="DIRECTORYOPEN";
 ofn.Flags=OFN_HIDEREADONLY|OFN_PATHMUSTEXIST|
            OFN_ENABLETEMPLATE|OFN_NONETWORKBUTTON|
            OFN_NOTESTFILECREATE; 
 i=(int)(GetSaveFileName(&ofn));
 if(i){
   strcpy(szdummy,szfile);
   *AnsiPrev(szdummy,FileInPath(szdummy)) = '\0';
   strcpy(szdir,szdummy);
 }
 return i;
}