LOADER.C

Go to the documentation of this file.

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

/* file loader.c  - loads/saves the models from their files on disk  */

#define MODULE_LOADER 1

#include "design.h"

extern long LastToolVertex;

static void ReadModWireframe(long clen);
static void ReadOldOldFaces(long clen, short shader);
static void ReadOldFaces(long clen, BOOL short_form);
static void ReadFaces(long clen);
static void ReadEdges(long clen, BOOL short_form);
static void ReadVertices(long clen);
static void ReadVerticesSelection(long clen);
static void ReadVertexMapping(long clen, long version);
static void ReadSkeleton(long clen, short version);
static int ReadImageMaps(long clen, short relation, BOOL bNew, long f_map);
static void ReadModWireframe(long clen);
static void ReadEmbeddedImages(long clen, long n_maps, long f_map);
static void ReadMaterials(long id, long clen, short relation, long f_mat);
static void ReadFaceMapping(long clen);
static unsigned char getlon(long *);
static unsigned char getsht(short *);
static unsigned char getusht(unsigned short *);
static void outsht(short);
static void outusht(unsigned short);
static void outlng(long);
static void getchunk(long clen);
static void WriteImageMaps(void);
static void WriteMaterials(void);
static void WriteEmbeddedImages(void);
static void WriteVertices(short status);
static void WriteVerticesSelection(short status);
static void WriteVertexMapping(short status);
static void WriteEdges(BOOL );
static void WriteFaces(void);
static void WriteSkeleton(void);
static void WriteWireframe(void);
static void WriteFaceMapping(void);
static void WriteByteBuffer(long lng, unsigned char *b);

#define BRUSHBIT   0x40
#define SMOOTHBIT  0x80
#define TILEBIT    0x20;

static DWORD dwRead;
static HANDLE fq;
static FILE *fo;
static long newface,newedge,newvert,newglue,minX,minY,minZ,maxX,maxY,maxZ;
static char str[10];
static key_points TempAxis;
static long FaceBase,EdgeBase,VertexBase;


static unsigned char getlon(long *val){
 long l,l0,l1,l2,l3;
 ReadFile(fq,&l,sizeof(long),&dwRead,NULL);
 l0 = (l >> 24) & 0x000000ff;
 l1 = (l >> 16) & 0x000000ff;
 l2 = (l >>  8) & 0x000000ff;
 l3 = (l      ) & 0x000000ff;
 *val = (l3 << 24) | (l2 << 16) | (l1 <<  8) | l0;
 return 1;
}

unsigned char ReadLongInteger(long *val, HANDLE h){
 long l,l0,l1,l2,l3;
 ReadFile(h,&l,sizeof(long),&dwRead,NULL);
 l0 = (l >> 24) & 0x000000ff;
 l1 = (l >> 16) & 0x000000ff;
 l2 = (l >>  8) & 0x000000ff;
 l3 = (l      ) & 0x000000ff;
 *val = (l3 << 24) | (l2 << 16) | (l1 <<  8) | l0;
 return 1;
}

static unsigned char getsht(short * val){
 short s,s0,s1;
 ReadFile(fq,&s,sizeof(short),&dwRead,NULL);
 s0 = (s >>  8) & 0x00ff;
 s1 = (s      ) & 0x00ff;
 *val = (s1 <<  8) | s0;
 return 1;
}

static unsigned char getusht(unsigned short * val){
 unsigned short s,s0,s1;
 ReadFile(fq,&s,sizeof(short),&dwRead,NULL);
 s0 = (s >>  8) & 0x00ff;
 s1 = (s      ) & 0x00ff;
 *val = (s1 <<  8) | s0;
 return 1;
}

static void getchunk(long clen){ // dump this chunk
 SetFilePointer(fq,clen,NULL,FILE_CURRENT);
}

static unsigned short GetUshortFromBuffer(unsigned char *b){
 return ((unsigned short)(*b) <<  8) | (unsigned short)(*(b+1));
}

static short GetShortFromBuffer(unsigned char *b){
 return ((short)(*b) <<  8) | (short)(*(b+1));
}

static long GetLongFromBuffer(unsigned char *b){
 return ((long)(*b) << 24) | ((long)(*(b+1)) << 16) |
        ((long)(*(b+2)) <<  8) | (long)(*(b+3));
}

static void outsht(short sht){
 fputc((char)(sht >>  8),fo);
 fputc((char)(sht      ),fo);
}

static void outusht(unsigned short sht){
 fputc((char)(sht >>  8),fo);
 fputc((char)(sht      ),fo);
}

static void outlng(long lng){
 fputc((char)(lng >> 24),fo);
 fputc((char)(lng >> 16),fo);
 fputc((char)(lng >>  8),fo);
 fputc((char)(lng      ),fo);
}

void WriteLongInteger(long lng, FILE *ff){
 fputc((char)(lng >> 24),ff);
 fputc((char)(lng >> 16),ff);
 fputc((char)(lng >>  8),ff);
 fputc((char)(lng      ),ff);
}

static void WriteByteBuffer(long lng, unsigned char *b){
  int i;
  char cc;
  for (i=0;i<lng;i++){
    cc=(char)*(b+i);
    fputc(cc,fo);
  }
}
  

char *short_form(char *filename){
 char *sps,*spc;
 if(filename == NULL)return NULL;
 sps=spc=filename;
 while((spc=strchr(spc,'\\')) != NULL){spc++; sps=spc;}
 return sps;
}


int LoadObject(char *FileName, short relation){
/* relation = 0 for full load
            = 1 for local load
            = 2 abs load
            = 3 rescale the incoming model to match the vertex scales  
*/
 // CHUNKsize is the size of the data chunk excluding the chunk name and the chunksize  
 BOOL bReadFaceMapping=FALSE,bReadVertexMapping=FALSE;
 int fail=OK;
 long CHUNKsize,FORMsize,i,uxx,reset_ruler=1;
 long n_maps,f_map,f_mat;
 vertex *v;
 face   *f;
 double local_ruler=(double)UNIT;
 long   local_lrulerx=0,local_lrulery=0,local_lrulerz=0;
 char   local_ruler_name[8]="None";
 if(relation > 0)EDIT_ACTION=YES;
 maxX = maxY = maxZ = -MAXUNIT;
 minX = minY = minZ =  MAXUNIT;
 FaceBase=Nface; EdgeBase=Nedge; VertexBase=Nvert;
 n_maps=0; f_map=nImaps; f_mat=nMats;
 SendPrgmMessage(IDS_LOADING,0);
 fq=CreateFile(FileName,GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,
    FILE_ATTRIBUTE_READONLY,(HANDLE)NULL);
 if(fq == INVALID_HANDLE_VALUE){
   SendPrgmMessage(IDS_FILEOPENFAIL,1);
   return FAIL;
 }
 LOADOPERATION=1;
 TempAxis.Origin.xyz[0]=0;         /* make sure all local variables */
 TempAxis.Origin.xyz[1]=0;         /* are  reset before using for   */
 TempAxis.Origin.xyz[2]=0;         /* the loading process           */
 newface=0; newedge=0; newvert=0; newglue=0;
 ReadFile(fq,str,4,&dwRead,NULL);
 if (dwRead != 4 || strcmp(str,"FORM") != 0){
   fail=FAIL;
   goto end;
 }
 getlon(&FORMsize);
 ReadFile(fq,str,4,&dwRead,NULL);
 if (dwRead != 4 || (strcmp(str,"OFXM") != 0 && strcmp(str,"AAPO") != 0)){
   fail=FAIL;
   goto end;
}
loop:
 if(!ReadFile(fq,str,4,&dwRead,NULL))goto end;
 if(dwRead != 4)goto end;
 getlon(&CHUNKsize);
 if     (strcmp(str,"VERT") == 0)ReadVertices(CHUNKsize);
 else if(strcmp(str,"VSEL") == 0)ReadVerticesSelection(CHUNKsize);
 else if(strcmp(str,"edge") == 0)ReadEdges(CHUNKsize,TRUE);
 else if(strcmp(str,"EDGE") == 0)ReadEdges(CHUNKsize,FALSE);
 else if(strcmp(str,"NFCE") == 0)ReadFaces(CHUNKsize);
 else if(strcmp(str,"SFCE") == 0)ReadOldFaces(CHUNKsize,TRUE);
 else if(strcmp(str,"LFCE") == 0)ReadOldFaces(CHUNKsize,FALSE);
 else if(strcmp(str,"FACE") == 0)ReadOldOldFaces(CHUNKsize,0);
 else if(strcmp(str,"SFAC") == 0)ReadOldOldFaces(CHUNKsize,1);
 else if(strcmp(str,"VTEX") == 0){ReadVertexMapping(CHUNKsize,0); bReadVertexMapping=TRUE;}
 else if(strcmp(str,"VTX2") == 0){ReadVertexMapping(CHUNKsize,1); bReadVertexMapping=TRUE;}
 else if(strcmp(str,"FTEX") == 0){ReadFaceMapping(CHUNKsize); bReadFaceMapping=TRUE;}
 else if(strcmp(str,"AXIS") == 0){
   getlon(&TempAxis.Origin.xyz[0]);
   getlon(&TempAxis.Origin.xyz[1]);
   getlon(&TempAxis.Origin.xyz[2]);
   for(i=0;i<9;i++)getlon(&uxx); // ignore the axis information   -- use for additional markers
   if(relation == 0){ /* full load */
     for(i=0;i<3;i++)ObjectAxis.Origin.xyz[i]=TempAxis.Origin.xyz[i];
   }
 }
 else if(strcmp(str,"OFFS") == 0  && relation == 0){/* only for full clean load*/
   getlon(&i);   /* no of offsets 1 for now allows possible expansion */
   getlon(&ObjectAxis.Offset.xyz[0]);  /* offset for objects to follow */
   getlon(&ObjectAxis.Offset.xyz[1]);  /* this one */
   getlon(&ObjectAxis.Offset.xyz[2]);
 }
 else if(strcmp(str,"IMAP") == 0)n_maps=ReadImageMaps(CHUNKsize,relation,FALSE,f_map);
 else if(strcmp(str,"IMA2") == 0)n_maps=ReadImageMaps(CHUNKsize,relation,TRUE,f_map);
 else if(strcmp(str,"EMAP") == 0)ReadEmbeddedImages(CHUNKsize,n_maps,f_map); 
 else if(strcmp(str,"MTL1") == 0)ReadMaterials(1,CHUNKsize,relation,f_mat); 
 else if(strcmp(str,"MTL2") == 0)ReadMaterials(2,CHUNKsize,relation,f_mat); 
 else if(strcmp(str,"SKEL") == 0 && relation == 0)ReadSkeleton(CHUNKsize,0);
 else if(strcmp(str,"SK01") == 0 && relation == 0)ReadSkeleton(CHUNKsize,1);
 else if(strcmp(str,"SK02") == 0 && relation == 0)ReadSkeleton(CHUNKsize,2);
 else if(strcmp(str,"SK03") == 0 && relation == 0)ReadSkeleton(CHUNKsize,3);
 else if(strcmp(str,"SK04") == 0 && relation == 0)ReadSkeleton(CHUNKsize,4);
 else if(strcmp(str,"UNIT") == 0){
   if(relation == 0){
     getlon(&i);  ruler = (double)i;
     ReadFile(fq,ruler_name,8,&dwRead,NULL);  if(dwRead != 8)goto end;
     getlon(&lrulerx);   getlon(&lrulery);   getlon(&lrulerz);
     rulerx = lrulerx; rulery = lrulery; rulerz = lrulerz;
     getlon(&i);   getlon(&i);   getlon(&i); /* don't use : is relative ruler */
     reset_ruler=0;
   }
   else{
     getlon(&i); local_ruler = (double)i;
     ReadFile(fq,local_ruler_name,8,&dwRead,NULL); if(dwRead != 8)goto end;
     getlon(&local_lrulerx);   getlon(&local_lrulery);   getlon(&local_lrulerz);
     getlon(&i);   getlon(&i);   getlon(&i);
   }
 }
 else if(strcmp(str,"GRID") == 0 && relation == 0){ /* not for local */
   getlon(&i);
   grid_size = (double)i;
   getlon(&i); /* unused */
 }
 else if(strcmp(str,"WFRM") == 0 && relation == 0)ReadModWireframe(CHUNKsize);
 else if(strcmp(str,"NURB") == 0)ReadNurbs(CHUNKsize,relation,fq);
// put Nurbs here
 else getchunk(CHUNKsize);
 goto loop;
end:
 CloseHandle(fq);
 if(bReadVertexMapping && !bReadFaceMapping){ // no face mapping so use vertex mapping to construct face mapping
   vertex *v0,*v1,*v2;
   //MessageBox(NULL,"NO face mapping","Making from Vertex data",MB_OK);
   if(Nface > FaceBase)for(i=FaceBase,f=(MainFp+FaceBase);i<Nface;i++,f++){
     if(f->imagemap >= 0 && f->imagemap < nImaps){ // valid image map
       if(iMap[f->imagemap].Map == MAP_BY_VERTEX){// using vertex coords
         v0=(MainVp + f->V[0]); v1=(MainVp + f->V[1]); v2=(MainVp + f->V[2]);
         if(v0->gp && v1->gp && v2->gp){
           f->gp=1; 
           f->x[0]=v0->x; f->y[0]=v0->y;
           f->x[1]=v1->x; f->y[1]=v1->y;
           f->x[2]=v2->x; f->y[2]=v2->y;
         }
       }
     }
   }   
 }
 if(relation == 1){   /* apply local offset  */
   v=(MainVp+VertexBase);  /* object origin is placed at cursor */
   for(i=VertexBase;i<Nvert;i++){/* the existing origin is retained */
     v->xyz[0] += NpointerX-TempAxis.Origin.xyz[0];
     v->xyz[1] += NpointerY-TempAxis.Origin.xyz[1];
     v->xyz[2] += NpointerZ-TempAxis.Origin.xyz[2];
     v++;
   }
 }
 else if(relation == 2){;} // do nothing 
 else if(relation == 3){   /* load using coords  */
   double tx,ty,tz;
   v=(MainVp+VertexBase);  /* object origin is placed at old coord origin */
   for(i=VertexBase;i<Nvert;i++){/* the existing origin is retained */
     tx = ((double)(v->xyz[0]-local_lrulerx))/local_ruler;
     ty = ((double)(v->xyz[1]-local_lrulery))/local_ruler;
     tz = ((double)(v->xyz[2]-local_lrulerz))/local_ruler;
     v->xyz[0] = (long)(tx*ruler)+lrulerx;
     v->xyz[1] = (long)(ty*ruler)+lrulery;
     v->xyz[2] = (long)(tz*ruler)+lrulerz;
     v++;
   }
 }
 else  EDIT_ACTION=NO;
 if(Nvert > 0 && (relation == 0 || relation == 3)){
//
   reset_mod_maxview(1);
 }
 if(relation == 0 && reset_ruler){  // units got garbled
   strcpy(ruler_name,"None");
   ruler=(double)UNIT;
   rulerx=0;rulery=0;rulerz=0;
   lrulerx=0;lrulery=0;lrulerz=0;
 }
 LOADOPERATION=0;
 return fail;
}

static void ReadOldOldFaces(long clen, short shader){
  long i;
  long id;
  face *Fp;
  unsigned char texture,brush,attrib;
  unsigned char *buffer=NULL,*b;
  if(shader)newface=clen/21;
  else      newface=clen/20;
  if(newface == 0)return;
  buffer=(unsigned char *)X__Malloc(clen);
  if(buffer == NULL)longjmp(j_buf,0);  b=buffer;
  ReadFile(fq,buffer,clen,&dwRead,NULL);
  UpdateFaceHeap(Nface+newface);
  Fp=(MainFp+FaceBase);
  for(i=0;i<newface;i++){
    Fp=(MainFp+FaceBase+i);
    Fp->material = -1;
    Fp->imagemap = -1;
    Fp->gp=FALSE;
    Fp->V[0]=VertexBase+GetLongFromBuffer(b); b+= 4;
    Fp->V[1]=VertexBase+GetLongFromBuffer(b); b+= 4;
    Fp->V[2]=VertexBase+GetLongFromBuffer(b); b+= 4;
    memcpy(Fp->color,b,3); b+= 3;
    texture = *b++;
    b+= 3; // old matco
    brush = *b++;
    if(shader)/*Fp->axis = * */ b++;
    /* make texture byte correspond to new arrangement */
    attrib=(texture & 0xf0) | (brush >> 4);
    if((attrib & 0x40) == 0x40)Fp->imagemap = (short)(brush & 0x1f);
    else Fp->imagemap = -1;
    if((attrib & 0x80) == 0x80)Fp->bSmooth=TRUE;
    else Fp->bSmooth=FALSE;
    Nface++;
    Fp++;
  }
  X__Free(buffer);
  return;
}

static void ReadOldFaces(long clen, BOOL short_form){
  long i;
  long id;
  unsigned short ids;
  unsigned char  attrib,map;
  face *Fp;
  unsigned char texture,brush;
  unsigned char *buffer=NULL,*b;
  if(short_form)newface=clen/18;
  else          newface=clen/24;
  if(newface == 0)return;
  buffer=(unsigned char *)X__Malloc(clen);
  if(buffer == NULL)longjmp(j_buf,0);  b=buffer;
  ReadFile(fq,buffer,clen,&dwRead,NULL);
  UpdateFaceHeap(Nface+newface);
  Fp=(MainFp+FaceBase);
  for(i=0;i<newface;i++){
    Fp=(MainFp+FaceBase+i);
    Fp->material = -1;
    Fp->gp=FALSE;
    if(short_form){
      Fp->V[0]=VertexBase+(long)GetUshortFromBuffer(b); b+= 2;
      Fp->V[1]=VertexBase+(long)GetUshortFromBuffer(b); b+= 2;
      Fp->V[2]=VertexBase+(long)GetUshortFromBuffer(b); b+= 2;
    }
    else{
      Fp->V[0]=VertexBase+(long)GetLongFromBuffer(b); b+= 4;
      Fp->V[1]=VertexBase+(long)GetLongFromBuffer(b); b+= 4;
      Fp->V[2]=VertexBase+(long)GetLongFromBuffer(b); b+= 4;
    }
    memcpy(Fp->color,b,3);  b += 3;
    /*memcpy(Fp->matcol,b,3);*/  b += 3;
    attrib = *b++; 
    /*Fp->param  = * */ b++;
    map  = *b++;
    if((attrib & 0x40) == 0x40)Fp->imagemap=map;
    else Fp->imagemap= -1;
    if((attrib & 0x80) == 0x80)Fp->bSmooth=TRUE;
    else Fp->bSmooth=FALSE;
    /*Fp->shader = * */ b++;
    /*Fp->axis   = * */ b++;
    /*Fp->pad    = * */ b++;
    Nface++;
    Fp++;
  }
  X__Free(buffer);
  return;
}

static void ReadFaces(long clen){
  long i;
  long id;
  unsigned short ids;
  face *Fp;
  unsigned char texture,brush;
  unsigned char *buffer=NULL,*b;
  newface=clen/20;
  if(newface == 0)return;
  buffer=(unsigned char *)X__Malloc(clen);
  if(buffer == NULL)longjmp(j_buf,0);  b=buffer;
  ReadFile(fq,buffer,clen,&dwRead,NULL);
  UpdateFaceHeap(Nface+newface);
  Fp=(MainFp+FaceBase);
  for(i=0;i<newface;i++){
    Fp=(MainFp+FaceBase+i);
    Fp->V[0]=VertexBase+(long)GetLongFromBuffer(b); b+= 4;
    Fp->V[1]=VertexBase+(long)GetLongFromBuffer(b); b+= 4;
    Fp->V[2]=VertexBase+(long)GetLongFromBuffer(b); b+= 4;
    memcpy(Fp->color,b,3);  b += 3;
    Fp->bSmooth = *b++;
    Fp->material=GetShortFromBuffer(b); b+= 2;
    Fp->imagemap=GetShortFromBuffer(b); b+= 2;
    Fp->gp=FALSE;
    Nface++;
    Fp++;
  }
  X__Free(buffer);
  return;
}

static void ReadFaceMapping(long clen){
  long i,j,ix,iy,nn;
  face *Fp;
  unsigned char *buffer=NULL,*b;
  nn=clen/28;
  if(nn == 0)return;
  buffer=(unsigned char *)X__Malloc(clen);
  if(buffer == NULL)longjmp(j_buf,0);  b=buffer;
  ReadFile(fq,buffer,clen,&dwRead,NULL);
  if(nn == newface){
//MessageBox(NULL,"Reading Face Mapping",NULL,MB_OK);
    Fp=(MainFp+FaceBase);
    for(i=0;i<nn;i++){
      Fp=(MainFp+FaceBase+i);
      Fp->gp=(BOOL)GetLongFromBuffer(b); b+= 4;
      for(j=0;j<3;j++){
        ix=GetLongFromBuffer(b); b+= 4;
        iy=GetLongFromBuffer(b); b+= 4;
        Fp->x[j]=(float)ix*0.000001;
        Fp->y[j]=(float)iy*0.000001;
      }
      Fp++;
    }
  }
  X__Free(buffer);
  return;
}

static void ReadEdges(long clen, BOOL short_form){
  long i;
  long id1,id2;
  unsigned short ids1,ids2;
  edge *Ep;
  unsigned char *buffer=NULL,*b;
  if(short_form)newedge=clen/4;
  else          newedge=clen/8;
  if(newedge == 0)return;
  buffer=(unsigned char *)X__Malloc(clen);
  if(buffer == NULL)longjmp(j_buf,0);  b=buffer;
  ReadFile(fq,buffer,clen,&dwRead,NULL);
  UpdateEdgeHeap(Nedge+newedge);
  Ep=(MainEp+EdgeBase);
  for(i=0;i<newedge;i++){
    if(short_form){
      Ep->V[0]=VertexBase+(long)GetUshortFromBuffer(b); b+= 2;
      Ep->V[1]=VertexBase+(long)GetUshortFromBuffer(b); b+= 2;
    }
    else{
      Ep->V[0]=VertexBase+(long)GetLongFromBuffer(b); b+= 4;
      Ep->V[1]=VertexBase+(long)GetLongFromBuffer(b); b+= 4;
    }
    Ep++;
    Nedge++;
  }
  X__Free(buffer);
  return;
}

static void ReadVertices(long clen){
  vertex *Vp;
  char c;
  long i,j;
  unsigned char *buffer=NULL,*b;
  newvert=clen/12;
  if(newvert == 0)return;
  buffer=(unsigned char *)X__Malloc(clen);
  if(buffer == NULL)longjmp(j_buf,0);  b=buffer;
  ReadFile(fq,buffer,clen,&dwRead,NULL);
  UpdateVertexHeap(Nvert+newvert);
  Vp=(MainVp+VertexBase);
  for(i=0;i<newvert;i++){
    Vp->status=SELECTED;   
    Vp->sp =  NULL;
    Vp->gp = 0;
    Vp->xyz[0]=GetLongFromBuffer(b); b+= 4;
    Vp->xyz[1]=GetLongFromBuffer(b); b+= 4;
    Vp->xyz[2]=GetLongFromBuffer(b); b+= 4;
    Vp->sp=NULL;
    if(Vp->xyz[0] > maxX)maxX=Vp->xyz[0];
    if(Vp->xyz[0] < minX)minX=Vp->xyz[0];
    if(Vp->xyz[1] > maxY)maxY=Vp->xyz[1];
    if(Vp->xyz[1] < minY)minY=Vp->xyz[1];
    if(Vp->xyz[2] > maxZ)maxZ=Vp->xyz[2];
    if(Vp->xyz[2] < minZ)minZ=Vp->xyz[2];
    NvertSelect++;
    Nvert++;
    Vp++;
  }
  X__Free(buffer);
  return;
}

static void ReadVerticesSelection(long clen){
  vertex *Vp;
  char c;
  long i,j,nv;
  unsigned char *buffer=NULL,*b;
  nv=clen;
  if(nv == 0 || nv != newvert)return;
  buffer=(unsigned char *)X__Malloc(clen);
  if(buffer == NULL)longjmp(j_buf,0);  b=buffer;
  ReadFile(fq,buffer,clen,&dwRead,NULL);
  Vp=(MainVp+VertexBase);
  for(i=0;i<nv;i++){
    c = *b; b++;
    if     (c == 0){Vp->status=SELECTED; }
    else if(c == 1){Vp->status=DESELECTED; NvertSelect--; NvertDeselect++;}
    else if(c == 2){Vp->status=HIDDEN;  NvertSelect--; NvertDeselect++;}
    Vp++;
  }
  X__Free(buffer);
  return;
}

static void ReadVertexMapping(long clen, long version){
  long i,id,ix,iy,szz,ida;
  vertex *Vp;
  unsigned char *buffer=NULL,*b;
  newglue=clen/12;
  if(newglue == 0)return;
  if(newglue > newvert){ /* dump the mapping */
    MessageBox(NULL,"Bad vertex mapping",NULL,MB_OK);
    for(i=0;i<newglue;i++){
      getlon(&id); getlon(&ix); getlon(&iy);
    }
    return;
  }
  buffer=(unsigned char *)X__Malloc(clen);
  if(buffer == NULL)longjmp(j_buf,0);  b=buffer;
  ReadFile(fq,buffer,clen,&dwRead,NULL);
  //if(version == 0)MessageBox(NULL,"Old vertex mapping",NULL,MB_OK);
  //else MessageBox(NULL,"New Vertex Mapping",NULL,MB_OK);
  for(i=0;i<newglue;i++){
    id=GetLongFromBuffer(b); b+= 4;
    if(version == 0)ida=id; else ida=i;
    ix=GetLongFromBuffer(b); b+= 4;
    iy=GetLongFromBuffer(b); b+= 4;
    Vp=(MainVp+VertexBase+ida);
    if(version == 0)Vp->gp=1;   // just some vertices mapped
    else            Vp->gp=id;  // every vertex mapped/or not this gives value (1 or 0)
    Vp->x=(float)ix*0.000001;
    Vp->y=(float)iy*0.000001;
  }
  X__Free(buffer);
  return;
}

static void DumpSkeleton(long nskel,long clen){
{char xxx[256]; sprintf(xxx,"Skeleton size %ld ",nskel); MessageBox(NULL,xxx,"Dumping Skeleton: Too large",MB_OK);}
 getchunk(clen-4);  // have already read the first long
}

static void ReadSkeleton(long clen, short version){
  vertex *v;
  char c;
  long i,j,k,l,szz,n,x,y,z,nskel;
  skel *sp,**s;
  short dummy;
  long dummyl; 
  getlon(&n);
  if(n == 0)return; nskel=n;
  EraseAllSkeleton();  /* start with new skeleton */
  if(nskel > 512){DumpSkeleton(nskel,clen); return;}
  szz=sizeof(skel *);
  s=(skel  **)X__Malloc((long)(szz*n));
  if(s == NULL){
    SendPrgmQuery(IDQ_NOMEM2,0);
    CloseHandle(fq);
    longjmp(j_buf,0);
  }
  getlon(&MainSp->xyz[0]); /* first Node into root node */
  getlon(&MainSp->xyz[1]);
  getlon(&MainSp->xyz[2]);
  if(version < 3){getsht(&dummy);  dummyl=(long)dummy;}
  else           {getlon(&dummyl);}
  if(dummyl < 0 || dummyl >= nskel){MainSp->id=0; MessageBox(NULL,"SkeletonError",NULL,MB_OK);}
  else MainSp->id = dummyl;
  if(version > 0){
    ReadFile(fq,MainSp->name,sizeof(char)*16,&dwRead,NULL);
    if(version > 3){
      getlon(&dummyl); MainSp->weight=((double)dummyl)/1000.0; 
      getlon(&dummyl); MainSp->wrange=((double)dummyl)/1000.0; 
      getlon(&dummyl); MainSp->wzone=((double)dummyl)/1000.0; 
    }
  }
  if(version > 1){
    for(j=0;j<3;j++){getlon(&l); MainSp->u[j] = ((double)l)*1.0e-8;}
    for(j=0;j<3;j++){getlon(&l); MainSp->v[j] = ((double)l)*1.0e-8;}
    for(j=0;j<3;j++){getlon(&l); MainSp->w[j] = ((double)l)*1.0e-8;}
    for(j=0;j<8;j++)for(k=0;k<3;k++)getlon(&(MainSp->bx[j][k]));
  }
  MainSp->at=NULL;
  *s = MainSp;
  if(n > 1)for(i=1;i<n;i++){
    CreateSkeleton(NULL);
    getlon(&MainSp->xyz[0]);
    getlon(&MainSp->xyz[1]);
    getlon(&MainSp->xyz[2]);
    if(version < 3){getsht(&dummy); MainSp->id=(long)dummy;}
    else           {getlon(&dummyl); MainSp->id = dummyl;}
    if(version > 0){
      ReadFile(fq,MainSp->name,sizeof(char)*16,&dwRead,NULL);
      if(version > 3){
        getlon(&dummyl); MainSp->weight=((double)dummyl)/1000.0; 
        getlon(&dummyl); MainSp->wrange=((double)dummyl)/1000.0; 
        getlon(&dummyl); MainSp->wzone=((double)dummyl)/1000.0; 
      }
    }
    if(version > 1){
      for(j=0;j<3;j++){getlon(&l); MainSp->u[j] = ((double)l)*1.0e-8;}
      for(j=0;j<3;j++){getlon(&l); MainSp->v[j] = ((double)l)*1.0e-8;}
      for(j=0;j<3;j++){getlon(&l); MainSp->w[j] = ((double)l)*1.0e-8;}
      for(j=0;j<8;j++)for(k=0;k<3;k++)getlon(&(MainSp->bx[j][k]));
    }
    *(s+i)=MainSp;
  }
  if((sp = FirstSp->next) != NULL)while(sp != NULL){ /* fix up pointers */
    if(sp->id < 0 || sp->id >= nskel)sp->at = *s;
    else sp->at = *(s + (long)sp->id);
    sp=sp->next;
  }
  getlon(&n);
  if(n != newvert){
    SendPrgmQuery(IDQ_HERROR,0);
    for(i=0;i<n;i++){
      if(version < 3)getsht(&dummy);
      else           getlon(&dummyl);
    }
  }
  else{
    v=(MainVp+VertexBase);
    for(i=0;i<n;i++){
      if(version < 3){getsht(&dummy); dummyl=(long)dummy;}   /* put into new vertex the pointer to the sk joint */
      else            getlon(&dummyl);
if(dummyl >= nskel)MessageBox(NULL,"Skeleton Error",NULL,MB_OK);
      if(dummyl > 0 && dummyl < nskel)v->sp = *(s+(long)dummyl);
      else          v->sp = NULL;
      v++;
    }
  }
  if(version < 2){ /* work out bounding boxes for old versions */
    TidyUpOldSkeltonType();
  }
  X__Free(s);
}

//RSFx
int AddExternalSkeleton(char *FileName){ // This loads a skeleton from another model and maps it onto the model
  // there must be the same number of vertices.
 long CHUNKsize,FORMsize,vc=0;
 BOOL bCanImport=FALSE; 
 FaceBase=0; EdgeBase=0; VertexBase=0;
 fq=CreateFile(FileName,GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,
    FILE_ATTRIBUTE_READONLY,(HANDLE)NULL);
 if(fq == INVALID_HANDLE_VALUE){
   SendPrgmMessage(IDS_FILEOPENFAIL,1);
   return FAIL;
 }
 ReadFile(fq,str,4,&dwRead,NULL);
 if (dwRead != 4 || strcmp(str,"FORM") != 0){
   goto end;
 }
 getlon(&FORMsize);
 ReadFile(fq,str,4,&dwRead,NULL);
 if (dwRead != 4 || (strcmp(str,"OFXM") != 0 && strcmp(str,"AAPO") != 0)){
   goto end;
}
loop:
 if(!ReadFile(fq,str,4,&dwRead,NULL))goto end;
 if(dwRead != 4)goto end;
 getlon(&CHUNKsize);
//  newvert=clen/12;
 if     (strcmp(str,"VERT") == 0){
   if((vc=CHUNKsize/12) == Nvert)bCanImport=TRUE;
   getchunk(CHUNKsize);
 }
 else if(strcmp(str,"SKEL") == 0 && bCanImport)ReadSkeleton(CHUNKsize,0);
 else if(strcmp(str,"SK01") == 0 && bCanImport)ReadSkeleton(CHUNKsize,1);
 else if(strcmp(str,"SK02") == 0 && bCanImport)ReadSkeleton(CHUNKsize,2);
 else if(strcmp(str,"SK03") == 0 && bCanImport)ReadSkeleton(CHUNKsize,3);
 else if(strcmp(str,"SK04") == 0 && bCanImport)ReadSkeleton(CHUNKsize,4);
 else getchunk(CHUNKsize);
 goto loop;
end:
 CloseHandle(fq);
 if(!bCanImport)MessageBox(NULL,"Incompatible Skeletons",NULL,MB_OK);
 //{char sss[256]; sprintf(sss,"F=[%s] Nvert=%d Vskel=%d",FileName,Nvert,vc);
 //MessageBox(NULL,sss,"Add in skeleton",MB_OK);}
 return OK;
}


static int ReadImageMaps(long clen, short relation, BOOL bNew, long ts){
 face *f;
 long j,i,k,l,m,tid,temp,temp1;
 short temps;
 char temp_str[256];
 unsigned char *buffer=NULL,*b;
 buffer=(unsigned char *)X__Malloc(clen);
 if(buffer == NULL)longjmp(j_buf,0);  b=buffer;
 ReadFile(fq,buffer,clen,&dwRead,NULL);
 j=GetLongFromBuffer(b); b+= 4; /* number of image maps in this model */
 if(j > 0){   
   for(i=0;i<j;i++){
     k=nImaps; // this will be the first image map
     if(CreateImageMap() == FAIL)goto ERR;  // nImaps will be up one by this
     iMap[k].P[0]=GetLongFromBuffer(b); b+= 4;
     iMap[k].P[1]=GetLongFromBuffer(b); b+= 4;
     iMap[k].P[2]=GetLongFromBuffer(b); b+= 4;
     iMap[k].X[0]=GetLongFromBuffer(b); b+= 4;
     iMap[k].X[1]=GetLongFromBuffer(b); b+= 4;
     iMap[k].X[2]=GetLongFromBuffer(b); b+= 4;
     iMap[k].Y[0]=GetLongFromBuffer(b); b+= 4;
     iMap[k].Y[1]=GetLongFromBuffer(b); b+= 4;
     iMap[k].Y[2]=GetLongFromBuffer(b); b+= 4;
     iMap[k].Type=(char)GetLongFromBuffer(b);  b+= 4;   b+= 4; b+= 4; b+= 4;// include not used items
     iMap[k].TypeR=(char)GetLongFromBuffer(b); b+= 4;   b+= 4; b+= 4; b+= 4;
     iMap[k].TypeB=(char)GetLongFromBuffer(b); b+= 4;   b+= 4; b+= 4; b+= 4;
     iMap[k].TypeT=(char)GetLongFromBuffer(b); b+= 4;   b+= 4; b+= 4; b+= 4;
      b+=4;   // skip skeleton attachment
     iMap[k].Map=(char)GetLongFromBuffer(b); b+=4;       /* 0 plane 1 cylinder     */
     iMap[k].Angle=360.0;  /* default */         /* 2 = pl-moz 3 = cyl-moz */
     iMap[k].Lock=0;
     iMap[k].Vlock[0] = -1; iMap[k].Vlock[1] = -1; iMap[k].Vlock[2] = -1;
     iMap[k].Angle=GetLongFromBuffer(b); b+=4;
     b += 4; //iMap[k].Lock = (char)GetLongFromBuffer(b); b+=4; // not used
     b += (3*4); // locking is not used now
     memcpy(iMap[k].N,b,32);  b+= 32;   // read map name
     iMap[k].s = *b++;
     iMap[k].r = *b++;
     iMap[k].b = *b++;
     iMap[k].t = *b++;
     iMap[k].Key = *b++;
     iMap[k].sp=GetShortFromBuffer(b); b+= 2;
     iMap[k].rp=GetShortFromBuffer(b); b+= 2;
     iMap[k].bp=GetShortFromBuffer(b); b+= 2;
     iMap[k].tp=GetShortFromBuffer(b); b+= 2;
     memcpy(iMap[k].d_colour,b,3); b += 3;
     memcpy(iMap[k].s_colour,b,3); b += 3;
     memcpy(iMap[k].a_colour,b,3); b += 3;
     memcpy(iMap[k].k_colour,b,3); b += 3;
     // get the filenames 
     memset(temp_str,0,256); memcpy(temp_str,b,250); b += 256; // to make sure some zeros
     //{char ttt[256]; sprintf(ttt,"String [%s]length=%ld",temp_str,strlen(temp_str));
     //MessageBox(NULL,ttt,"Image map string",MB_OK);}
     if(iMap[k].s){
       if((iMap[k].S=(char *)X__Malloc(strlen(temp_str)+1)) == NULL)iMap[k].s=0;
       else strcpy(iMap[k].S,temp_str);
     }
     else iMap[k].S=NULL;
     memset(temp_str,0,256); memcpy(temp_str,b,250); b += 256;
     if(iMap[k].r){
       if((iMap[k].R=(char *)X__Malloc(strlen(temp_str)+1)) == NULL)iMap[k].r=0;
       else strcpy(iMap[k].R,temp_str);
     }
     else iMap[k].R=NULL;
     memset(temp_str,0,256); memcpy(temp_str,b,250); b += 256;
     if(iMap[k].b){
       if((iMap[k].B=(char *)X__Malloc(strlen(temp_str)+1)) == NULL)iMap[k].b=0;
       else strcpy(iMap[k].B,temp_str);
     }
     else iMap[k].B=NULL;
     memset(temp_str,0,256); memcpy(temp_str,b,250); b += 256;
     if(iMap[k].t){
       if((iMap[k].T=(char *)X__Malloc(strlen(temp_str)+1)) == NULL)iMap[k].t=0;
       else strcpy(iMap[k].T,temp_str);
     }
     else iMap[k].T=NULL;
     if(bNew){
       b +=4 ; //will be version
       iMap[k].bDecal  = (BOOL)GetLongFromBuffer(b); b += 4;
       iMap[k].bShaded = (BOOL)GetLongFromBuffer(b); b += 4;
       iMap[k].bTiled  = (BOOL)GetLongFromBuffer(b); b += 4;
     }
     // end of read for this MAP
     if(relation == 1){ /* the brush must be repositioned to new offset */
       iMap[k].P[0] += NpointerX-TempAxis.Origin.xyz[0];
       iMap[k].P[1] += NpointerY-TempAxis.Origin.xyz[1];
       iMap[k].P[2] += NpointerZ-TempAxis.Origin.xyz[2];
       iMap[k].X[0] += NpointerX-TempAxis.Origin.xyz[0];
       iMap[k].X[1] += NpointerY-TempAxis.Origin.xyz[1];
       iMap[k].X[2] += NpointerZ-TempAxis.Origin.xyz[2];
       iMap[k].Y[0] += NpointerX-TempAxis.Origin.xyz[0];
       iMap[k].Y[1] += NpointerY-TempAxis.Origin.xyz[1];
       iMap[k].Y[2] += NpointerZ-TempAxis.Origin.xyz[2];
     }
   }
   //  fix up the faces to match the imagemaps
   if(FaceBase > 0){               /* set new faces for appropriate brush */
     f=(MainFp+FaceBase); for(m=0;m<newface;m++){
       if(f->imagemap >= 0){
         tid = f->imagemap;              /* extract the brush identifier */
         tid += ts;                 /* get the new brush id         */
         if(tid >= nImaps){
           tid=nImaps-1;
           MessageBox(NULL,"Map Load Error",NULL,MB_OK);
         }
         f->imagemap=(short)tid; /* put it back                  */
       }
       f++;
     }
   }
 }
 X__Free(buffer);
 return j;
 ERR:
 if(buffer != NULL)X__Free(buffer);
 MessageBox(NULL,"Bad Read Image Map",NULL,MB_OK);
 CloseHandle(fq);
 longjmp(j_buf,0);
 return 0;
}

static void ReadEmbeddedImages(long clen, long n_maps, long f_map){
 // read the embedded images - this must come after the read Image Maps chunk
 int i,j;
 //{char xxx[256]; sprintf(xxx,"Emb chunk size=%ld  %ld maps  first map=%ld",clen,n_maps,f_map);
 //MessageBox(NULL,xxx,"Reading Ram Image",MB_OK);}
 getlon(&i);
 if(i != n_maps)MessageBox(NULL,"MAP MISMATCH",NULL,MB_OK);
 for(i=0;i<n_maps;i++){
   j=i+f_map;
   if(j < 0 || j >= nImaps){
     MessageBox(NULL,"Bad Map Index",NULL,MB_OK);
   }
   ReadRamImage((&iMap[j].si),fq);
   ReadRamImage((&iMap[j].ri),fq);
   ReadRamImage((&iMap[j].bi),fq);
   ReadRamImage((&iMap[j].ti),fq);
 }
}

static void ReadModWireframe(long clen){
 long i,ne,np;
 getlon(&np);  getlon(&ne);
 i=((np*3)+(ne*2)+2)*sizeof(long);
 if(clen != i){   /* if chunk is void */
   getchunk(clen-2);
   return;
 }
 w_frame.p = (point *)X__Malloc(np*sizeof(point));
 w_frame.e = (twoLongs *)X__Malloc(ne*sizeof(twoLongs));
 if(w_frame.p == NULL || w_frame.e == NULL){
   if(w_frame.p != NULL)X__Free(w_frame.p); w_frame.p=NULL;
   if(w_frame.e != NULL)X__Free(w_frame.e); w_frame.e=NULL;
   getchunk(clen-2);
   return;
 }
 w_frame.Np=np;  w_frame.Ne=ne;
 for(i=0;i<w_frame.Np;i++){
   getlon(&w_frame.p[i][0]);
   getlon(&w_frame.p[i][1]);
   getlon(&w_frame.p[i][2]);
 }
 for(i=0;i<w_frame.Ne;i++){
   getlon(&w_frame.e[i][0]);
   getlon(&w_frame.e[i][1]);
 }
}

static void ReadMaterials(long id, long clen, short relation, long f_mat){
 face *f;
 long i,j,k,n,s_in_use,ln,lp;
 char temp_name[32];
 long tid,ts;
 unsigned char *buffer=NULL,*b;
 buffer=(unsigned char *)X__Malloc(clen);
 if(buffer == NULL)longjmp(j_buf,0);  b=buffer;
 ReadFile(fq,buffer,clen,&dwRead,NULL);
 n=GetLongFromBuffer(b); b+= 4; /* number of materials in this model */
 ts=f_mat;       /* the present no of materials loaded */
 if(n > 0)for(i=0;i<n;i++){
   k=nMats;
   if(CreateMaterial(FALSE) == FAIL)goto ERR;  // nImaps will be up one by this
   iMat[k].version = (long)GetLongFromBuffer(b); b+=4;
   memcpy(iMat[k].name,b,32);  b+= 32;
   //MessageBox(NULL,iMat[k].name,"Creating New material",MB_OK);
   memcpy(iMat[k].mcolour1,b,3); b+=3;
   memcpy(iMat[k].mcolour2,b,3); b+=3;
   memcpy(iMat[k].acolour,b,3); b+=3;
   memcpy(iMat[k].scolour,b,3); b+=3;
   memcpy(iMat[k].xcolour,b,3); b+=3;
   memcpy(iMat[k].ycolour,b,3); b+=3;
   memcpy(iMat[k].zcolour,b,3); b+=3;
   iMat[k].gloss = (unsigned char)GetLongFromBuffer(b); b+=4;
   iMat[k].refl = (unsigned char)GetLongFromBuffer(b); b+=4;
   iMat[k].transp = (unsigned char)GetLongFromBuffer(b); b+=4;
   iMat[k].refractive_index = (long)GetLongFromBuffer(b); b+=4;
   iMat[k].bInternalShader = (BOOL)GetLongFromBuffer(b); b+=4;
   iMat[k].internalShaderID = (int)GetLongFromBuffer(b); b+=4;
   for(j=0;j<3;j++){iMat[k].ax.P[j] = GetLongFromBuffer(b); b+=4;}
   for(j=0;j<3;j++){iMat[k].ax.X[j] = GetLongFromBuffer(b); b+=4;}
   for(j=0;j<3;j++){iMat[k].ax.Y[j] = GetLongFromBuffer(b); b+=4;}
   for(j=0;j<4;j++){
     iMat[k].Shader[j].version=GetLongFromBuffer(b); b+=4;
     iMat[k].Shader[j].bActive=(BOOL)GetLongFromBuffer(b); b+=4;
     s_in_use=iMat[k].Shader[j].in_use=GetLongFromBuffer(b); b+=4;
     if(s_in_use){
       //{char ttt[256]; sprintf(ttt,"Material %ld Shader %ld in use active=%ld",k,j,iMat[k].Shader[j].bActive);
       // MessageBox(NULL,ttt,"Shader",MB_OK);}
       ln=GetLongFromBuffer(b); b+=4; // length of shader name string
       lp=GetLongFromBuffer(b); b+=4; // lenght of shader paramter string
       if(lp == 0 || ln == 0)MessageBox(NULL,"Inconsistent Material",NULL,MB_OK);
       if(ln > 0){
         if((iMat[k].Shader[j].xname=(char *)X__Malloc(ln+1)) == NULL)goto ERR;
         memcpy(iMat[k].Shader[j].xname,b,ln+1); b += (ln+1);
         if((iMat[k].Shader[j].parameters=(char *)X__Malloc(lp+1)) == NULL)goto ERR;
         memcpy(iMat[k].Shader[j].parameters,b,lp+1); b += (lp+1);
         //{char ttt[256]; sprintf(ttt,"Mat %ld Shader %ld - ln=%ld lp=%ld [%s] [%s]",k,j,ln,lp,
         //iMat[k].Shader[j].parameters,iMat[k].Shader[j].xname);
         //MessageBox(NULL,ttt,"Reading Shader",MB_OK);}
       }
     }
   }
   iMat[k].bSmooth = (BOOL)GetLongFromBuffer(b); b+=4;
   iMat[k].bShiny = (BOOL)GetLongFromBuffer(b); b+=4;
   iMat[k].bClear = (BOOL)GetLongFromBuffer(b); b+=4;
   iMat[k].bGlassEdge = (BOOL)GetLongFromBuffer(b); b+=4;
   iMat[k].bUseSurfaceMapping = (BOOL)GetLongFromBuffer(b); b+=4;
   for(j=0;j<16;j++){iMat[k].params[j] = (unsigned char)GetLongFromBuffer(b); b+=4;}
   for(j=0;j<16;j++){iMat[k].pad[j]=GetLongFromBuffer(b); b+=4;}  // padding
   if(id > 1){ // for material versions > 1
     memcpy(iMat[k].other_properties,b,512); b+= 512;
     sscanf(iMat[k].other_properties,"%lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf",
       &(iMat[k].mmw[0]),&(iMat[k].mmw[1]),&(iMat[k].mmw[2]),
       &(iMat[k].mmw[3]),&(iMat[k].mmw[4]),&(iMat[k].mmw[5]),
       &(iMat[k].mmw[6]),&(iMat[k].mmw[7]),&(iMat[k].mmw[8]),
       &(iMat[k].mmw[9]),&(iMat[k].mmw[10]),&(iMat[k].mmw[11]),
       &(iMat[k].mmw[12]),&(iMat[k].mmw[13]),&(iMat[k].mmw[14]));
     if(iMat[k].mmw[5] > 2.5)strcpy(iMat[k].mmw_brdf,&(iMat[k].other_properties[300])); //copy in BRDF file  
   }
   // end of read for this material
   if(relation == 1){ /* the material must be repositioned to new offset */
     iMat[k].ax.P[0] += NpointerX-TempAxis.Origin.xyz[0];
     iMat[k].ax.P[1] += NpointerY-TempAxis.Origin.xyz[1];
     iMat[k].ax.P[2] += NpointerZ-TempAxis.Origin.xyz[2];
     iMat[k].ax.X[0] += NpointerX-TempAxis.Origin.xyz[0];
     iMat[k].ax.X[1] += NpointerY-TempAxis.Origin.xyz[1];
     iMat[k].ax.X[2] += NpointerZ-TempAxis.Origin.xyz[2];
     iMat[k].ax.Y[0] += NpointerX-TempAxis.Origin.xyz[0];
     iMat[k].ax.Y[1] += NpointerY-TempAxis.Origin.xyz[1];
     iMat[k].ax.Y[2] += NpointerZ-TempAxis.Origin.xyz[2];
   }
 }
 // now fix up faces when adding to existing material list
 // check
 if(FaceBase > 0 && MainFp != NULL){
 //if(debug != NULL)fprintf(debug,"Fixing material %ld (%ld) faces  Before %ld materials Now %ld\n",Nface,FaceBase,ts,nMats);
  f=(MainFp+FaceBase); for(j=FaceBase;j<Nface;j++,f++){
    tid = f->material;          /* extract the mateiral id      */
    if(tid >= 0){
      tid += ts;               
      if(tid >= nMats)tid=0;   
      f->material=tid;         
    }
  }
 }
 X__Free(buffer);
 return;
 ERR:
 if(buffer != NULL)X__Free(buffer);
 MessageBox(NULL,"Bad Read Image Map",NULL,MB_OK);
 CloseHandle(fq);
 longjmp(j_buf,0);
}

// Save the MFX file  /////////////////////////////


void SaveObject(char *Filename, short status){
  long pos1,pos2,pos3,pos4,pos5,pos6,pos7,pos8,posB,
       posG,posH,pose,posIs,posIe,posMs,posMe,posXs,posXe,posVXs,posVXe;
  long i,FORMsize;
  HCURSOR hSave;
  short id;
  FORMsize=0; newvert=0; newface=0; newedge=0; newglue=0;
  /* status = 3 -> saving with - no extra display  save everything!! */
  /* status = 4 -> save as "1" but without file check                */
  if(status < 3){   /* no memory problem */
    if( (fo=fopen(Filename,"r")) != NULL){ /* check for old file */
      fclose(fo);
      if(SendPrgmQuery(IDQ_FILEEXISTS,1) != IDYES)return;
    }
  }
  if(status == 4)status=1;
  if( (fo=fopen(Filename,"wb")) == NULL){   /* now open for reading */
    SendPrgmQuery(IDQ_FILEOPENFAIL,0);
    return;
  }
  if(status < 2)SendPrgmMessage(IDS_SAVING,0);
  if(status < 3)hSave=SetCursor(ghcurWait);
  if(status == 1 || status == 3)EDIT_ACTION=NO;
  fprintf(fo,"FORM");
  pos1=ftell(fo); outlng(FORMsize);
  fprintf(fo,"OFXM");
  fprintf(fo,"AXIS"); outlng(48L); /* size of data chunk */
  if(status == 2){  /* dont use offset for rendering in triview */
    outlng(0); outlng(0); outlng(0);
  }
  else{
    outlng(ObjectAxis.Origin.xyz[0]);
    outlng(ObjectAxis.Origin.xyz[1]);
    outlng(ObjectAxis.Origin.xyz[2]);
  }
  for(i=0;i<9;i++)outlng(0);
  fprintf(fo,"OFFS"); outlng(16L);      /* follow point */
  outlng(3L);
  outlng(ObjectAxis.Offset.xyz[0]);
  outlng(ObjectAxis.Offset.xyz[1]);
  outlng(ObjectAxis.Offset.xyz[2]);
  pos2 = -1; if(Nvert > 0){
    fprintf(fo,"VERT"); pos2=ftell(fo); outlng(0L); /* filled in later */
    WriteVertices(status);
    if(newvert == 0){ // no vertices - so reset the file pointer
      fseek(fo,pos2-4,0);
    }
  }
  pos3 = -1; if(Nedge > 0 && newvert > 1){
    if(Nedge < 65536){
      fprintf(fo,"edge"); pos3=ftell(fo); outlng(0L); WriteEdges(TRUE);
    }
    else {
      fprintf(fo,"EDGE"); pos3=ftell(fo); outlng(0L); WriteEdges(FALSE);
    }
  }
  pos4 = -1; if(Nface > 0 && newvert > 2){
    fprintf(fo,"NFCE"); pos4=ftell(fo); outlng(0L); WriteFaces();
    if(newface == 0)fseek(fo,pos4-4,0); // no faces written so remove segment
  }
  posB = -1; if(Nvert > 0 && newvert > 0){
    fprintf(fo,"VTX2"); posB=ftell(fo); outlng(0L);
    WriteVertexMapping(status);
  }
  posXs = -1; if(Nface > 0 && newvert > 2 && newface > 1){
    fprintf(fo,"FTEX"); posXs=ftell(fo); outlng(0L); 
    WriteFaceMapping();
    posXe=ftell(fo);
  }
  posMs = -1; if(nMats > 0){
    //fprintf(fo,"MTL1"); posMs=ftell(fo); outlng(0L);
    fprintf(fo,"MTL2"); posMs=ftell(fo); outlng(0L);
    WriteMaterials();
    posMe=ftell(fo);
  }
  pos5 = -1; if(nImaps > 0){
    fprintf(fo,"IMA2"); pos5=ftell(fo); outlng(0L);
    WriteImageMaps();
    pos6=ftell(fo);
  }
  posIs = -1; if(nImaps > 0){
    fprintf(fo,"EMAP"); posIs=ftell(fo); outlng(0L);
    WriteEmbeddedImages();
    posIe=ftell(fo);
  } 
  pos7 = -1; if((status == 1 || status == 3) &&
      Nskel > 1){/* if saving whole object then save skeleton */
    fprintf(fo,"SK04"); pos7=ftell(fo); outlng(0L);
    WriteSkeleton();
    pos8=ftell(fo);
  }
  posVXs = -1; if(Nvert > 0 && newvert > 0){ // write out the vertex selection
    fprintf(fo,"VSEL"); posVXs=ftell(fo); outlng(0L);
    WriteVerticesSelection(status);
    posVXe=ftell(fo); 
  }
  fprintf(fo,"UNIT"); outlng((long)(7*sizeof(long)+8));
  outlng((long)ruler);
  fwrite(ruler_name,1,8,fo);
  outlng(lrulerx); outlng(lrulery); outlng(lrulerz);
  outlng(rulerx);  outlng(rulery);  outlng(rulerz);
  fprintf(fo,"GRID"); outlng((long)(2*sizeof(long)));
  outlng(grid_size); outlng(grid_size); /* second is unused */
  WriteWireframe();
  posH = -1; if(Nnurbs > 0){
    fprintf(fo,"NURB"); posH=ftell(fo); outlng(0);
    WriteNurbs(fo);
    posG=ftell(fo);
  }
  pose=ftell(fo);    /* the end of the object */
  // FIX UP the FILE lengths
  if(pos2 > 0){fseek(fo,pos2,0); outlng(12*newvert); }  // vertex chunk
  if(pos3 > 0){fseek(fo,pos3,0); // size of edge chunk 
    if(Nedge < 65536)outlng(4*newedge); else  outlng(8*newedge);
  }
  if(pos4   > 0){fseek(fo,pos4,0);   outlng(20*newface);}     // size of face chunk
  if(posB   > 0){fseek(fo,posB,0);   outlng(12*newglue);}     // Glue vertex coords
  if(pos5   > 0){fseek(fo,pos5,0);   outlng(pos6-pos5-4);}    /* image map !inc size */
  if(posMs  > 0){fseek(fo,posMs,0);  outlng(posMe-posMs-4);}  /* materials           */
  if(posIs  > 0){fseek(fo,posIs,0);  outlng(posIe-posIs-4);}  /* embedded images     */
  if(posXs  > 0){fseek(fo,posXs,0);  outlng(posXe-posXs-4);}  /* Face mapping coords */
  if(pos7   > 0){fseek(fo,pos7,0);   outlng(pos8-pos7-4);}    /* skeleton            */
  if(posH   > 0){fseek(fo,posH,0);   outlng(posG-posH-4);}    /* Nurbs surfaces      */
  if(posVXs > 0){fseek(fo,posVXs,0); outlng(posVXe-posVXs-4);}/* vertex selection    */
  fseek(fo,pos1,0); outlng(pose-8);
  fclose(fo);
  if(status < 2)SendPrgmMessage(IDS_CURRENT,0);
  if(status < 3)SetCursor(hSave);
  return;
}

static void WriteImageMaps(void){
 long i,temp,j;
 skel *sp;
 long v,zero=0;
 char n256[256];
 i=0;
 memset(n256,0,256);
 sp=FirstSp; while(sp != NULL){ /* set up sk id */
   sp->id=i; i++;
   sp=sp->next;
 }
 outlng((long)nImaps);
 for(i=0;i<nImaps;i++){
   outlng(iMap[i].P[0]); outlng(iMap[i].P[1]); outlng(iMap[i].P[2]);
   outlng(iMap[i].X[0]); outlng(iMap[i].X[1]); outlng(iMap[i].X[2]);
   outlng(iMap[i].Y[0]); outlng(iMap[i].Y[1]); outlng(iMap[i].Y[2]);
   temp=iMap[i].Type;    outlng(temp); for(j=0;j<3;j++)outlng(zero);
   temp=iMap[i].TypeR;   outlng(temp); for(j=0;j<3;j++)outlng(zero);  
   temp=iMap[i].TypeB;   outlng(temp); for(j=0;j<3;j++)outlng(zero);  
   temp=iMap[i].TypeT;   outlng(temp); for(j=0;j<3;j++)outlng(zero);
   temp=0; outlng(temp); // No skeleton attachment is recorded
   temp=iMap[i].Map; outlng(temp);   /* 0 = plane 1 = cyl. map  2/3 = moz */
   temp=iMap[i].Angle; outlng(temp); /* angle for cylinder brushes */
   // Locking is not stored any more
   temp=0; outlng(temp); outlng(temp); outlng(temp); outlng(temp);
   fwrite(iMap[i].N,1,32,fo);
   fwrite(&iMap[i].s,1,1,fo);
   fwrite(&iMap[i].r,1,1,fo);
   fwrite(&iMap[i].b,1,1,fo);
   fwrite(&iMap[i].t,1,1,fo);
   fwrite(&iMap[i].Key,1,1,fo);
   outsht(iMap[i].sp);
   outsht(iMap[i].rp);
   outsht(iMap[i].bp);
   outsht(iMap[i].tp);
   fwrite(iMap[i].d_colour,1,3,fo);
   fwrite(iMap[i].s_colour,1,3,fo);
   fwrite(iMap[i].a_colour,1,3,fo);
   fwrite(iMap[i].k_colour,1,3,fo);
   memset(n256,0,256); 
   if(iMap[i].s && iMap[i].S != NULL)sprintf(n256,"%s",iMap[i].S);
   fwrite(n256,1,256,fo);
   memset(n256,0,256); 
   if(iMap[i].r && iMap[i].R != NULL)sprintf(n256,"%s",iMap[i].R);
   fwrite(n256,1,256,fo);
   memset(n256,0,256); 
   if(iMap[i].b && iMap[i].B != NULL)sprintf(n256,"%s",iMap[i].B);
   fwrite(n256,1,256,fo);
   memset(n256,0,256);
   if(iMap[i].t && iMap[i].T != NULL)sprintf(n256,"%s",iMap[i].T);  
   fwrite(n256,1,256,fo);
   temp=(long)iMap[i].version;  outlng(temp);
   temp=(long)iMap[i].bDecal;   outlng(temp);
   temp=(long)iMap[i].bShaded;  outlng(temp);
   temp=(long)iMap[i].bTiled;   outlng(temp);
 }
}

static void  WriteEmbeddedImages(void){
 int i;
 outlng((long)nImaps);
 for(i=0;i<nImaps;i++){
   WriteRamImage((&iMap[i].si),fo);
   WriteRamImage((&iMap[i].ri),fo);
   WriteRamImage((&iMap[i].bi),fo);
   WriteRamImage((&iMap[i].ti),fo);
 } 
}

static void WriteMaterials(void){
 int j,k;
 long temp,ln,lp;
 outlng((long)nMats);  /* number of materials in this model */
 for(k=0;k<nMats;k++){
   temp=iMat[k].version; outlng(temp);
   fwrite(iMat[k].name,1,32,fo);
   fwrite(iMat[k].mcolour1,1,3,fo); 
   fwrite(iMat[k].mcolour2,1,3,fo); 
   fwrite(iMat[k].acolour,1,3,fo);
   fwrite(iMat[k].scolour,1,3,fo);
   fwrite(iMat[k].xcolour,1,3,fo);
   fwrite(iMat[k].ycolour,1,3,fo);
   fwrite(iMat[k].zcolour,1,3,fo);
   temp=(long)iMat[k].gloss; outlng(temp);
   temp=(long)iMat[k].refl; outlng(temp);
   temp=(long)iMat[k].transp; outlng(temp);
   temp=(long)iMat[k].refractive_index; outlng(temp);
   temp=(long)iMat[k].bInternalShader; outlng(temp);
   temp=(long)iMat[k].internalShaderID; outlng(temp);
   for(j=0;j<3;j++){temp=(long)iMat[k].ax.P[j]; outlng(temp);}
   for(j=0;j<3;j++){temp=(long)iMat[k].ax.X[j]; outlng(temp);}
   for(j=0;j<3;j++){temp=(long)iMat[k].ax.Y[j]; outlng(temp);}
   for(j=0;j<4;j++){
     temp=(long)iMat[k].Shader[j].version; outlng(temp);
     temp=(long)iMat[k].Shader[j].bActive; outlng(temp);
     temp=(long)iMat[k].Shader[j].in_use; outlng(temp);
     if(iMat[k].Shader[j].in_use){
       temp=ln=(long)strlen(iMat[k].Shader[j].xname); outlng(temp);
       temp=lp=(long)strlen(iMat[k].Shader[j].parameters); outlng(temp);
       fwrite(iMat[k].Shader[j].xname,1,ln+1,fo);
       fwrite(iMat[k].Shader[j].parameters,1,lp+1,fo);
       //{char ttt[256]; sprintf(ttt,"Mat %ld Shader %ld - ln=%ld lp=%ld [%s] [%s]",k,j,ln,lp,
       //iMat[k].Shader[j].parameters,iMat[k].Shader[j].xname);
       //MessageBox(NULL,ttt,"Shader",MB_OK);}
     }
   }
   temp=(long)iMat[k].bSmooth; outlng(temp);
   temp=(long)iMat[k].bShiny; outlng(temp);
   temp=(long)iMat[k].bClear; outlng(temp);
   temp=(long)iMat[k].bGlassEdge; outlng(temp);
   temp=(long)iMat[k].bUseSurfaceMapping; outlng(temp);
   for(j=0;j<16;j++){temp=(long)iMat[k].params[j]; outlng(temp);}
   for(j=0;j<16;j++){temp=(long)iMat[k].pad[j]; outlng(temp);}  // padding
   sprintf(iMat[k].other_properties,"%.3lf %.3lf %.3lf %.3lf %3lf %.3lf %.3lf %.3lf %.3lf %.5lf %.5lf %.3lf %.5lf %.5lf %.3lf",
       (iMat[k].mmw[ 0]),(iMat[k].mmw[ 1]),(iMat[k].mmw[ 2]),
       (iMat[k].mmw[ 3]),(iMat[k].mmw[ 4]),(iMat[k].mmw[ 5]),
       (iMat[k].mmw[ 6]),(iMat[k].mmw[ 7]),(iMat[k].mmw[ 8]),
       (iMat[k].mmw[ 9]),(iMat[k].mmw[10]),(iMat[k].mmw[11]),
       (iMat[k].mmw[12]),(iMat[k].mmw[13]),(iMat[k].mmw[14]));
   if(iMat[k].mmw[5] > 2.0)strcpy(&(iMat[k].other_properties[300]),iMat[k].mmw_brdf);   //copy in the BRDF filename
   else iMat[k].other_properties[300]=0;
   WriteByteBuffer(512,iMat[k].other_properties);  // for other material properties
 }
 return;
}

static void WriteVertices(short status){
 long i,j;
 vertex  *vp;
 i=0;
 vp=MainVp; for(j=0;j<Nvert;j++){
  if(status == 2){ /* for use in renderer */
    if(intriview(vp)){
      outlng(vp->xyz[0]); outlng(vp->xyz[1]); outlng(vp->xyz[2]);
      vp->id=i;
      i++; newvert++;
    }
    else vp->id = -1;
  }
  else if( (status==1) || (status == 3) || (vp->status==SELECTED) ){
    outlng(vp->xyz[0]); outlng(vp->xyz[1]); outlng(vp->xyz[2]);
    vp->id=i;
    i++; newvert++;
  }
  else vp->id = -1;
  vp++;
 }
}

static void WriteVerticesSelection(short status){
 long i,j;
 char t;
 vertex  *vp;
 i=0;
 vp=MainVp; for(j=0;j<Nvert;j++){
  if(status == 2){ /* for use in renderer */
    if(intriview(vp)){
      if(vp->status == SELECTED)t=0;
      else if(vp->status == DESELECTED)t=1;
      else if(vp->status == HIDDEN)t=2;
      fwrite(&t,1,1,fo);
      i++;
    }
    else vp->id = -1;
  }
  else if( (status==1) || (status == 3) || (vp->status==SELECTED) ){
    if(vp->status == SELECTED)t=0;
    else if(vp->status == DESELECTED)t=1;
    else if(vp->status == HIDDEN)t=2;
    fwrite(&t,1,1,fo);
    i++; 
  }
  vp++;
 }
}


static void WriteVertexMapping(short status){ // new structure - every vertex
 long j,i,ix,iy,temp;
 vertex *vp;
 i=0;
 vp=MainVp; for(j=0;j<Nvert;j++){
  if(status == 2){ /* for use in renderer */
    if(intriview(vp)){
      ix=(long)(vp->x * 1.0e6); iy=(long)(vp->y * 1.0e6);
      temp=(long)vp->gp; outlng(temp); outlng(ix); outlng(iy);
      newglue++;
      i++;
    }
  }
  else if( (status==1) || (status == 3) || (vp->status==SELECTED) ){
    ix=(long)(vp->x * 1.0e6); iy=(long)(vp->y * 1.0e6);
    temp=(long)vp->gp; outlng(temp); outlng(ix); outlng(iy);
    newglue++;
    i++;
  }
  vp++;
 }
}

static void WriteFaceMapping(void){
 face *f;
 long i,j,ix,iy,temp;
 vertex *V0,*V1,*V2;
 f=MainFp;
 for(i=0;i<Nface;i++){
   V0=(MainVp+f->V[0]); V1=(MainVp+f->V[1]); V2=(MainVp+f->V[2]);
   if((V0->id >= 0) &&
      (V1->id >= 0) &&
      (V2->id >= 0)){
     temp=(long)f->gp; outlng(temp); 
     for(j=0;j<3;j++){
       ix=(long)(f->x[j] * 1.0e6); iy=(long)(f->y[j] * 1.0e6); 
       outlng(ix); outlng(iy);
     }
   }
   f++;
 }
}


static void WriteEdges(BOOL short_form){
 unsigned short ids1,ids2;
 long i,idl1,idl2;
 edge *ep;
 vertex *V0,*V1;
 ep=MainEp;
 for(i=0;i<Nedge;i++){
   V0=(MainVp+ep->V[0]); V1=(MainVp+ep->V[1]);
   if((V0->id >= 0) && (V1->id >= 0)){
     if(short_form){
       ids1=(unsigned short)V0->id; ids2=(unsigned short)V1->id;
       outusht(ids1); outusht(ids2);
     }
     else{
       idl1=V0->id; idl2=V1->id;
       outlng(idl1); outlng(idl2);
     }
     newedge++;
   }
   ep++;
 }
}

static void WriteFaces(void){
 face *f;
 unsigned short ids;
 long i,idl;
 vertex *V0,*V1,*V2;
 f=MainFp;
 for(i=0;i<Nface;i++){
   V0=(MainVp+f->V[0]); V1=(MainVp+f->V[1]); V2=(MainVp+f->V[2]);
   if((V0->id >= 0) &&
      (V1->id >= 0) &&
      (V2->id >= 0)){
     idl=V0->id; outlng(idl);
     idl=V1->id; outlng(idl);
     idl=V2->id; outlng(idl);
     fwrite(f->color,1,3,fo);
     fwrite(&f->bSmooth,1,1,fo);
     outsht(f->material);
     outsht(f->imagemap);
     newface++;
   }
   f++;
 }
}

static void WriteSkeleton(void){
 long i,j;
 skel *sp;
 vertex *vp;
 long l;
 long k;
 i=0;
 sp=FirstSp; while(sp != NULL){
   sp->id=i; i++;
   sp=sp->next;
 }
 outlng(Nskel);
 sp=FirstSp; while(sp != NULL){
   outlng(sp->xyz[0]); outlng(sp->xyz[1]); outlng(sp->xyz[2]);
   if(sp->at != NULL)outlng(sp->at->id);
   else              outlng(0);
   fwrite(sp->name,sizeof(char),16,fo);
   l=(long)(sp->weight*1000.0); outlng(l);
   l=(long)(sp->wrange*1000.0); outlng(l);
   l=(long)(sp->wzone*1000.0); outlng(l);
   for(j=0;j<3;j++){l=(long)(sp->u[j]*1.0e8); outlng(l);}
   for(j=0;j<3;j++){l=(long)(sp->v[j]*1.0e8); outlng(l);}
   for(j=0;j<3;j++){l=(long)(sp->w[j]*1.0e8); outlng(l);}
   for(i=0;i<8;i++)for(j=0;j<3;j++)outlng(sp->bx[i][j]);
   sp=sp->next;
 }
 outlng(Nvert);
 vp=MainVp; for(k=0;k<Nvert;k++){
   if(vp->sp != NULL)outlng(vp->sp->id);
   else              outlng(0);
   vp++;
 }
}

static void WriteWireframe(void){
 long i;
 if(w_frame.Np == 0 || w_frame.Ne == 0)return;
 fprintf(fo,"WFRM");
 outlng((long)(((w_frame.Np*3)+(w_frame.Ne*2)+2)*sizeof(long)));
 outlng(w_frame.Np); outlng(w_frame.Ne);
 for(i=0;i<w_frame.Np;i++){
   outlng(w_frame.p[i][0]);
   outlng(w_frame.p[i][1]);
   outlng(w_frame.p[i][2]);
 }
 for(i=0;i<w_frame.Ne;i++){
   outlng(w_frame.e[i][0]); outlng(w_frame.e[i][1]);
 }
}



void LoadAApoly(int aa_or_not_aa, char *filename){  // loads paths
 FILE *fpp;
 long vp,vpf;
 short  fail,points,x,y,z,i;
 long xx,yy,zz;
 unsigned char closed,magic;
 long   packer;
 if((fpp=fopen(filename,"rb")) == NULL){
   SendPrgmQuery(IDQ_FILEOPENFAIL,0);
   return;
 }
 if(fread(&points,2,1,fpp) != 1)goto NOREAD;
 if(fread(&packer,4,1,fpp) != 1)goto NOREAD;
 if(fread(&closed,1,1,fpp) != 1)goto NOREAD;
 if(aa_or_not_aa){
   if(fread(&magic,1,1 ,fpp)  != 1 || magic != 0x99)goto NOREAD;
 }
 else{
   if(fread(&magic,1,1 ,fpp)  != 1 || magic != 0x88)goto NOREAD;
 }
 if(points == 0)goto NOREAD;
 if(!UpdateVertexHeap(Nvert+(long)points))goto NOREAD;
 if(!UpdateEdgeHeap(Nedge+(long)points+1))goto NOREAD;
 for(i=0; i< points; i++){
   if(aa_or_not_aa){
     if(fread(&x,2,1,fpp) != 1)goto NOREAD;
     if(fread(&y,2,1,fpp) != 1)goto NOREAD;
     if(fread(&z,2,1,fpp) != 1)goto NOREAD;
     vp=Nvert-1;
     CreateVertex();
     (MainVp+Nvert-1)->xyz[0] = ((long)x-160)*200;
     (MainVp+Nvert-1)->xyz[1] = 0;
     (MainVp+Nvert-1)->xyz[2] = ((long)y-100)*(-200);
   }
   else{
     if(fread(&xx,4,1,fpp) != 1)goto NOREAD;
     if(fread(&yy,4,1,fpp) != 1)goto NOREAD;
     if(fread(&zz,4,1,fpp) != 1)goto NOREAD;
     vp=Nvert-1;
     CreateVertex();
     (MainVp+Nvert-1)->xyz[0] = xx;
     (MainVp+Nvert-1)->xyz[1] = yy;
     (MainVp+Nvert-1)->xyz[2] = zz;
   }
   if(i > 0 && vp >= 0){
     CreateEdge(Nvert-1,vp);
   }
   else if(i == 0)vpf=Nvert-1;
 }
 if(closed == 1 && vpf >= 0)CreateEdge(vpf,Nvert-1);
 goto READOK;
 NOREAD:
 if(aa_or_not_aa)SendPrgmQuery(IDQ_NOTAAPROPATH,0);
 else            SendPrgmQuery(IDQ_NOTPATHFILE,0);
 READOK:
 fclose(fpp);
 UpdateVertexHeap(Nvert);
 UpdateEdgeHeap(Nedge);
 return;
}

void SavePath(void){
 vertex *Va;
 long *va;
 int a,id,Np;
 char closed;
 unsigned char magic;
 FILE *fpp;
 long Npath,packer=0,i;
 if((va=GetPathList(&Npath)) != NULL){
   a=MessageBox (ghwnd_main,"Save as Closed Path","Save Path",
                 MB_YESNOCANCEL | MB_ICONQUESTION | MB_TASKMODAL);
   if    (a == IDYES)id=1;
   else if(a == IDNO)id=0;
   else id = -1;
   if(id == 0 || id == 1){
     if(SelectSfxFileName(1,gszPTHfile,gszPTHdir,IDX_MISC_WRITEPATH,
        "(*.PTH)|*.pth|",ghwnd_main) == TRUE){
       AppendFileExtension(gszPTHfile,".pth");
       closed = (char)id;
       if((fpp=fopen(gszPTHfile,"wb")) == NULL){
         SendPrgmQuery(IDQ_FILEOPENFAIL,0);
         goto XXIT;
       }
       Np=(short)Npath;
       if(fwrite(&Np,2,1,fpp) != 1)goto NOWRITE;
       if(fwrite(&packer,4,1,fpp) != 1)goto NOWRITE;
       if(fwrite(&closed,1,1,fpp) != 1)goto NOWRITE;
       magic = 0x88;
       if(fwrite(&magic,1,1 ,fpp)  != 1)goto NOWRITE;
       if(Npath == 0)goto NOWRITE;
       for(i=0; i< Npath; i++){
         Va=(MainVp+va[i]);
         if(fwrite(&(Va->xyz[0]),4,1,fpp) != 1)goto NOWRITE;
         if(fwrite(&(Va->xyz[1]),4,1,fpp) != 1)goto NOWRITE;
         if(fwrite(&(Va->xyz[2]),4,1,fpp) != 1)goto NOWRITE;
       }
       goto READOK;
       NOWRITE:
       SendPrgmQuery(IDQ_SAVINGERROR,0);
       READOK:
       fclose(fpp);
     }
   }
   XXIT:
   X__Free(va);
   DrawVerticesOnly(NULL);
   UpdateCounters();
 }
 else{
   SendPrgmQuery(IDQ_NOPATHSTART,0);
 }
}


static long  Undo_Vertex = -1;
static long  Undo_Edge   = -1;
static long  Undo_Face   = -1;
static short Undo_Active  = 0;
static BOOL *Undo_Flag=NULL;

void Save_Undo(short model){
  long sizz,i,j;
  vertex *vp;
  skel *sp;
  char workfile[128],*ud;
  EDIT_ACTION=YES;
  if(!UNDO_ON)return;
  Empty_Undo();
  if(Nvert == 0)return; 
  vp=MainVp; for(j=0;j<Nvert;j++){
    vp->status_undo=vp->status;  vp++;
  }
  if(model == 0){/* need only current numbers and statis flags */
    Undo_Vertex=Nvert;
    Undo_Edge=Nedge;
    Undo_Face=Nface;
    Undo_Active=1;
  }
  else if(model == 1){/* need to save position info as well */
    Undo_Vertex=Nvert;
    Undo_Edge=Nedge;
    Undo_Face=Nface;
    Undo_Active=2;
    vp=MainVp; for(j=0;j<Nvert;j++){
     memcpy(vp->xyz_undo,vp->xyz,3*sizeof(long)); // status already copied
     vp++;
    }
    if(Nskel > 0){
      sp=FirstSp; while(sp != NULL){
        VECCOPY(sp->xyz,sp->xyz_undo)
        for(j=0;j<8;j++)VECCOPY(sp->bx[j],sp->bx_undo[j])
        sp=sp->next;
      }
    }
  }
  else{  /* model = 2 use  temp device */
    sprintf(workfile,"%sundo_$.$$$",TempPath);
    if((fo=fopen(workfile,"wb")) == NULL){
      SendPrgmQuery(IDQ_NOUNDOSPACE,0);
      return;
    }
    if((Undo_Flag=(BOOL *)X__Malloc(Nvert*sizeof(BOOL))) != NULL){
      for(vp=MainVp,j=0;j<Nvert;j++,vp++)Undo_Flag[j]=vp->status;
    }
    newvert=0; newface=0; newedge=0; newglue=0;
    outlng(12*(long)Nvert);
    outlng(12*(long)Nvert);  // size of Vertex Mapping data
    outlng( 8*(long)Nedge);
    outlng(20*(long)Nface);  // number of bytes written
    outlng(   (long)Nskel);
    outlng(   (long)Nnurbs);
    outlng(28*(long)Nface);
    if(Nvert  > 0)WriteVertices(1);
    if(Nedge  > 0)WriteEdges(FALSE);
    if(Nface  > 0)WriteFaces();
    if(Nface  > 0)WriteFaceMapping();
    if(Nskel  > 1)WriteSkeleton();
    if(Nvert  > 0)WriteVertexMapping(1);
    if(Nnurbs > 0)WriteNurbs(fo);
    fclose(fo);
    Undo_Active=3;
  }
}

void Restore_Undo(void){
 short id;
 char workfile[128];
 long i,j,nv,ne,nf,ns,nn,ng,nm;
 vertex *vp;
 skel *sp;
 if(Undo_Active == 0){
   SendPrgmQuery(IDQ_NOUNDO,0);
   return;
 }
 else if(SelectedBrush >= 0 || SelectedShader >= 0){
   SendPrgmQuery(IDQ_UNDONOTREADY,0);
   return;
 }
 LastToolVertex= -1;    /* incase undo in middle of tool */
 if(Undo_Active < 3){   /* undo for extras or positions  */
    if(Nvert > Undo_Vertex){  /* get rid of effects of deleted vertices */
     vp=(MainVp+Undo_Vertex); for(i=Undo_Vertex;i<Nvert;i++){
       vp->status=SELECTED;
       vp++;
     }
     Delete_Bcurve(); Delete_MapLock();
   }
   UpdateVertexHeap(Undo_Vertex); Nvert=Undo_Vertex;
   UpdateEdgeHeap(Undo_Edge);     Nedge=Undo_Edge;
   UpdateFaceHeap(Undo_Face);     Nface=Undo_Face;
}
if(Undo_Active == 1){
   NvertSelect=0;  NvertDeselect=0; // restore and status
   if(Nvert > 0 && MainVp != NULL){
     vp=MainVp; for(i=0;i<Nvert;i++){
       vp->status=vp->status_undo;
       if(vp->status == SELECTED)NvertSelect++;
       else                      NvertDeselect++;
       vp++;
     }
   }
}
else if(Undo_Active == 2){
   NvertSelect=0;  NvertDeselect=0; // restore positions and status
   if(Nvert > 0 && MainVp != NULL){
     vp=MainVp; for(i=0;i<Nvert;i++){
       memcpy(vp->xyz,vp->xyz_undo,3*sizeof(long));
       vp->status=vp->status_undo;
       if(vp->status == SELECTED)NvertSelect++;
       else                      NvertDeselect++;
       vp++;
     }
   }
   if(Nskel > 0){
     sp=FirstSp; while(sp != NULL){
       VECCOPY(sp->xyz_undo,sp->xyz)
       for(j=0;j<8;j++)VECCOPY(sp->bx_undo[j],sp->bx[j])
       sp=sp->next;
     }
   }
 }
 else { /*  UNDO 3    off disk */
   sprintf(workfile,"%sundo_$.$$$",TempPath);
   fq=CreateFile(workfile,GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,
      FILE_ATTRIBUTE_READONLY,(HANDLE)NULL);
   if(fq == INVALID_HANDLE_VALUE){
     SendPrgmQuery(IDQ_NOUNDOSPACE,0);
     Empty_Undo();
     return;
   }
   getlon(&nv);
   getlon(&ng);
   getlon(&ne);
   getlon(&nf);
   getlon(&ns);
   getlon(&nn);
   getlon(&nm);
   EraseAll(0);  /* erase all vertices faces edges nurbs and skeleton no redraw */
   if(nv > 0)ReadVertices(nv);
   if(ne > 0)ReadEdges(ne,FALSE);
   if(nf > 0)ReadFaces(nf);
   if(nm > 0)ReadFaceMapping(nm);
   if(ns > 1)ReadSkeleton(0L,3);  /* no size necessary */ 
   if(nv > 0)ReadVertexMapping(ng,1);
   if(nn > 0)ReadNurbs(0,0,fq);
   CloseHandle(fq);
   remove(workfile);
   NvertSelect=0;  NvertDeselect=0; 
   if(nv > 0 && Undo_Flag != NULL){
    for(vp=MainVp,j=0;j<Nvert;j++,vp++){
      vp->status=Undo_Flag[j];
      if(vp->status == SELECTED)NvertSelect++;
      else                      NvertDeselect++;
    }
   }
   if(Undo_Flag != NULL)X__Free(Undo_Flag);  Undo_Flag=NULL; 
 }
 Empty_Undo();
 DrawModel();
 UpdateCounters();
 if(tool > INZOOM)Save_Undo(1);
}

void Empty_Undo(void){
 char workfile[256];
 if(Undo_Active == 1 || Undo_Active == 2){
   Undo_Vertex = -1;
   Undo_Edge   = -1;
   Undo_Face   = -1;
 }
 else if(Undo_Active == 3){
   if(Undo_Flag != NULL)X__Free(Undo_Flag);  Undo_Flag=NULL; 
   sprintf(workfile,"%sundo_$.$$$",TempPath);
   remove(workfile);
 }
 Undo_Active=0;
}

#if 0
static void ReadAndAddSkeleton(long clen, short version, short relaTion){  //  NOT USED NOW
  vertex *v;
  char c;
  long i,j,k,l,szz,n,x,y,z,nskel;
  skel *sp,**s,*RootSp;
  short dummy;
  long dummyl,ol[3]={0,0,0}; 
  getlon(&n);
  if(n == 0)return; nskel=n;
  if(nskel > 512){DumpSkeleton(nskel,clen); return;}
  szz=sizeof(skel *);
  s=(skel  **)X__Malloc((long)(szz*n));
  if(s == NULL){
    SendPrgmQuery(IDQ_NOMEM2,0);
    CloseHandle(fq);
    longjmp(j_buf,0);
  }
  if(relation == 1){ /* the brush must be repositioned to new offset */
    ol[0]=NpointerX-TempAxis.Origin.xyz[0]; // offsets
    ol[1]=NpointerY-TempAxis.Origin.xyz[1]; // offsets
    ol[2]=NpointerZ-TempAxis.Origin.xyz[2]; // offsets
  }
  CreateSkeleton(NULL);   // This is a root node for the new part, join it to the main Skeleton
  for(j=0;j<3;j++){getlon(&MainSp->xyz[j]);  MainSp->xyz[j] += ol[j];}

  if(version < 3){getsht(&dummy);  dummyl=(long)dummy;}
  else           {getlon(&dummyl);}
  if(dummyl < 0 || dummyl >= nskel){MainSp->id=0;}
  else MainSp->id = dummyl;
  if(version > 0){
    ReadFile(fq,MainSp->name,sizeof(char)*16,&dwRead,NULL);
  }
  if(version > 1){
    for(j=0;j<3;j++){getlon(&l); MainSp->u[j] = ((double)l)*1.0e-8;}
    for(j=0;j<3;j++){getlon(&l); MainSp->v[j] = ((double)l)*1.0e-8;}
    for(j=0;j<3;j++){getlon(&l); MainSp->w[j] = ((double)l)*1.0e-8;}
    for(j=0;j<8;j++)for(k=0;k<3;k++){getlon(&(MainSp->bx[j][k])); MainSp->bx[j][k] += ol[k]; } 
  }
  RootSp=MainSp;
  MainSp->at=FirstSp; 
  *s = MainSp;
  if(n > 1)for(i=1;i<n;i++){
    CreateSkeleton(NULL);
    for(j=0;j<3;j++){getlon(&MainSp->xyz[j]); MainSp->xyz[j] += ol[j]; }
    if(version < 3){getsht(&dummy); MainSp->id=(long)dummy;}
    else           {getlon(&dummyl); MainSp->id = dummyl;}
    if(version > 0){
      ReadFile(fq,MainSp->name,sizeof(char)*16,&dwRead,NULL);
    }
    if(version > 1){
      for(j=0;j<3;j++){getlon(&l); MainSp->u[j] = ((double)l)*1.0e-8;}
      for(j=0;j<3;j++){getlon(&l); MainSp->v[j] = ((double)l)*1.0e-8;}
      for(j=0;j<3;j++){getlon(&l); MainSp->w[j] = ((double)l)*1.0e-8;}
      for(j=0;j<8;j++)for(k=0;k<3;k++){getlon(&(MainSp->bx[j][k])); MainSp->bx[j][k] += ol[k]; }
    }
    *(s+i)=MainSp;
  }
  if((sp = RootSp->next) != NULL)while(sp != NULL){ /* fix up pointers */
    sp->at = *(s + (long)sp->id);
    sp=sp->next;
  }
  getlon(&n);
  if(n != newvert){
    SendPrgmQuery(IDQ_HERROR,0);
    for(i=0;i<n;i++){
      if(version < 3)getsht(&dummy);
      else           getlon(&dummyl);
    }
  }
  else{
    v=(MainVp+VertexBase);
    for(i=0;i<n;i++){
                if(version < 3){getsht(&dummy); dummyl=(long)dummy;}   /* put into new vertex the pointer to the sk joint */
      else          getlon(&dummyl);
      if(dummyl > 0 && dummyl < nskel)v->sp = *(s+(long)dummyl);
      else                            v->sp = NULL;
      v++;
    }
  }
  X__Free(s);
}
#endif