LOADER.C

Go to the documentation of this file.

/* file loader.c    */

#define MODULE_LOADER 1

#include "animate.h"
#include "callall.h"

static char WIN32_environment[512];

char *R_GetEnv(char const *aa){
 if(GetEnvironmentVariable((LPTSTR)aa,(LPTSTR)WIN32_environment,256) == 0)
   return NULL;
//MessageBox(NULL,WIN32_environment,aa,MB_OK);
 return WIN32_environment;
}

typedef struct {
 char *old,*new;
 object *Op;
} discarded_file;


static FILE *fo,*fr;
static long newface,newedge,newvert,newnurbs,n_discarded=0,
            minX,minY,minZ,maxX,maxY,maxZ;
static char str[8]={0,0,0,0,0,0,0,0},RAMfilename[256];
static discarded_file *discarded_file_list=NULL;

static short TryAgainToLoad(char *filename, object *Op);
static void StageReadSkeleton(long clen, object *Op, short version, HANDLE);
static void StageReadAxis(long clen, object *Op, HANDLE);
static short StageReadEdges(long clen, object *Op, BOOL short_form, HANDLE);
static void StageReadVertices(long clen, object *Op, HANDLE);
static void StageReadWireframe(long clen, object *Op, HANDLE);
static void StageReadNurbs(long clen, object *Op, HANDLE);
static HANDLE SearchForFile(char *, char *);
static void LoadEmbeddedImageMaps(long chunk_size, FILE *fr);
static void WriteEmbeddedImageMaps(FILE *fr);
static void UnpackName(char *name);

#include "wspaces.c"


static short TryAgainToLoad(char *filename, object *Op){
 long i;
 discarded_file *temp;
 char title[256];
 if(GetAsyncKeyState(VK_CONTROL) & 0x8000)return NO;
 i=max(0,((long)strlen(filename)-25));
 if(i > 0)sprintf(title,"Rep: ...%s",(filename+i));
 else     sprintf(title,"Replace %s",filename);
 if(SelectFileName(0,gszSCEfile,gszSCEdir,title,"(*.MFX)|*.mfx|",ghwnd_main)
          == TRUE){
   temp=(discarded_file*)X__Realloc(discarded_file_list,
      sizeof(discarded_file)*(n_discarded+1));
   if(temp != NULL){  /* make a list so that any other objects of the same */
     discarded_file_list=temp; /* file are also redirected */
     discarded_file_list[n_discarded].old=strdup(filename);
     discarded_file_list[n_discarded].new=strdup(gszSCEfile);
     discarded_file_list[n_discarded].Op=Op;
     n_discarded++;
   }
   strcpy(filename,gszSCEfile);
   return YES;
 }
 return NO;
}

void ReplaceOneObjectFile(node *Np, object *Lop, char *NewName){
 short robot;
 long ff,lf;
 skel *S,*Scopy;
 long i,nSkelO;
 lf=Lop->lastframe;
 ff=Lop->firstframe;
 Scopy=NULL;
 if(Lop->type == ROBOT){ // make copy of skeleton
   S=Lop->skeleton;
   nSkelO=Lop->nskeleton;
   if(nSkelO > 0 && S != NULL){
     Scopy=(skel *)X__Malloc(nSkelO*sizeof(skel));
     if(Scopy != NULL)memcpy(Scopy,S,nSkelO*sizeof(skel));
   }
 }
 DeleteCostume(Np,Lop->lastframe);
 Lop=CreateCostume(Np,ff,lf);
 if(fail_op == YES){;}
 else if(Lop == NULL){;}
 else{
   Lop->type=Np->type;
   strcpy(Lop->name,NewName);
   if(Lop->type == ROBOT)robot=YES;
   else                  robot=NO;
   if(LoadMeshObject(NewName,Lop,YES,YES,robot) == FAIL){
     DeleteCostume(Np,lf);
   }
   else{
     if(Lop->type == ROBOT){
       if(Lop->nskeleton == nSkelO && Lop->skeleton != NULL && Scopy != NULL){ // copy back the robot pose
         memcpy(Lop->skeleton,Scopy,nSkelO*sizeof(skel)); 
       } 
     }
   }
 }
 if(Scopy != NULL)X__Free(Scopy);
 return;
}

void ReplaceObjectFile(object *Lop, char *NewName){
 node   *Np;
 object *Op;
 point  *P,*Pw,origin,offset;
 Sedge  *E,*Ew;
 long   *Skid;
 skel   *S;
 nurbs  *Nn;
 short fileid,inram,robot;
 long i,j,nNurbs,nSkelO;
 char Oldname[256];
 P=Lop->points;
 E=Lop->edges;
 S=Lop->skeleton;
 nSkelO=Lop->nskeleton;
 Pw=Lop->w_frame.p;
 Ew=Lop->w_frame.e;
 nNurbs=Lop->nNurbs;
 Nn=Lop->Nurbs;
 Skid=Lop->skid;
 fileid = Lop->fileID;
 inram=Lop->in_ram;
 CopyPoint(Lop->origin,origin);
 CopyPoint(Lop->offset,offset);
 if(Lop->type == ROBOT)robot=YES;
 else                  robot=NO;
 if(LoadMeshObject(NewName,Lop,YES,NO,robot) == FAIL){
   SendPrgmQuery(IDQ_OLD3,0);  /* put back anything that might have changed */
   Lop->in_ram=inram;
   CopyPoint(origin,Lop->origin);
   CopyPoint(offset,Lop->origin);
 }
 else{
   sprintf(RAMfilename,"%s%d.$$$",TempPath,fileid);
//   remove(RAMfilename);
   strcpy(Oldname,Lop->name);
   strcpy(Lop->name,NewName);
   if(P != NULL)X__Free(P);
   if(E != NULL)X__Free(E);
   if(robot && S != NULL  && Lop->nskeleton == nSkelO){ // can copy the old skeleton pose to the new one
     for(i=0;i<nSkelO;i++){
       memcpy(&(Lop->skeleton[i]),&(S[i]),sizeof(skel));
     }
   }
   if(S != NULL)X__Free(S);
   if(Pw != NULL)X__Free(Pw);
   if(Ew != NULL)X__Free(Ew);
   if(Skid != NULL)X__Free(Skid);
   if(Nn != NULL)FreeNurbs(nNurbs,Nn);
   if((Np=FirstNp) != NULL)while(Np != NULL){ /* update any other same model */
     if((Op=Np->fobj) != NULL)while(Op != NULL){
       if(strcmp(Oldname,Op->name) == 0 && Op != Lop){
         for(j=0;j<3;j++){
           Op->origin[j] = Lop->origin[j];
           Op->offset[j] = Lop->offset[j];
           for(i=0;i<8;i++){
             Op->outline[i][j]  = Lop->outline[i][j];
           }
         }
         strcpy(Op->name,Lop->name);
         Op->npoints   = Lop->npoints;
         Op->nedges    = Lop->nedges;
         Op->points    = Lop->points;
         Op->edges     = Lop->edges;
         Op->in_ram    = Lop->in_ram;
         Op->fileID    = Lop->fileID;
         Op->skid      = Lop->skid;
         Op->nNurbs    = Lop->nNurbs;
         Op->Nurbs     = Lop->Nurbs;
         Op->bIKchain  = Lop->bIKchain;
         if(Op->nskeleton != Lop->nskeleton){/* skeketons incompatible */
           SendPrgmQuery(IDQ_SKELINCOMPAT,0);
         }
         Op->nskeleton = Lop->nskeleton;
         Op->w_frame.Np= Lop->w_frame.Np;
         Op->w_frame.Ne= Lop->w_frame.Ne;
         Op->w_frame.e = Lop->w_frame.e;
         Op->w_frame.p = Lop->w_frame.p;
       }
       Op=Op->next;
     }
     Np=Np->next;
   }
 }
}

void DeleteRamFile(short id, object *op){
 /* remove only if single object present  - delete from ram if INRAM */
 node   *Np;
 object *Op;
 int idcount;
 idcount=0;
 if((Np=FirstNp) != NULL)while(Np != NULL){
  if((Op=Np->fobj) != NULL)while(Op != NULL){
    if(id == Op->fileID)idcount++;
    Op=Op->next;
  }
  Np=Np->next;
 }
 op->nskeleton=0;
 if(op->skeleton != NULL)X__Free(op->skeleton);
 op->skeleton=NULL;
 if(idcount > 1)return; /* if this is needed by another actor */
 if(op->points != NULL){X__Free(op->points); op->points = NULL;}
 if(op->edges != NULL){X__Free(op->edges); op->edges = NULL;}
 op->npoints=0;    op->nedges=0;
 if(op->skid != NULL){X__Free(op->skid); op->skid=NULL;}
 if(op->w_frame.e != NULL){X__Free(op->w_frame.e); op->w_frame.e = NULL;}
 if(op->w_frame.p != NULL){X__Free(op->w_frame.p); op->w_frame.p = NULL;}
 op->w_frame.Ne=0; op->w_frame.Np=0;
 op->in_ram=0;
 op->bIKchain=FALSE;
 if(op->Nurbs != NULL){
   FreeNurbs(op->nNurbs,op->Nurbs);
   op->nNurbs=0; op->Nurbs=NULL;
 }
 sprintf(RAMfilename,"%s%d.$$$",TempPath,id);
// if(remove(RAMfilename) != 0){
//; /*   Failed to delete Work file */
// }
}

object *ObjectExists(char *FileName, object *Oop, long *fileID){
 node   *Np;
 object *Op;
 long i;
 /* first check if this is in the discarded list - if it is and the new
    entry exists then return that */
  if(n_discarded > 0 && discarded_file_list != NULL){
    for(i=0;i<n_discarded;i++){
      if(discarded_file_list[i].old != NULL &&
         discarded_file_list[i].new != NULL &&
         discarded_file_list[i].Op  != NULL){
        if(strcmp(FileName,discarded_file_list[i].old) == 0){
          Op=discarded_file_list[i].Op;
          *fileID=Op->fileID;
          strcpy(FileName,discarded_file_list[i].new);
          return Op;
        }
      }
    }
  }
 /* now check all the other actors + costumes to see it this one is in
    use */
 if((Np=FirstNp) != NULL)while(Np != NULL){
  if((Op=Np->fobj) != NULL)while(Op != NULL){
    if(strcmp(FileName,Op->name) == 0 && Op != Oop){
      *fileID = Op->fileID;
      return Op;
    }
    Op=Op->next;
  }
  Np=Np->next;
 }
 return NULL;
}


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

unsigned char getlon_s(long * val, FILE *f){
 *val  = ((long)getc(f))<<24;
 *val |= ((long)getc(f))<<16;
 *val |= ((long)getc(f))<<8;
 *val |= ((long)getc(f));
 return(1);
}

static unsigned char getush_s(FILE *f, long * val){
 *val  = ((long)getc(f))<<8;
 *val |= ((long)getc(f));
 return(1);
}

unsigned char getsht_s(FILE *f, short * val){
 *val  = ((short)getc(f))<<8;
 *val |= ((short)getc(f));
 return(1);
}

// load the OFX file

unsigned char getlon_H(HANDLE f, long * val){
 DWORD dwRead;
 long l,l0,l1,l2,l3;
 ReadFile(f,&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 getush_H(HANDLE f, long * val){
 DWORD dwRead;
 unsigned short s,s0,s1;
 ReadFile(f,&s,sizeof(short),&dwRead,NULL);
 s0 = (s >>  8) & 0x00ff;
 s1 = (s      ) & 0x00ff;
 *val = (s1 <<  8) | s0;
 return(1);
}

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

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 getchunk_H(long clen, HANDLE f){
 SetFilePointer(f,clen,NULL,FILE_CURRENT);
}

static void getchunk_F(long clen, FILE *f){
 fseek(f,clen,SEEK_CUR); 
}

static void StageReadSkeleton(long clen, object *Op, short version,HANDLE fp){
 unsigned char *buffer=NULL,*b;
 DWORD dwRead;
 short loadit=1;
 long s;
 long n,i,j,k,l,l0,l1,l2,*jj;
 char name[32]={"None"};
 skel *sp;
 buffer=(unsigned char *)X__Malloc(clen);
 if(buffer == NULL)return;  b=buffer;
 if(!ReadFile(fp,buffer,clen,&dwRead,NULL) || dwRead != clen){
   X__Free(buffer);
   return;
 }
 n=(long)GetLongFromBuffer(b); b+= 4;
 if((Op->skeleton=(skel *)X__Malloc(n*(long)sizeof(skel))) == NULL)loadit=0;
 else Op->nskeleton=n;
 sp=Op->skeleton;
 for(i=0;i<n;i++){
  l0=(long)GetLongFromBuffer(b); b+= 4;
  l1=(long)GetLongFromBuffer(b); b+= 4;
  l2=(long)GetLongFromBuffer(b); b+= 4;
  if(version < 3){s=(long)GetShortFromBuffer(b); b+= 2;}
  else           {s=(long)GetLongFromBuffer(b); b+= 4;}
  if(version > 0){
    memcpy(name,b,16); b+= 16;
    if(version > 3){
      l=(long)GetLongFromBuffer(b); b+= 4;
      sp->weight=(double)l/1000.0;
      l=(long)GetLongFromBuffer(b); b+= 4;
      sp->wrange=(double)l/1000.0;
      l=(long)GetLongFromBuffer(b); b+= 4;
      sp->wzone=(double)l/1000.0;
    }
    else sp->weight=1.0;
  }
  strcpy(sp->name,name);
  if(version > 1){
    for(j=0;j<3;j++){
      l=(long)GetLongFromBuffer(b); b+= 4;
      sp->u[j] = ((double)l)*1.0e-8;
    }
    for(j=0;j<3;j++){
      l=(long)GetLongFromBuffer(b); b+= 4;
      sp->v[j] = ((double)l)*1.0e-8;
    }
    for(j=0;j<3;j++){
      l=(long)GetLongFromBuffer(b); b+= 4;
      sp->w[j] = ((double)l)*1.0e-8;
    }
    for(j=0;j<8;j++)for(k=0;k<3;k++){
      sp->bx[j][k]=(long)GetLongFromBuffer(b); b+= 4;
      sp->bx[j][k] -= Op->origin[k];
    }
  }
  if(loadit){
    sp->id=s;
    sp->pp[0]=sp->p[0] = l0 - Op->origin[0];
    sp->pp[1]=sp->p[1] = l1 - Op->origin[1];
    sp->pp[2]=sp->p[2] = l2 - Op->origin[2];
    for(j=0;j<3;j++){
      sp->pt[j]=0;
      sp->uu[j]=sp->u[j];
      sp->vv[j]=sp->v[j];
      sp->ww[j]=sp->w[j];
    }
    null_transform(sp->R);
    null_transform(sp->Q);
    null_transform(sp->T);
    sp->IKlock=FALSE;
    sp->uIKlock=FALSE;
    sp->vIKlock=FALSE;
    sp->wIKlock=FALSE;
    sp->uIKmin=0.0; sp->vIKmin=0.0; sp->wIKmin=0.0;
    sp->uIKmax=360.0; sp->vIKmax=360.0; sp->wIKmax=360.0;
    sp++;
  }
 }
 n=(long)GetLongFromBuffer(b); b+= 4;
 if(n > 0){
   if(loadit){
     if((Op->skid=(long *)X__Malloc(n*(long)sizeof(long))) == NULL){
       loadit=0;
       X__Free(Op->skeleton); Op->skeleton=NULL; Op->nskeleton=0;
     }
     else jj=Op->skid;
   }
   for(i=0;i<n;i++){
     if(version < 3){s=(long)GetShortFromBuffer(b); b+= 2;}
     else           {s=(long)GetLongFromBuffer(b); b+= 4;}
     if(loadit)*jj++ = (long)s;
   }
 }
 X__Free(buffer);
 return;
}

static void StageReadWireframe(long clen, object *Op, HANDLE fp){
 long i,np,ne,readit=1,size,x,y;
 point p;
 getlon_H(fp,&np);
 getlon_H(fp,&ne);
 size=np*(long)sizeof(point);
 if((Op->w_frame.p = (point *)X__Malloc(size)) == NULL)readit=0;
 size=ne*(long)sizeof(Sedge);
 if((Op->w_frame.e = (Sedge *)X__Malloc(size)) == NULL){
   readit=0;
   if(Op->w_frame.p != NULL){X__Free(Op->w_frame.p); Op->w_frame.p=NULL;}
 }
 for(i=0;i<np;i++){
   getlon_H(fp,&p[0]); getlon_H(fp,&p[1]); getlon_H(fp,&p[2]);
   p[0] -= Op->origin[0];
   p[1] -= Op->origin[1];
   p[2] -= Op->origin[2];
   if(readit)CopyPoint(p,Op->w_frame.p[i]);
 }
 for(i=0;i<ne;i++){
   getlon_H(fp,&x); getlon_H(fp,&y);
   if(readit){Op->w_frame.e[i][0]=x; Op->w_frame.e[i][1]=y;}
 }
 if(readit){
   Op->w_frame.Np=np; Op->w_frame.Ne=ne;
 }
}

static void StageReadNurbs(long clen, object *Op, HANDLE fp){
 DWORD dwRead;
 BOOL readit=TRUE;
 long i,j,k,N;
 nurbs *n,*Np;
 vector4 *p;
 double w;
 ReadFile(fp,&N,sizeof(long),&dwRead,NULL);
 if(N == 0)return;
 newnurbs=N;
 if((Np=(nurbs *)X__Malloc(N*sizeof(nurbs))) == NULL)return;
 for(k=0;k<N;k++){
   n=(Np+k);
   ReadFile(fp,&(n->properties),sizeof(NurbsProperties),&dwRead,NULL);
   ReadFile(fp,&(n->numU),sizeof(long),&dwRead,NULL);
   ReadFile(fp,&(n->numV),sizeof(long),&dwRead,NULL);
   ReadFile(fp,&(n->orderU),sizeof(long),&dwRead,NULL);
   ReadFile(fp,&(n->orderV),sizeof(long),&dwRead,NULL);
   AllocNurbs(n,NULL,NULL);
   for(i=0;i<n->numU + n->orderU; i++)
     ReadFile(fp,&(n->kvU[i]),sizeof(double),&dwRead,NULL);
   for(i=0;i<n->numV + n->orderV; i++)
     ReadFile(fp,&(n->kvV[i]),sizeof(double),&dwRead,NULL);
   for(i=0;i<n->numV; i++)
   for(j=0;j<n->numU; j++){
     p=&(n->points[i][j]);
     ReadFile(fp,p,sizeof(vector4),&dwRead,NULL);
     w=p->w;
     p->x=(p->x)/w;
     p->y=(p->y)/w;
     p->z=(p->z)/w;
     minX=min(p->x,minX);     maxX=max(p->x,maxX);
     minY=min(p->y,minY);     maxY=max(p->y,maxY);
     minZ=min(p->z,minZ);     maxZ=max(p->z,maxZ);
     p->x = (p->x - (long)Op->origin[0])*w;
     p->y = (p->y - (long)Op->origin[1])*w;
     p->z = (p->z - (long)Op->origin[2])*w;
   }
 }
 if(readit){
   Op->nNurbs=N;
   Op->Nurbs=Np;
 }
 return;
}

static void StageReadAxis(long clen, object *Op,HANDLE fp){
 long i,notrequired;
 getlon_H(fp,&Op->origin[0]);
 getlon_H(fp,&Op->origin[1]);
 getlon_H(fp,&Op->origin[2]);
 for(i=0;i<9;i++)getlon_H(fp,&notrequired);
}

static short StageReadEdges(long clen, object *Op, BOOL short_form, HANDLE fp){
  DWORD dwRead;
  long i,size;
  unsigned char *buffer=NULL,*b;
  if(short_form)newedge=clen/4;
  else          newedge=clen/8;
  size=newedge*(long)sizeof(Sedge);
  if(Op->in_ram){
    if(size > 0){
      if((Op->edges = (Sedge *)X__Malloc(size)) == NULL)return FAIL;
    }
    else Op->edges=NULL;
    Op->nedges=newedge;
  }
  if(newedge == 0)return OK;
  buffer=(unsigned char *)X__Malloc(clen);
  if(buffer == NULL)return FAIL;  b=buffer;
  if(!ReadFile(fp,buffer,clen,&dwRead,NULL) || dwRead != clen){
    X__Free(buffer);
    return FAIL;
  }
  for(i=0;i<newedge;i++){
    if(short_form){
      Op->edges[i][0]=(long)GetUshortFromBuffer(b); b+= 2;
      Op->edges[i][1]=(long)GetUshortFromBuffer(b); b+= 2;
    }
    else {
      Op->edges[i][0]=(long)GetLongFromBuffer(b); b+= 4;
      Op->edges[i][1]=(long)GetLongFromBuffer(b); b+= 4;
    }
  }
  X__Free(buffer);
  return OK;
}

static void StageReadVertices(long clen, object *Op, HANDLE fp){
  DWORD dwRead;
  unsigned char *buffer=NULL,*b;
  char c;
  long i,szz,xyz[3],size;
  newvert=clen/12;
  size=newvert*(long)sizeof(point);
  if(Op->in_ram){
    if((Op->points = (point *)X__Malloc(size)) == NULL)Op->in_ram=0;
    else Op->npoints=newvert;
  }
  if(newvert == 0)return;
  buffer=(unsigned char *)X__Malloc(clen);
  if(buffer == NULL)return;  b=buffer;
  if(!ReadFile(fp,buffer,clen,&dwRead,NULL) || dwRead != clen){
    X__Free(buffer);
    return;
  }
  for(i=0;i<newvert;i++){
     xyz[0]=(long)GetLongFromBuffer(b); b+= 4;
     xyz[1]=(long)GetLongFromBuffer(b); b+= 4;
     xyz[2]=(long)GetLongFromBuffer(b); b+= 4;
     minX=min(xyz[0],minX);     maxX=max(xyz[0],maxX);
     minY=min(xyz[1],minY);     maxY=max(xyz[1],maxY);
     minZ=min(xyz[2],minZ);     maxZ=max(xyz[2],maxZ);
     if(Op->in_ram)CopyPoint(xyz,Op->points[i]);
  }
  X__Free(buffer);
  return;
}

static HANDLE SearchForFile(char *input, char *output){
 HANDLE fp;
 char *fs;
 long l;
 char pref[32];
 char replace[1024],path[1024];
 // first try to see if the model is on the same drive as OFX
 strcpy(output,input);
//MessageBox(NULL,output,"Replace file",NULL);
 output[0]=gszHomeDir[0]; // get drive from root
 fp=CreateFile(output,GENERIC_READ,
                 FILE_SHARE_READ,NULL,OPEN_EXISTING,
                 FILE_ATTRIBUTE_READONLY,(HANDLE)NULL);
 if(fp != INVALID_HANDLE_VALUE)return fp;
 // Now check the preferences paths 
 fs=short_form(input);
 // try to see if in same path as animation file
 strcpy(replace,gszSTGfile);
 if(FileInPath(replace) != NULL) *FileInPath(replace)='\0';
 strcat(replace,fs);
//#if 0
//MessageBox(NULL,replace,"Trying In same directory as animation file",NULL);
 fp=CreateFile(replace,GENERIC_READ,
               FILE_SHARE_READ,NULL,OPEN_EXISTING,
               FILE_ATTRIBUTE_READONLY,(HANDLE)NULL);
 if(fp != INVALID_HANDLE_VALUE){
  strcpy(output,replace);
  return fp;
 }
//#endif
 for(l=1;l<=128;l++){ 
   sprintf(pref,"MODEL-PATH%ld",l);
   GetPrivateProfileString(IniRenderSection,pref,"$$$",
                           output,255,IniFilename);
   if(strncmp(output,"$$$",3) == 0)break;   // no more info in INI file
   if(output[1] != ':')continue;            // try next one (invalid entry)
   if(output[strlen(output)-1] != '\\')strcat(output,"\\");
   strcat(output,fs);
//MessageBox(NULL,output,"Trying preference path with",NULL);
   fp=CreateFile(output,GENERIC_READ,
                 FILE_SHARE_READ,NULL,OPEN_EXISTING,
                 FILE_ATTRIBUTE_READONLY,(HANDLE)NULL);
   if(fp != INVALID_HANDLE_VALUE)return fp;
 }
 // now try to see if derived from "openfx" folder in different location
 strlwr(input); 
 if((fs=strstr(input,"openfx\\")) != NULL){
   fs+=7;
   strcpy(output,gszHomeDir); strcat(output,fs);
//MessageBox(NULL,output,"Trying new root for model",NULL);
   fp=CreateFile(output,GENERIC_READ,
                 FILE_SHARE_READ,NULL,OPEN_EXISTING,
                 FILE_ATTRIBUTE_READONLY,(HANDLE)NULL);
   if(fp != INVALID_HANDLE_VALUE)return fp;
 }
 // try putting whole path in OpenFX folder
 if(input[2] == '\\'){
   strcpy(output,gszHomeDir); strcat(output,(input+3));
//MessageBox(NULL,output,"Trying whole path in OFX home folder",NULL);
   fp=CreateFile(output,GENERIC_READ,
                 FILE_SHARE_READ,NULL,OPEN_EXISTING,
                 FILE_ATTRIBUTE_READONLY,(HANDLE)NULL);
   if(fp != INVALID_HANDLE_VALUE)return fp;
 }
 // else replace one of a number of partial paths with a default partial path
 GetPrivateProfileString(IniRenderSection,"MODEL-ROOT","$$$",
                         path,512,IniFilename);
 if(strncmp(path,"$$$",3) != 0){
   if(path[strlen(path)-1] != '\\')strcat(path,"\\");
   strlwr(path);
   for(l=1;l<=128;l++){ 
     sprintf(pref,"MODEL-ROOT%ld",l);
     GetPrivateProfileString(IniRenderSection,pref,"$$$",
                             replace,255,IniFilename);
     if(strncmp(replace,"$$$",3) == 0)break;   // no info in INI file
     if(replace[1] != ':')continue;            // try next one (invalid entry)
     if(replace[strlen(replace)-1] != '\\')strcat(replace,"\\");
     strlwr(replace);
//MessageBox(NULL,replace,"looking for",NULL);
//MessageBox(NULL,input,"in",NULL);
     if((fs=strstr(input,replace)) != NULL){   // found string
       fs += strlen(replace);
       strcpy(output,path);
       strcat(output,fs);
//MessageBox(NULL,output,"Trying substitute path",NULL);
       fp=CreateFile(output,GENERIC_READ,
                   FILE_SHARE_READ,NULL,OPEN_EXISTING,
                   FILE_ATTRIBUTE_READONLY,(HANDLE)NULL);
       if(fp != INVALID_HANDLE_VALUE)return fp;
     }
   }   
 }
 return INVALID_HANDLE_VALUE;
}

short LoadMeshObject(char *FileName, object *Op, short report,
                      short check, short robot){
 DWORD dwRead;
 HANDLE fp;
 object *Lop;
 long CHUNKsize,FORMsize,i,j,OldfileID,notrequired;
 short status=1;
 skel *sp;
 Op->in_ram = 1;  /* don't support disk base any more */
 maxX = maxY = maxZ = -MAXUNIT;
 minX = minY = minZ =  MAXUNIT;
 Op->origin[0]=0; Op->origin[1]=0; Op->origin[2]=0;
 Op->offset[0]=0; Op->offset[1]=0; Op->offset[2]=0;
 Op->w_frame.Np=Op->w_frame.Ne=0;
 Op->w_frame.e=NULL; Op->w_frame.p=NULL;
 Op->skid=NULL;
 Op->npoints=0; Op->nedges=0;
 Op->nskeleton=0;
 Op->nNurbs=0; Op->Nurbs=NULL;
 Op->bIKchain=FALSE;
 InitialiseRamImage(&(Op->image));
 if((check == 0) || ((Lop=ObjectExists(FileName,Op,&OldfileID)) == NULL)){
   sprintf(RAMfilename,"%s%d.$$$",TempPath,fileID);
   Op->fileID=fileID;
   fileID++;
 }
 else{
   for(j=0;j<3;j++){
     Op->origin[j] = Lop->origin[j];
     Op->offset[j] = Lop->offset[j];
     for(i=0;i<8;i++){
       Op->outline[i][j]  = Lop->outline[i][j];
     }
   }
   Op->npoints   = Lop->npoints;
   Op->nedges    = Lop->nedges;
   Op->points    = Lop->points;
   Op->edges     = Lop->edges;
   Op->nNurbs    = Lop->nNurbs;
   Op->Nurbs     = Lop->Nurbs;
   Op->w_frame.Np= Lop->w_frame.Np;
   Op->w_frame.Ne= Lop->w_frame.Ne;
   Op->w_frame.e = Lop->w_frame.e;
   Op->w_frame.p = Lop->w_frame.p;
   /* make copy of the skeleton */
   Op->in_ram    = Lop->in_ram;
   Op->fileID=OldfileID;
   if(Lop->nskeleton > 0){
     j=(long)(Lop->nskeleton)*(long)sizeof(skel);
     if((Op->skeleton=(skel *)X__Malloc(j)) != NULL){
       Op->nskeleton = Lop->nskeleton;
       memcpy(Op->skeleton,Lop->skeleton,j);
       sp=Op->skeleton;               /* Copy will be same as */
       for(j=0;j<Op->nskeleton;j++){  /* original             */
         null_transform(sp->R);
         null_transform(sp->Q);
         null_transform(sp->T);
         sp++;
       }
     }
     else{
       Op->nskeleton=0;
     }
   }
   else Op->nskeleton=0;
   Op->skid      = Lop->skid;
   return OK;
 }
 fp=CreateFile(FileName,GENERIC_READ,
               FILE_SHARE_READ,NULL,OPEN_EXISTING,
               FILE_ATTRIBUTE_READONLY,(HANDLE)NULL);
 if(fp == INVALID_HANDLE_VALUE){
   if((fp=SearchForFile(FileName,RAMfilename)) != INVALID_HANDLE_VALUE)goto UPDATED;
   DeleteRamFile(Op->fileID,Op);
   if(report){
     SendPrgmQuery(IDQ_FILEOPENFAIL,0);
   }
   return FAIL;
   UPDATED:
//MessageBox(NULL,RAMfilename,FileName,MB_OK);
   strcpy(FileName,RAMfilename);
   // and relpace the object name with the one found
   strcpy(Op->name,RAMfilename);
 }
 newedge=0; newvert=0; newnurbs=0;
 fail_op=NO;
 ReadFile(fp,str,4,&dwRead,NULL);
 if (dwRead != 4 || strcmp(str,"FORM") != 0){
   goto FAILURE1;
 }
 if(!ReadFile(fp,&FORMsize,sizeof(long),&dwRead,NULL))goto end;
 if(!ReadFile(fp,str,4,&dwRead,NULL))goto FAILURE1;
 if (dwRead != 4 || (strcmp(str,"OFXM") != 0 && strcmp(str,"AAPO") != 0)){
   goto FAILURE1;
 }
loop:
 if(!ReadFile(fp,str,4,&dwRead,NULL))goto end;
 if(dwRead != 4)goto end;
 if (getlon_H(fp,&CHUNKsize) != 1) goto end;
 if     (strcmp(str,"VERT") == 0)StageReadVertices(CHUNKsize,Op,fp);
 else if(strcmp(str,"EDGE") == 0 ||
         strcmp(str,"edge") == 0){
  BOOL short_form;
  if(strcmp(str,"edge") == 0)short_form=TRUE; else short_form=FALSE;
  if(StageReadEdges(CHUNKsize,Op,short_form,fp) == FAIL){
    if(Op->in_ram){ /* try to load again to back up device */
      X__Free(Op->points);
      Op->npoints=0;
      fail_op=YES;  goto FAILURE2;
    }
  }
 }
 else if(strcmp(str,"AXIS") == 0)StageReadAxis(CHUNKsize,Op,fp);
 else if(strcmp(str,"OFFS") == 0){
   getlon_H(fp,&notrequired);    /* is 3 for 3 long integers to follow */
   getlon_H(fp,&Op->offset[0]);
   getlon_H(fp,&Op->offset[1]);
   getlon_H(fp,&Op->offset[2]);
 }
 else if((strcmp(str,"SK04")) == 0 && robot == YES){
   StageReadSkeleton(CHUNKsize,Op,4,fp);
 }
 else if((strcmp(str,"SK03")) == 0 && robot == YES){
   StageReadSkeleton(CHUNKsize,Op,3,fp);
 }
 else if((strcmp(str,"SK02")) == 0 && robot == YES){
   StageReadSkeleton(CHUNKsize,Op,2,fp);
 }
 else if((strcmp(str,"SK01")) == 0 && robot == YES){
   StageReadSkeleton(CHUNKsize,Op,1,fp);
 }
 else if((strcmp(str,"SKEL")) == 0 && robot == YES){
   StageReadSkeleton(CHUNKsize,Op,0,fp);
 }
 else if((strcmp(str,"WFRM")) == 0)StageReadWireframe(CHUNKsize,Op,fp);
 else if((strcmp(str,"NURB")) == 0)StageReadNurbs(CHUNKsize,Op,fp);
 else getchunk_H(CHUNKsize,fp);
 if(fail_op == YES)goto FAILURE2;
 goto loop;
end:
 CloseHandle(fp);
 if(newvert == 0 && newnurbs == 0)return FAIL;  /* no object in file */
 Op->outline[0][0]=minX; Op->outline[0][1]=minY; Op->outline[0][2]=maxZ;
 Op->outline[1][0]=maxX; Op->outline[1][1]=minY; Op->outline[1][2]=maxZ;
 Op->outline[2][0]=maxX; Op->outline[2][1]=maxY; Op->outline[2][2]=maxZ;
 Op->outline[3][0]=minX; Op->outline[3][1]=maxY; Op->outline[3][2]=maxZ;
 Op->outline[4][0]=minX; Op->outline[4][1]=minY; Op->outline[4][2]=minZ;
 Op->outline[5][0]=maxX; Op->outline[5][1]=minY; Op->outline[5][2]=minZ;
 Op->outline[6][0]=maxX; Op->outline[6][1]=maxY; Op->outline[6][2]=minZ;
 Op->outline[7][0]=minX; Op->outline[7][1]=maxY; Op->outline[7][2]=minZ;
 for(i=0;i<8;i++){
   Op->outline[i][0] -= Op->origin[0];
   Op->outline[i][1] -= Op->origin[1];
   Op->outline[i][2] -= Op->origin[2];
 }
 Op->offset[0] -= Op->origin[0];
 Op->offset[1] -= Op->origin[1];
 Op->offset[2] -= Op->origin[2];
 return fileID;
FAILURE1:
 CloseHandle(fp);
 SendPrgmQuery(IDQ_NOTAMODEL,0);
 return FAIL;
FAILURE2:
 CloseHandle(fp);
 SendPrgmQuery(IDQ_TFWE,0);
 fail_op=NO;
 return FAIL;
}


short LoadAnimationFile(char *filename, BOOL bUnpack){  // max version = 6
 unsigned char zeroname[16];
 BOOL          skip;
 node          *Np,**NNp;
 object        *Op;
 sky           *Sp;
 director      *Dp;
 position      *Pp;
 align         *Ap;
 size          *Xp;
 pathpoint     *Ppp;
 point         TVC,TVP,TVclipMax,TVclipMin;
 short         Zero,Error,Nobj,Nsky,Npos,Ndirector,Nali,Nsiz,tt
              ,firstframe,lastframe,N,Nf
              ,failed_to_find
              ,failed_to_load
              ,robot;
 long          i,j,k,kk,Minus1,dummylong,head_chunks,version=0,
               chunk_size;
 double        dummydouble,x,y,z;
 point         Outline[8];
 Zero=0; Error=0; Minus1 = -1; failed_to_find=0;
 n_discarded=0; discarded_file_list=NULL;

 if(filename != NULL){
  if((fr=fopen(filename,"rb")) != NULL){
    ScrapEverything();    /* get rid of everything */
    UpdateSelectedActor(FALSE);
    NEXTSEGMENT:
    if(fread(str,1,4,fr) != 4){Error=1; goto NOLOAD;}
    if(strcmp(str,"OFXA") == 0  || strcmp(str,"ANIH") == 0){
      getlon_s(&head_chunks,fr);
      getlon_s(&i,fr);   ruler = (double)i;
      if(fread(ruler_name,1,8,fr) != 8){Error=1; goto NOLOAD;}
      getlon_s(&lrulerx,fr); getlon_s(&lrulery,fr);   getlon_s(&lrulerz,fr);
      rulerx = lrulerx; rulery = lrulery; rulerz = lrulerz;
      getlon_s(&i,fr);       getlon_s(&i,fr);         getlon_s(&i,fr);
      getlon_s(&grid_size,fr);
      if(head_chunks > 1){
        getlon_s(&version,fr);
      }
      goto NEXTSEGMENT;
    }
    if(strcmp(str,"XIMP") == 0){
      getlon_s(&head_chunks,fr);
      for(i=0;i<head_chunks;i++){
        skip=FALSE;
        if(CreateImageProcess(NULL) == NULL)skip=TRUE;
        getlon_s(&kk,fr);
        if(!skip){
          MainIp->p=(char *)X__Malloc(kk+1);
          if(MainIp->p == NULL)skip=TRUE;
          if(!skip)memset(MainIp->p,0,kk+1);
          if(!skip)fread(MainIp->p,1,kk,fr);
          else for(j=0;j<kk;j++)fread(&dummylong,1,1,fr);
        }
      }
      goto NEXTSEGMENT;
    }
    if(strcmp(str,"STAG") == 0){
      fread(&Nf,sizeof(long),1,fr);
      fread(&N,sizeof(short),1,fr);
      NNp=(node **)X__Malloc(N*sizeof(node *));
      if(NNp == NULL){Error=1; goto NOLOAD;}
      /* this used to be the location of scrap-everything moved XIMP !! */
      Nframes=Nf;
      fread(&Nground,sizeof(short),1,fr);
      for(i=0;i<N;i++){
        Np=CreateNode();
        NNp[i]=Np;
        fread(zeroname,1,16,fr);
        if(zeroname[0] == 255 && zeroname[1] == 254 &&
           zeroname[2] == 253 && zeroname[3] == 252 &&
           zeroname[4] == 255 && zeroname[5] == 254 &&
           zeroname[6] == 253 && zeroname[7] == 252){
          fread(Np->actorname,1,128,fr);
        }
        else{
          strcpy(Np->actorname,(char *)zeroname);
        }
        fread(&(Np->type),sizeof(short),1,fr);
        if(version > 0){
          fread(&(Np->ID),sizeof(short),1,fr);
          if(Np->ID >= MaxNodeID)MaxNodeID=Np->ID + 1;
        }
        if(Np->type == ROBOT)Nrobots++;
        if(Np->type == SKY)Nskys=1;
        if(Np->type == DIRECTOR)Ndirectors=1;
        else if(Np->type == CAMERA){
          Ncameras++;
          if(Ncameras == 1)SelectedCamera=Np;
          else if(Ncameras > 1){  /* additional camera has flag => in use */
            fread(&tt,1,sizeof(short),fr);
            if(tt)SelectedCamera=Np;
          }
        }
      }
      for(i=0,Np=FirstNp;i<Nnodes;i++){
        fread(&(Np->type),sizeof(short),1,fr);
        fread(zeroname,1,16,fr);
        if(zeroname[0] == 255 && zeroname[1] == 254 &&
           zeroname[2] == 253 && zeroname[3] == 252 &&
           zeroname[4] == 255 && zeroname[5] == 254 &&
           zeroname[6] == 253 && zeroname[7] == 252){
          fread(Np->actorname,1,128,fr);
        }
        else{
          strcpy(Np->actorname,(char *)zeroname);
        }
        fread(&Nsky,sizeof(short),1,fr);
        if(Nsky > 0){
          for(j=0;j<Nsky;j++){
            fread(&firstframe,sizeof(short),1,fr);
            fread(&lastframe,sizeof(short),1,fr);
            Sp=CreateSky(Np,firstframe,lastframe);
            fread(Sp->colour,1,3,fr);
            fread(Sp->zcolour,1,3,fr);
            fread(&Sp->type,sizeof(short),1,fr);
            if(Sp->type > 7){ /* ambient is specified         */
              Sp->type -= 8;   /* extract the type identifier */
              fread(&Sp->gamb,sizeof(double),1,fr);
              fread(&Sp->oamb,sizeof(double),1,fr);
              fread(Sp->gamb_colour,sizeof(double),3,fr);
              fread(Sp->oamb_colour,sizeof(double),3,fr);
            }
            fread(Sp->name,1,128,fr);
            if(Sp->type == SKYANIMATED){
              fread(&Sp->aff,sizeof(long),1,fr);
              fread(&Sp->alf,sizeof(long),1,fr);
              fread(&Sp->ast,sizeof(long),1,fr);
            }
            if(version > 4){
              fread(&Sp->sky_params,32*sizeof(double),1,fr);
              fread(&Sp->sky_params_file,256,1,fr); 
            }
          }
        }
        if(Np->type == DIRECTOR){
          fread(&Ndirector,sizeof(short),1,fr);
          if(Ndirector > 0)for(j=0;j<Ndirector;j++){
            fread(&firstframe,sizeof(short),1,fr);
            fread(&lastframe,sizeof(short),1,fr);
            Dp=CreateDirector(Np,firstframe,lastframe);
            fread(&Dp->type,sizeof(long),1,fr);
            fread(&k,sizeof(long),1,fr);
            if(k >= 0)Dp->ActiveCamera=NNp[k];
          }
        }
        fread(&Npos,sizeof(short),1,fr);
        if(Npos > 0){
          for(j=0;j<Npos;j++){
            fread(&firstframe,sizeof(short),1,fr);
            fread(&lastframe,sizeof(short),1,fr);
            Pp=CreatePosition(Np,firstframe,lastframe);
            fread(&(Pp->type),sizeof(short),1,fr);
            if(Pp->type == FOLLOWAT){
              fread(&(Pp->fx),sizeof(short),1,fr);
              fread(&(Pp->fy),sizeof(short),1,fr);
              fread(&(Pp->fz),sizeof(short),1,fr);
            }
            fread(Pp->finish,sizeof(point),1,fr);
            fread(&k,sizeof(long),1,fr);
            if(k >= 0)Pp->onpath=NNp[k];
            fread(zeroname,1,16,fr);
            if(zeroname[0] == 255 && zeroname[1] == 254 &&
               zeroname[2] == 253 && zeroname[3] == 252 &&
               zeroname[4] == 255 && zeroname[5] == 254 &&
               zeroname[6] == 253 && zeroname[7] == 252){
              fread(Pp->pnodename,1,128,fr);
            }
            else{
              strcpy(Pp->pnodename,(char *)zeroname);
            }
          }
        }
        fread(&Nali,sizeof(short),1,fr);
        if(Nali > 0){
          for(j=0;j<Nali;j++){
            fread(&firstframe,sizeof(short),1,fr);
            fread(&lastframe,sizeof(short),1,fr);
            Ap=CreateAlign(Np,firstframe,lastframe);
            fread(&(Ap->type),sizeof(short),1,fr);
            if(Ap->type > 7){  /* if internal motion present read it in */
              Ap->type = (Ap->type & 0x0007);
              fread(&(Ap->im),sizeof(short),1,fr);
              fread(&(Ap->ima),sizeof(double),1,fr);
            }
            else{Ap->im=0; Ap->ima=0.0;} /* no internal motion */
            fread(&(Ap->theta),sizeof(double),1,fr);
            fread(&(Ap->phi),sizeof(double),1,fr);
            fread(&(Ap->alpha),sizeof(double),1,fr);
            fread(&k,sizeof(long),1,fr);
            if(k >= 0)Ap->topath=NNp[k];
            fread(zeroname,1,16,fr);
            if(zeroname[0] == 255 && zeroname[1] == 254 &&
               zeroname[2] == 253 && zeroname[3] == 252 &&
               zeroname[4] == 255 && zeroname[5] == 254 &&
               zeroname[6] == 253 && zeroname[7] == 252){
              fread(Ap->anodename,1,128,fr);
            }
            else{
              strcpy(Ap->anodename,(char *)zeroname);
            }
          }
        }
        fread(&Nsiz,sizeof(short),1,fr);
        if(Nsiz > 0){
          for(j=0;j<Nsiz;j++){
            fread(&firstframe,sizeof(short),1,fr);
            fread(&lastframe,sizeof(short),1,fr);
            Xp=CreateSize(Np,firstframe,lastframe);
            fread(&(Xp->Sx),sizeof(double),1,fr);
            fread(&(Xp->Sy),sizeof(double),1,fr);
            fread(&(Xp->Sz),sizeof(double),1,fr);
            if(version > 4){
              fread(&(Xp->camera_params),20*sizeof(double),1,fr);
            }
          }
        }
        fread(&Nobj,sizeof(short),1,fr);
        if(Nobj > 0){
          for(j=0;j<Nobj;j++){
            if((fread(&firstframe,sizeof(short),1,fr)) != 1)goto FAILED;
            if((fread(&lastframe,sizeof(short),1,fr)) != 1)goto FAILED;
            Op=CreateCostume(Np,firstframe,lastframe);
            if(Op == NULL)goto FAILED;
            fread(Op->name,1,128,fr);   // RSFX  need to make longer
            if((fread(&(Op->type),sizeof(short),1,fr)) != 1)goto FAILED;
            if(Op->type == IMAGEP){
              if(fread(&tt,sizeof(short),1,fr) != 1)goto FAILED;
              if(tt > 0){
                if(fread(&tt,sizeof(short),1,fr) != 1)goto FAILED;
                if(tt > 0){
                  Op->xip=(char *)X__Malloc(tt+1);
                  if(Op->xip == NULL)goto FAILED;
                  memset(Op->xip,0,tt+1);
                  fread(Op->xip,1,tt,fr);
                }
              }
            }
            fread(&(Op->morph),sizeof(short),1,fr);
            tt = Op->morph >> 4;  /* high bits of morph flag for effect*/
            Op->morph &= 0x000f;  /* must be 0 or 1 or 2 or 3*/
            if(tt == 127){ /* read the rest of the effects structure */
              fread(&tt,sizeof(short),1,fr);
              Op->effect=(char *)X__Malloc(tt+1);
              memset(Op->effect,0,tt+1);
              fread(Op->effect,1,tt,fr);
            }
            else Op->effect=NULL;
            if(Op->effect != NULL){
              char effectname[255];
              sscanf(Op->effect,"%s",effectname);
              if(strlen(effectname) == 1){
                int idd;
                idd=atoi(effectname);
                sprintf(effectname,"%seffects\\%s",gszHomeDir,
                         internal_effect_list[idd-1]);
              }
              LoadEffectLibrary(effectname,Op); /* hidden white spaces */
            }
            fread(&(Op->morphNo),sizeof(short),1,fr); Op->morphNo=0; /* NB temp */
            fread(&(Op->fileID),sizeof(short),1,fr);
            if((fread(Op->origin,sizeof(point),1,fr)) != 1)goto FAILED;
            if((fread(Outline,sizeof(point),8,fr)) != 8)goto FAILED;
            if(Op->type == PARTICLE){ 
              for(k=0;k<8;k++)CopyPoint(Outline[k],Op->outline[k]);
            }
            Op->offset[0]=Op->origin[0]; /* will be set in LoadObject */
            Op->offset[1]=Op->origin[1]; /* as will Op->origin and outline */
            Op->offset[2]=Op->origin[2];
            failed_to_load=NO;  
            if(Op->type == ROBOT)robot=YES; 
            else                 robot=NO;
            TRYAGAINLOAD:
            if(Op->fileID >= 0){
              if(bUnpack)UnpackName(Op->name);
              if(LoadMeshObject(Op->name,Op,NO,YES,robot)
                                   == FAIL){
                if(TryAgainToLoad(Op->name,Op))goto TRYAGAINLOAD;
                failed_to_find=YES;
                failed_to_load=YES;
              }
            }
            if(Op->type == PARTICLE){ 
              fread(&dummylong,sizeof(long),1,fr);
              fread(&(Op->particles),dummylong,1,fr);   
            }
            if(Op->type == ROBOT){/* skeleton structure if robot */
              fread(&dummylong,sizeof(long),1,fr);
              if(failed_to_find == YES || failed_to_load == YES ||
                                          dummylong != Op->nskeleton){
                SendPrgmQuery(IDQ_SKELINCOMPAT,0);
                if(dummylong > 0)for(k=0;k<dummylong;k++){
                  for(kk=0;kk<16;kk++)fread(&dummydouble,sizeof(double),1,fr);
                }
              }
              else{
                Op->nskeleton=dummylong;
                if(Op->nskeleton > 0)for(k=0;k<Op->nskeleton;k++){
                  fread(Op->skeleton[k].R,sizeof(double),16,fr);
                  c4to4(Op->skeleton[k].R,Op->skeleton[k].Q);
                }
              }
            }
            fread(&(Op->groundtype),sizeof(short),1,fr);
            fread(&(Op->lighttype),sizeof(short),1,fr);
            fread(Op->colour,1,3,fr);
            if(Op->groundtype >= 255){  /* for compatibility  with old */
              Op->groundtype -= 256;
              fread(&(Op->gspec),sizeof(double),1,fr);
              fread(&(Op->gtran),sizeof(double),1,fr);
              fread(&(Op->grefl),sizeof(double),1,fr);
              fread(&(Op->gbump),sizeof(double),1,fr);
            }
            if(Op->groundtype > 127){
              fread(Op->acolour,1,3,fr);
            }
            fread(&(Op->pathtype),sizeof(short),1,fr);
            fread(&(Op->npathpoints),sizeof(short),1,fr);
            fread(&(Op->pathlength),sizeof(double),1,fr);
            if(Op->npathpoints > 0){
              for(k=0,Ppp=NULL;k<Op->npathpoints;k++){
                 if((Ppp=AppendPathPoint(Ppp)) == NULL){
                   DeleteCostume(Np,lastframe);
                   goto FAILED;
                 }
                 if(k == 0)Op->firstpathpoint=Ppp;
                 fread(&(Ppp->status),sizeof(short),1,fr);
                 fread(Ppp->p,sizeof(point),1,fr);
                 fread(&(Ppp->distance),sizeof(double),1,fr);
                 fread(&(Ppp->ptheta),sizeof(double),1,fr);
                 fread(&(Ppp->pfi),sizeof(double),1,fr);
                 Ppp->tension_p=Ppp->tension_n=0.5;
              }
            }
            if(Op->type == PATH){ /* read the path velocities + new items */
              if((Op->v=ReTweenVelocity(Op,NULL,
                      (int)(lastframe-firstframe+1),
                      (int)(lastframe-firstframe+1),
                      Op->pathlength,0)) != NULL){
                if(strncmp(Op->name,"PATH1991",8) == 0 ||
                   strncmp(Op->name,"PATH1995",8) == 0){
                  for(k=0;k<(lastframe-firstframe+1);k++)
                  if(fread(&(Op->v[k]),sizeof(double),1,fr) != 1)goto FAILED;
                }
                else strcpy(Op->name,"PATH1995"); /* make old paths new */
              }
              else goto FAILED;
              if(strncmp(Op->name,"PATH1995",8) == 0){ /* read tensions */
                PATHEDITCONTROL *pe1;
                if(Op->npathpoints > 0){
                  for(k=0,Ppp=Op->firstpathpoint;k<Op->npathpoints;k++){
                    fread(&(Ppp->tension_p),sizeof(double),1,fr);
                    fread(&(Ppp->tension_n),sizeof(double),1,fr);
                    Ppp=Ppp->next;
                  }
                }
                fread(&kk,sizeof(long),1,fr);  /* PathEdit Controls */
                Op->npec=0; Op->pec=NULL; pe1=NULL;
                if(kk > 0)for(k=0;k<kk;k++){
                  fread(&dummylong,sizeof(long),1,fr);
                  fread(&dummydouble,sizeof(double),1,fr);
                  pe1=CreatePathEditControlPoint(&(Op->npec),&(Op->pec),pe1,
                                                 NULL,dummylong,dummydouble);
                  if(Op->pec == NULL)goto FAILED;
                }
              }
              else strcpy(Op->name,"PATH1995"); /* make old paths new */
            }
            if(version > 1){ // for versions > 1
              fread(&(dummylong),sizeof(long),1,fr);
              Op->bWireframe=(short)dummylong;
              if(version > 2){
                fread(&(dummylong),sizeof(long),1,fr);
                Op->self_shadow=(short)dummylong;
                fread(&(dummylong),sizeof(long),1,fr);
                Op->cast_shadow=(short)dummylong;
                fread(&(dummylong),sizeof(long),1,fr);
                Op->show_shadow=(short)dummylong;
                fread(&(dummylong),sizeof(long),1,fr);
                Op->depth_cue=(short)dummylong;
                fread(&(Op->depth_cue_c),sizeof(double),1,fr);
                fread(&(Op->depth_cue_l),sizeof(double),1,fr);
                fread(&(Op->depth_cue_q),sizeof(double),1,fr);
                if(version > 5){  // version 6   
                  fread(&(Op->groundTemperature),sizeof(double),1,fr);
                  fread(&(Op->other_params),sizeof(double),8,fr);
                } 
              }
            }
            if(failed_to_load == YES)DeleteCostume(Np,lastframe);
          }
        }
        Np=Np->next;
      }
      goto SUCCESS;
      FAILED:
      SendPrgmQuery(IDQ_STAGELOADFAIL,0);
      SUCCESS:
      X__Free(NNp);
      if(!(GetAsyncKeyState(VK_CONTROL) & 0x8000)){ /* don't recentre */
        get_centre_stage(TVC,TVP,TVclipMax,TVclipMin);
        TVsizeX=2*(TVC[0]-TVP[0]);
        TVsizeY=2*(TVC[1]-TVP[1]);
        TVsizeZ=2*(TVC[2]-TVP[2]);
        TVpointX=TVP[0]-TVsizeX/10;
        TVpointY=TVP[1]-TVsizeY/10;
        TVpointZ=TVP[2]-TVsizeZ/10;
        TVsizeX += TVsizeX/5; TVsizeY += TVsizeY/5; TVsizeZ += TVsizeZ/5;
        TVcentreX=NpointerX=TVC[0];
        TVcentreY=NpointerY=TVC[1];
        TVcentreZ=NpointerZ=TVC[2];
        GetTriview(FALSE);  /* this will adjust the TV size */
      }
      if(failed_to_find){
        SendPrgmQuery(IDQ_NOTALLLOADED,0);
      }
    }
    else{
      SendPrgmQuery(IDQ_NOTSTAGEFILE,0);
    }
    if(version > 3){ // Read any additional chunks
      loop:
      if(fread(str,1,4,fr) != 4)goto NOLOAD;
      //MessageBox(NULL,str,"Reading V4 chunk",MB_OK);
      if(!getlon_s(&chunk_size,fr))goto NOLOAD;
      if((strcmp(str,"EOFF")) == 0)goto NOLOAD;  // End of animation file
      else if((strcmp(str,"EMAP")) == 0 && bEmbedImageMaps)
        LoadEmbeddedImageMaps(chunk_size,fr);
      else getchunk_F(chunk_size,fr);
      goto loop;
    }
    NOLOAD:
    fclose(fr);
    if(Error != 0){
      SendPrgmQuery(IDQ_READERROR,0);
    }
  }
  else{
   SendPrgmQuery(IDQ_FILEOPENFAIL,0);
  }
 }
 EDIT_ACTION=NO;
 if(discarded_file_list != NULL && n_discarded > 0){
   for(i=0;i<n_discarded;i++){
     if(discarded_file_list[i].old != NULL)X__Free(discarded_file_list[i].old);
     if(discarded_file_list[i].new != NULL)X__Free(discarded_file_list[i].new);
   }
   X__Free(discarded_file_list);
   discarded_file_list=NULL;
   n_discarded=0;
 }
 return OK;
}

short SaveAnimationFile(char *filename, BOOL backup){
 unsigned char zeroname[16];
 node         *Np,**NNp;
 object       *Op;
 sky          *Sp;
 director     *Dp;
 position     *Pp;
 align        *Ap;
 size         *Xp;
 pathpoint    *Ppp;
 XIP          *Ip;
 short        One,Zero,Error,Nobj,Nsky,Ndirector,Npos,Nali,Nsiz,
              tt,tg,endcode = OK;
 long         i,j,k,kk,Minus1,head_chunks,version=6;  // latest 
 int id;
#if __DEMO__
 // MessageBeep(MB_OK);
#else
 memset(zeroname,0,16);
 zeroname[0] = zeroname[4] = 255;
 zeroname[1] = zeroname[5] = 254;
 zeroname[2] = zeroname[6] = 253;
 zeroname[3] = zeroname[7] = 252;
 Zero=0; One=1; Error=0; Minus1 = -1;
 if(filename != NULL){
  if(!backup && ((fo=fopen(filename,"r")) != NULL)){ /* check for old file */
   fclose(fo);
   id=SendPrgmQuery(IDQ_OVERWRITE,1);
   if(id != IDYES)return -1;
  }
  if((fo=fopen(filename,"wb")) != NULL){
    sprintf(str,"OFXA"); fwrite(str,1,4,fo);
    head_chunks=2;
    outlng_s(head_chunks,fo);
    outlng_s((long)ruler,fo);
    fwrite(ruler_name,1,8,fo);
    outlng_s(lrulerx,fo); outlng_s(lrulery,fo); outlng_s(lrulerz,fo);
    outlng_s(rulerx,fo);  outlng_s(rulery,fo);  outlng_s(rulerz,fo);
    outlng_s(grid_size,fo);
    outlng_s(version,fo);
    if(NimageProcesses > 0){
      sprintf(str,"XIMP"); fwrite(str,1,4,fo);
      outlng_s((long)NimageProcesses,fo);
      Ip=FirstIp;
      for(i=0,Ip=FirstIp;i<NimageProcesses;i++,Ip=Ip->next){
        k=strlen(Ip->p);
        outlng_s(k,fo);
        fwrite(Ip->p,1,k,fo);
      }
    }
/* addition to pos rota and size structures */

    sprintf(str,"STAG"); fwrite(str,1,4,fo);
    fwrite(&Nframes,sizeof(long),1,fo);
    fwrite(&Nnodes,sizeof(short),1,fo);
    fwrite(&Nground,sizeof(short),1,fo);
    NNp=(node **)X__Malloc(Nnodes*sizeof(node *));
    if(NNp != NULL){
      for(i=0,Np=FirstNp;i<Nnodes;i++){
        fwrite(zeroname,1,16,fo);
        fwrite(Np->actorname,1,128,fo);
        fwrite(&(Np->type),sizeof(short),1,fo);
        fwrite(&(Np->ID),sizeof(short),1,fo);   // added
        if(i > 0 && Np->type == CAMERA){ /* first camera does not have flag */
          if(Np == SelectedCamera)fwrite(&One, 1,sizeof(short),fo);
          else                    fwrite(&Zero,1,sizeof(short),fo);
        }
        NNp[i]=Np;
        Np=Np->next;
      }
      for(i=0,Np=FirstNp;i<Nnodes;i++){
        fwrite(&(Np->type),sizeof(short),1,fo);
        fwrite(zeroname,1,16,fo);
        fwrite(Np->actorname,1,128,fo);
        Nsky=0;
        if((Sp=Np->fsky) != NULL){
          while(Sp != NULL){Nsky++; Sp=Sp->next;}
          fwrite(&Nsky,sizeof(short),1,fo);
          for(j=0,Sp=Np->fsky;j<Nsky;j++){
            fwrite(&(Sp->firstframe),sizeof(short),1,fo);
            fwrite(&(Sp->lastframe),sizeof(short),1,fo);
            fwrite(Sp->colour,1,3,fo);
            fwrite(Sp->zcolour,1,3,fo);
            id=Sp->type+8;   /* encode the type identifier */
            fwrite(&id,sizeof(short),1,fo);
            fwrite(&(Sp->gamb),sizeof(double),1,fo);
            fwrite(&(Sp->oamb),sizeof(double),1,fo);
            fwrite(Sp->gamb_colour,sizeof(double),3,fo);
            fwrite(Sp->oamb_colour,sizeof(double),3,fo);
            fwrite(Sp->name,1,128,fo);
            if(Sp->type == SKYANIMATED){
              fwrite(&(Sp->aff),sizeof(long),1,fo);
              fwrite(&(Sp->alf),sizeof(long),1,fo);
              fwrite(&(Sp->ast),sizeof(long),1,fo);
            }
            fwrite(&(Sp->sky_params),32*sizeof(double),1,fo); // version 5
            fwrite(&(Sp->sky_params_file),256,1,fo);          // version 5
            Sp=Sp->next;
          }
        }
        else fwrite(&Nsky,sizeof(short),1,fo);

        if(Np->type == DIRECTOR){
          Ndirector=0;
          Dp=Np->fdirector;
          while(Dp != NULL){Ndirector++; Dp=Dp->next;}
          fwrite(&Ndirector,sizeof(short),1,fo);
          if(Ndirector > 0)for(j=0,Dp=Np->fdirector;j<Ndirector;j++){
            fwrite(&(Dp->firstframe),sizeof(short),1,fo);
            fwrite(&(Dp->lastframe),sizeof(short),1,fo);
            kk=Dp->type;
            fwrite(&kk,sizeof(long),1,fo);
            if(Dp->ActiveCamera != NULL){
              for(k=0;k<Nnodes;k++)if(Dp->ActiveCamera == NNp[k])goto DPOS;
              k=Minus1;
              DPOS:
              fwrite(&k,sizeof(long),1,fo);
            }
            Dp=Dp->next;
          }
        }
        // else nothing to write
        Npos=0;
        if((Pp=Np->fpos) != NULL){
          while(Pp != NULL){Npos++; Pp=Pp->next;}
          fwrite(&Npos,sizeof(short),1,fo);
          for(j=0,Pp=Np->fpos;j<Npos;j++){
            fwrite(&(Pp->firstframe),sizeof(short),1,fo);
            fwrite(&(Pp->lastframe),sizeof(short),1,fo);
            fwrite(&(Pp->type),sizeof(short),1,fo);
            if(Pp->type == FOLLOWAT){
              fwrite(&(Pp->fx),sizeof(short),1,fo);
              fwrite(&(Pp->fy),sizeof(short),1,fo);
              fwrite(&(Pp->fz),sizeof(short),1,fo);
            }
            fwrite(Pp->finish,sizeof(point),1,fo);
            if(Pp->onpath != NULL){
              for(k=0;k<Nnodes;k++)if(Pp->onpath == NNp[k])goto EPOS;
              k=Minus1;
              EPOS:
              fwrite(&k,sizeof(long),1,fo);
            }
            else fwrite(&Minus1,sizeof(long),1,fo);
            fwrite(zeroname,1,16,fo);
            fwrite(Pp->pnodename,1,128,fo);
            Pp=Pp->next;
          }
        }
        else fwrite(&Npos,sizeof(short),1,fo);
        Nali=0;
        if((Ap=Np->fali) != NULL){
          while(Ap != NULL){Nali++; Ap=Ap->next;}
          fwrite(&Nali,sizeof(short),1,fo);
          for(j=0,Ap=Np->fali;j<Nali;j++){
            fwrite(&(Ap->firstframe),sizeof(short),1,fo);
            fwrite(&(Ap->lastframe),sizeof(short),1,fo);
            if(Ap->im > 0){     /* write out any internal motion */
              tt=Ap->type | 0x0008;
              fwrite(&tt,sizeof(short),1,fo);
              fwrite(&(Ap->im),sizeof(short),1,fo);
              fwrite(&(Ap->ima),sizeof(double),1,fo);
            }
            else fwrite(&(Ap->type),sizeof(short),1,fo);
            fwrite(&(Ap->theta),sizeof(double),1,fo);
            fwrite(&(Ap->phi),sizeof(double),1,fo);
            fwrite(&(Ap->alpha),sizeof(double),1,fo);
            if(Ap->topath != NULL){
              for(k=0;k<Nnodes;k++)if(Ap->topath == NNp[k])goto EALI;
              k=Minus1;
              EALI:
              fwrite(&k,sizeof(long),1,fo);
            }
            else fwrite(&Minus1,sizeof(long),1,fo);
            fwrite(zeroname,1,16,fo);
            fwrite(Ap->anodename,1,128,fo);
            Ap=Ap->next;
          }
        }
        else fwrite(&Nali,sizeof(short),1,fo);
        Nsiz=0;
        if((Xp=Np->fsiz) != NULL){
          while(Xp != NULL){Nsiz++; Xp=Xp->next;}
          fwrite(&Nsiz,sizeof(short),1,fo);
          for(j=0,Xp=Np->fsiz;j<Nsiz;j++){
            fwrite(&(Xp->firstframe),sizeof(short),1,fo);
            fwrite(&(Xp->lastframe),sizeof(short),1,fo);
            fwrite(&(Xp->Sx),sizeof(double),1,fo);
            fwrite(&(Xp->Sy),sizeof(double),1,fo);
            fwrite(&(Xp->Sz),sizeof(double),1,fo);
            fwrite(&(Xp->camera_params),20*sizeof(double),1,fo);  // only 3 used 17 left for expansion  // VERSION 5
            Xp=Xp->next;
          }
        }
        else fwrite(&Nsiz,sizeof(short),1,fo);
        Nobj=0;
        if((Op=Np->fobj) != NULL){ 
          while(Op != NULL){Nobj++; Op=Op->next;}
          fwrite(&Nobj,sizeof(short),1,fo);
          for(j=0,Op=Np->fobj;j<Nobj;j++){
            fwrite(&(Op->firstframe),sizeof(short),1,fo);
            fwrite(&(Op->lastframe),sizeof(short),1,fo);
            fwrite(Op->name,1,128,fo);  // need to make longer 
            fwrite(&(Op->type),sizeof(short),1,fo);
            if(Op->type == IMAGEP){
              if(Op->xip == NULL)tt=0;
              else               tt=1;
              fwrite(&tt,sizeof(short),1,fo);
              if(Op->xip != NULL){
                tt = strlen(Op->xip);
                fwrite(&tt,sizeof(short),1,fo);
                fwrite(Op->xip,1,tt,fo);
              }
            }
            if(Op->effect != NULL){
              tt = Op->morph | (127 << 4); /* combine morphing */
              fwrite(&tt,sizeof(short),1,fo);      /* with effect      */
              tt = strlen(Op->effect);
              fwrite(&tt,sizeof(short),1,fo);      /* size of effect   */
              fwrite(Op->effect,1,tt,fo);          /* effect           */
            }
            else{
              tt = Op->morph;
              fwrite(&tt,sizeof(short),1,fo);      /* no effect        */
            }
            fwrite(&(Op->morphNo),sizeof(short),1,fo);
            fwrite(&(Op->fileID),sizeof(short),1,fo);
            fwrite(Op->origin,sizeof(point),1,fo);
            fwrite(Op->outline,sizeof(point),8,fo);
            if(Op->type == PARTICLE){
              kk=sizeof(ParticleSystem);
              fwrite(&kk,sizeof(long),1,fo); 
              fwrite(&(Op->particles),kk,1,fo);
            } 
            if(Op->type == ROBOT){/* skeleton structure if robot */
              fwrite(&(Op->nskeleton),sizeof(long),1,fo);
              if(Op->nskeleton > 0)for(k=0;k<Op->nskeleton;k++){
                fwrite(Op->skeleton[k].R,sizeof(double),16,fo);
              }
            }
            tg=Op->groundtype+256;
            fwrite(&tg,sizeof(short),1,fo);
            fwrite(&(Op->lighttype),sizeof(short),1,fo);
            fwrite(Op->colour,1,3,fo);
            fwrite(&(Op->gspec),sizeof(double),1,fo);
            fwrite(&(Op->gtran),sizeof(double),1,fo);
            fwrite(&(Op->grefl),sizeof(double),1,fo);
            fwrite(&(Op->gbump),sizeof(double),1,fo);
            if(Op->groundtype > 127){
              fwrite(Op->acolour,1,3,fo);
            }
            fwrite(&(Op->pathtype),sizeof(short),1,fo);
            fwrite(&(Op->npathpoints),sizeof(short),1,fo);
            fwrite(&(Op->pathlength),sizeof(double),1,fo);
            if(Op->npathpoints > 0)
            for(k=0,Ppp=Op->firstpathpoint;k<Op->npathpoints;k++){
              fwrite(&(Ppp->status),sizeof(short),1,fo);
              fwrite(Ppp->p,sizeof(point),1,fo);
              fwrite(&(Ppp->distance),sizeof(double),1,fo);
              fwrite(&(Ppp->ptheta),sizeof(double),1,fo);
              fwrite(&(Ppp->pfi),sizeof(double),1,fo);
              Ppp=Ppp->next;
            }
            if(Op->type == PATH){/*out path velocities if path */
              PATHEDITCONTROL *pe1;
              if(Op->v == NULL){
                SendPrgmQuery(IDQ_MANGLEDPATH,0);
              }
              else for(k=0;k<(Op->lastframe - Op->firstframe + 1);k++)
                fwrite(&(Op->v[k]),sizeof(double),1,fo);
              if(Op->npathpoints > 0){
                for(k=0,Ppp=Op->firstpathpoint;k<Op->npathpoints;k++){
                  fwrite(&(Ppp->tension_p),sizeof(double),1,fo);
                  fwrite(&(Ppp->tension_n),sizeof(double),1,fo);
                  Ppp=Ppp->next;
                }
              }
              kk=Op->npec;
              fwrite(&kk,sizeof(long),1,fo);  /* PathEdit Controls */
              if(Op->npec > 0)for(k=0,pe1=Op->pec;k<Op->npec;k++){
                kk=pe1->frame; fwrite(&kk,sizeof(long),1,fo);
                fwrite(&(pe1->distance),sizeof(double),1,fo);
                pe1=pe1->next;
              }
            }
            if(version > 1){ // put additions here
              kk=(long)Op->bWireframe; fwrite(&kk,sizeof(long),1,fo);
              if(version > 2){
                kk=(long)Op->self_shadow; fwrite(&kk,sizeof(long),1,fo);
                kk=(long)Op->cast_shadow; fwrite(&kk,sizeof(long),1,fo);
                kk=(long)Op->show_shadow; fwrite(&kk,sizeof(long),1,fo);
                kk=(long)Op->depth_cue; fwrite(&kk,sizeof(long),1,fo);
                fwrite(&(Op->depth_cue_c),sizeof(double),1,fo);
                fwrite(&(Op->depth_cue_l),sizeof(double),1,fo);
                fwrite(&(Op->depth_cue_q),sizeof(double),1,fo);
                if(version > 5){  // version 6   
                  fwrite(&(Op->groundTemperature),sizeof(double),1,fo);
                  fwrite(&(Op->other_params),sizeof(double),8,fo);
                } 
              }
            }
            Op=Op->next;
          }
        }
        else fwrite(&Nobj,sizeof(short),1,fo);
        Np=Np->next;
      }
      X__Free(NNp);
    }
    else{
      endcode = FAIL;
      SendPrgmQuery(IDQ_NOMEM1,0);
    }
    if(endcode != FAIL){
      long posIs = -1, posIe = -1;
      fprintf(fo,"EMAP"); posIs=ftell(fo); outlng_s(0,fo);
      WriteEmbeddedImageMaps(fo);
      posIe=ftell(fo);
      fprintf(fo,"EOFF"); outlng_s(0,fo);  // zero length chunk to end 
      if(posIs > 0){fseek(fo,posIs,0); outlng_s(posIe-posIs-4,fo);} // enbedded images
    }
    fclose(fo);
    if(Error != 0){
      endcode = FAIL;
      SendPrgmQuery(IDQ_SAVINGERROR,0);
    }
  }
  else{
   endcode = FAIL;
   SendPrgmQuery(IDQ_FILEOPENFAIL,0);
  }
 }
 else endcode = FAIL;
#endif
 return endcode;
}

static void LoadEmbeddedImageMaps(long chunk_size, FILE *fr){
 node    *Np;
 object  *Op;
 sky     *Sp;
 long    i,st; 
 for(i=0,Np=FirstNp;i<Nnodes;i++){
   if((Sp=Np->fsky) != NULL){
     while(Sp != NULL){
       st=Sp->type;
       if(st == SKYMAPPED   ||
          st == SKYANIMATED ||
          st == SKYCUBE     ||
          st == BACKDROP){
          //MessageBox(NULL,Sp->name,"Reading Sky for",MB_OK);
          ReadRamImage(&(Sp->image),fr);
        }
        Sp=Sp->next;
     }
   }
   if((Op=Np->fobj) != NULL){
     while(Op != NULL){
       if(Op->type == GROUND){
         if(Op->groundtype == BRUM || Op->groundtype == TBRUM ||
            Op->groundtype == MBRUM){
           //MessageBox(NULL,Op->name,"Reading Ground for",MB_OK);
           ReadRamImage(&(Op->image),fr);
         }
       }
       Op=Op->next;
     }
   }
   Np=Np->next;
 }
}

static void WriteEmbeddedImageMaps(FILE *fr){
 node    *Np;
 object  *Op;
 sky     *Sp;
 long    i,st; 
 for(i=0,Np=FirstNp;i<Nnodes;i++){
   if((Sp=Np->fsky) != NULL){
     while(Sp != NULL){
       st=Sp->type;
       if(st == SKYMAPPED   ||
          st == SKYANIMATED ||
          st == SKYCUBE     ||
          st == BACKDROP){
          WriteRamImage(&(Sp->image),fr);
        }
        Sp=Sp->next;
     }
   }
   if((Op=Np->fobj) != NULL){
     while(Op != NULL){
       if(Op->type == GROUND){
         if(Op->groundtype == BRUM || Op->groundtype == TBRUM ||
            Op->groundtype == MBRUM){
           WriteRamImage(&(Op->image),fr);
         }
       }
       Op=Op->next;
     }
   }
   Np=Np->next;
 }
}

// end save/load OFX file  //////////////////////////////


pathpoint *LoadPath(short *pathtype, short *npathpoints, HWND parent){
 FILE *fpp;
 pathpoint *Ppp=NULL,*Fpp=NULL,*Lpp=NULL;
 short  fail,points,x,y,z,i;
 long xx,yy,zz;
 unsigned char closed,magic;
 long   packer;
 EnableToolPannels(ALL_PANNELS,FALSE);
 if(SelectSfxFileName(0,gszPTHfile,gszPTHdir,IDX_MISC_OPENPATH,
   "(*.PTH)|*.pth|",parent) == TRUE){
   EnableToolPannels(ALL_PANNELS,TRUE);
   if((fpp=fopen(gszPTHfile,"rb")) == NULL){
     SendPrgmQuery(IDQ_FILEOPENFAIL,0);
     return NULL;
   }
   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(fread(&magic,1,1 ,fpp)  != 1 || magic != 0x88)goto NOREAD;
   if(points == 0)goto NOREAD;
   for(i=0; i< points; i++){
     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;
     if((Ppp=AppendPathPoint(Ppp)) == NULL)goto NOREAD;
     Ppp->p[0]=xx; Ppp->p[1]=yy; Ppp->p[2]=zz;
     Ppp->ptheta=0;Ppp->pfi=0;
     Ppp->tension_p=Ppp->tension_n=0.5;
     Ppp->distance=0.0; /* set by path length calculation */
     Lpp=Ppp;
     if(i == 0)Fpp=Ppp;
   }
   *npathpoints = points;
   if(closed == 1) *pathtype = CLOSED;
   else            *pathtype = OPEN;
   goto READOK;
   NOREAD:
   SendPrgmQuery(IDQ_MANGLEDPATH,0);
   fclose(fpp);
   if(Lpp != NULL)while(Lpp!=NULL){Ppp=Lpp->last; X__Free(Lpp); Lpp=Ppp;}
   return NULL;
   READOK:
   fclose(fpp);
   return Fpp;   /* return pointer to first point on path */
 }
 EnableToolPannels(ALL_PANNELS,TRUE);
 return NULL;
}

void SaveAnimFile(node *Np){
  FILE *fani;
  object *Op;
  char objectname[256];
  short count,tf;
 if(Np->type != NORMAL && Np->type != ANIMOBJ){
   SendPrgmQuery(IDQ_OLD2,0);
   return;
 }
 if(SelectSfxFileName(1,gszANIfile,gszANIdir,IDX_MISC_WRITEMODELSET,
   "(*.ANI)|*.ani|",ghwndTimeline) == TRUE){
    AppendFileExtension(gszANIfile,".ani");
    if( (fani=fopen(gszANIfile,"w")) == NULL){
      SendPrgmQuery(IDQ_FILEOPENFAIL,0);
      return;
    }
    count=0; tf=0;
    if((Op=Np->fobj) != NULL)while(Op!=NULL){
      count++; tf=Op->lastframe; Op=Op->next;
    }
    fprintf(fani,"%d %d\n",count,tf);
    if((Op=Np->fobj) != NULL)while(Op!=NULL){
      strcpy(objectname,Op->name);
      HideWhiteSpaces(objectname);
      fprintf(fani,"%s %d %d\n",objectname,Op->firstframe,Op->lastframe);
      Op=Op->next;
    }
    fclose(fani);
  }
  return;
}

void LoadAnimObject(node *Np, short firstframe, short lastframe, HWND parent){
 FILE *fani;
 long count,cyclelength,Ncycles,dt,elementstart,elementend,elementlength;
 short ff,lf,llf,failed_to_load;
 char  string[16],objectfile[128];
 long  fpos,i,j;
 double scale;
 object *tempobj,*firstobj;
 if(lastframe < firstframe)return;
 EDIT_ACTION=YES;
 failed_to_load=NO;
 dt=lastframe-firstframe+1;
 if(SelectSfxFileName(0,gszANIfile,gszANIdir,IDX_MISC_OPENMODELSET,
   "(*.ANI)|*.ani|",parent) == TRUE){
   if( (fani=fopen(gszANIfile,"r")) == NULL){
     SendPrgmQuery(IDQ_FILEOPENFAIL,0);
     return;
   }
   Ncycles=RequestNumEntry(1,1,99,"No. Cycles"," Cycles");
   if(Ncycles < 0){
    fclose(fani);
    return;
   }
   if(fscanf(fani,"%ld %ld\n",&count,&cyclelength) != 2){
     SendPrgmQuery(IDQ_READERROR,0);
     fclose(fani);
     return;
   }
   if((count-1)*Ncycles + 1 > dt){ /* at least one frame for each element */
     SendPrgmQuery(IDQ_ANIOBJ1,0);
     fclose(fani);
     return;
   }
   if(fscanf(fani,"%s %ld %ld\n",objectfile
                 ,&elementstart,&elementend) != 3){
     SendPrgmQuery(IDQ_READERROR,0);
     fclose(fani);
     return;
   }
   RestoreWhiteSpaces(objectfile);
   elementlength = elementend-elementstart+1;
   if(elementlength != 1){
     SendPrgmQuery(IDQ_ANIOBJ2,0);
     fclose(fani);
     return;
   }
   ff=firstframe; lf=ff;  /* the first element is always 1 frame no morph */
   firstobj=NULL;
   tempobj=CreateCostume(Np,ff,lf);
   if(tempobj == NULL || fail_op == YES){
     if(tempobj != NULL)DeleteCostume(Np,ff);
     SendPrgmQuery(IDQ_ANIOBJ3,0);
     fclose(fani);
     return;
   }
   tempobj->type=Np->type;
   strcpy(tempobj->name,objectfile);
   tempobj->morph=NO;
   if(LoadMeshObject(objectfile,tempobj,NO,YES,NO) == FAIL){
     DeleteCostume(Np,ff);
     failed_to_load=YES;
   }
   else firstobj=tempobj;
   fpos=ftell(fani);
   cyclelength -= 1; /* excluding the first frame which is 1 frame */
   scale = (double)(dt-1)/(double)(Ncycles*cyclelength);
   llf=lf+1;
   for(j=0;j<Ncycles;j++){
     for(i=0;i<count-1;i++){
       if(fscanf(fani,"%s %ld %ld\n",objectfile
                     ,&elementstart,&elementend) != 3){
         SendPrgmQuery(IDQ_READERROR,0);
         fclose(fani);
         return;
       }
       RestoreWhiteSpaces(objectfile);
       ff=firstframe + (short)(( cyclelength*j + elementstart - 1 )*scale);
       if(ff < llf)ff=llf;
       lf=firstframe + (short)(( cyclelength*j + elementend   - 1 )*scale);
       if(lf < llf)lf =llf;
       llf=lf+1;  /* insist on at least one frame for each element */
       tempobj=CreateCostume(Np,ff,lf);
       if(tempobj == NULL || fail_op == YES){
         if(tempobj != NULL)DeleteCostume(Np,ff);
         SendPrgmQuery(IDQ_ANIOBJ3,0);
         fclose(fani);
         return;
       }
       tempobj->type=Np->type;
       strcpy(tempobj->name,objectfile);
       tempobj->morph = YES; /* possible new data */
       if(LoadMeshObject(objectfile,tempobj,NO,YES,NO) == FAIL){
         failed_to_load=YES;
         DeleteCostume(Np,ff);
         tempobj=NULL;
       }
     }
     fseek(fani,fpos,SEEK_SET);
   }
   if(lf < lastframe && tempobj != NULL)tempobj->lastframe = lastframe;
   fclose(fani);
   if(firstobj != NULL)if((firstobj=firstobj->next) != NULL)
   while(firstobj != NULL){ /* fix up object end points */
     firstobj->firstframe = firstobj->last->lastframe+1;
     firstobj=firstobj->next;
   }
 }
 if(failed_to_load){
   SendPrgmQuery(IDQ_ANIOBJ4,0);
 }
}


struct done_list {char fn[256],fm[256];};

static struct done_list *pdone;
static int ndone;

static BOOL in_done_list(char *name){
 int i;
 if(ndone > 0){
   for(i=0;i<ndone;i++){
     if(strcmp(pdone[i].fn,name) == 0)return TRUE;
   } 
 }
 if(ndone == 0)pdone=(struct done_line *)X__Malloc(sizeof(struct done_list));
 else          pdone=(struct done_line *)X__Realloc(pdone,sizeof(struct done_list)*(ndone+1));
 if(pdone != NULL){
   //fprintf(debug,"Adding [%s] to done list item %ld\n",name,ndone);
   strcpy(pdone[ndone].fn,name);
   ndone++;
 }
 return FALSE;
}

static BOOL in_comp_list(char *name, char *newname){
 if(ndone == 0)pdone=(struct done_line *)X__Malloc(sizeof(struct done_list));
 else          pdone=(struct done_line *)X__Realloc(pdone,sizeof(struct done_list)*(ndone+1));
 if(pdone != NULL){
   strcpy(pdone[ndone].fn,name);
   strcpy(pdone[ndone].fm,newname);
   ndone++;
 }
 return FALSE;
}


static void copy_file_to_pack(FILE *pk, char *f){
 FILE *fi;
 char c;
 int bc=0,cc;
 if((fi=fopen(f,"rb")) != NULL){
   while(!feof(fi)){
     cc=fread(&c,1,1,fi); 
     if(ferror(fi)){MessageBox(NULL," ",NULL,MB_OK); break;}
     if(cc > 0)fwrite(&c,1,1,pk); bc += cc;
   } 
   fclose(fi);
 }  
 //if(debug != NULL)fprintf(debug,"%ld bytes copied from file [%s]\n",bc,f);
}

static void copy_file_from_pack(FILE *pk, char *f, int l){
 FILE *fo;
 char c;
 int bc=0,cc;
 if((fo=fopen(f,"wb")) != NULL){
   for(bc=0;bc<l;bc++){
     cc=fread(&c,1,1,pk); 
     if(ferror(pk)){MessageBox(NULL," ",NULL,MB_OK); break;}
     if(cc > 0)fwrite(&c,1,1,fo);
   } 
   fclose(fo);
 }  
 //if(debug != NULL)fprintf(debug,"%ld bytes written to file [%s]\n",l,f);
}


void PackAnimationFile(void){
 struct done_list *pdone=NULL;
 FILE *foo;
 char tempstor[512];
 node *Np;
 object *Op;
 int i,j,Nobj;
 long pos1,pos1e,pos2,pos2e,pos3,pos3e;
 if(SelectSfxFileName(1,gszPAKfile,gszPAKdir,  // 1=>Save
    IDX_MISC_PACK,"(*.OFXP)|*.ofxp|",ghwnd_main) == TRUE){
   AppendFileExtension(gszPAKfile,".ofxp");
   ghcurSave=SetCursor(ghcurWait);
   strcpy(tempstor,TempPath);
   strcat(tempstor,"build_$.ofx");
   SaveAnimationFile(tempstor,TRUE);
   if((foo=fopen(gszPAKfile,"wb")) != NULL){
     fprintf(foo,"FORM");
     pos1=ftell(foo); outlng_s(0,foo);
     fprintf(foo,"OFXP");
     fprintf(foo,"ANIM"); pos2=ftell(foo);  outlng_s(0,foo); 
     copy_file_to_pack(foo,tempstor);
     pos2e=ftell(foo);
     ndone=0; pdone=NULL;
     //if(debug != NULL)fprintf(debug,"Pak [%s] Anim [%s]\n",gszPAKfile,tempstor);
     for(i=0,Np=FirstNp;i<Nnodes;i++){
       if((Op=Np->fobj) != NULL){ 
         Nobj=0; while(Op != NULL){Nobj++; Op=Op->next;}
         for(j=0,Op=Np->fobj;j<Nobj;j++){
           if(Op->fileID >= 0){
//           if(Op->type == NORMAL || Op->type == ANIMOBJ || Op->type == ROBOT){ // This should be same as ...
             if(!in_done_list(Op->name)){
               fprintf(foo,"MODL"); pos3=ftell(foo);  outlng_s(0,foo); 
               //if(debug != NULL)fprintf(debug,"Copying File [%s], type %ld\n",Op->name,Op->type);
               outlng_s(255,foo); fwrite(Op->name,1,255,foo);
               copy_file_to_pack(foo,Op->name);
               pos3e=ftell(foo);
               fseek(foo,pos3,0);  outlng_s(pos3e-pos3-4,foo);
               //if(debug != NULL)fprintf(debug,"Model file %ld bytes\n",pos3e-pos3-4);
               fseek(foo,pos3e,0); 
             }
           }
           Op=Op->next;
         }
       }
       Np=Np->next;
     }
     fprintf(foo,"ENDP"); outlng_s(0,foo); 
     if(pdone != NULL)X__Free(pdone);
     pos1e=ftell(foo);
     fseek(foo,pos1,0);  outlng_s(pos1e-pos1-4,foo); // overall form   
     fseek(foo,pos2,0);  outlng_s(pos2e-pos2-4,foo); // animation file
     fclose(foo);
   }
   else  SendPrgmQuery(IDQ_FILEOPENFAIL,0);
   remove(tempstor);
   SetCursor(ghcurSave);
 }
}

void UnpackAnimationFile(void){
 FILE *fii;
 char *pj,chunk[5],animation_file[256],model_file[256],new_name[256];
 long ns,chunksize;
 chunk[4]='\0';
 if(SelectSfxFileName(0,gszPAKfile,gszPAKdir,IDX_MISC_UNPACK,
      "(*.OFXP)|*.ofxp|",ghwnd_main) == TRUE){

   strcpy(animation_file,gszPAKfile); 
   animation_file[strlen(gszPAKfile)-1] = '\0';
   ndone=0; pdone=NULL;
   if((fii=fopen(gszPAKfile,"rb")) != NULL){
     fread(chunk,1,4,fii);
     if(strncmp(chunk,"FORM",4) != 0)goto ERROR_READ;  // not a pack file  
     getlon_s(&chunksize,fii);
     fread(chunk,1,4,fii);
     if(strncmp(chunk,"OFXP",4) != 0)goto ERROR_READ;  // not a pack file  
     fread(chunk,1,4,fii);
     if(strncmp(chunk,"ANIM",4) != 0)goto ERROR_READ;  // not an animation file 
     getlon_s(&chunksize,fii);
     //if(debug != NULL)fprintf(debug,"Writing animation file [%s] length %ld\n",animation_file,chunksize);
     copy_file_from_pack(fii,animation_file,chunksize);
     while(1){  // process the models
       fread(chunk,1,4,fii);
       if(ferror(fii))goto ERROR_READ;
       getlon_s(&chunksize,fii);
       //if(debug != NULL)fprintf(debug,"Reading Chunk [%s] length %ld\n",chunk,chunksize);
       if(strncmp(chunk,"ENDP",4) == 0)break; // end of models
       else if(strncmp(chunk,"MODL",4) == 0){
         getlon_s(&ns,fii); fread(model_file,1,255,fii);
         // make up the new name
         strcpy(new_name,animation_file); pj=strrchr(new_name,'\\');
         if(pj != NULL){pj += 1; *pj=0;}
         strcat(new_name,short_form(model_file));
         in_comp_list(model_file,new_name);
         //if(debug != NULL)fprintf(debug,"model [%s] size %ld new_name [%s]\n",model_file,chunksize-259,new_name);
         //getchunk_F(chunksize-259,fii); // testing instead of next line
         copy_file_from_pack(fii,new_name,chunksize-259);
       }
       else getchunk_F(chunksize,fii);
       if(feof(fii))goto ERROR_READ;
     }
     fclose(fii);
     // Load the animation and re-vector all the names
     LoadAnimationFile(animation_file,TRUE);
     // now resave the animation
     SaveAnimationFile(animation_file,TRUE);
     ReDrawStageDisplay(TRUE);
     if(ghwndOpenGLview == NULL)PerspectiveView(0,1);
     else UpdateGLview(TRUE);
     if(coords_visible)UpdateRuler(0);
     UPDATETIMELINES(IDC_TIMEL_UPDATE)
     goto END_UNPACK;
     ERROR_READ:
     MessageBox(NULL," ",NULL,MB_OK);
     fclose(fii);
     END_UNPACK:   
     if(pdone != NULL)X__Free(pdone); pdone=NULL; ndone=0;
   }
 }
}

static void UnpackName(char *name){
 int i;
 if(ndone > 0){
   for(i=0;i<ndone;i++){
     if(strcmp(pdone[i].fn,name) == 0){ // found the name - substitute replacement
       strcpy(name,pdone[i].fm);
       return;
     }
   } 
 }
}


static long undo_frame;

void Save_UndoA(void){
 if(UNDO_ACTIVE == NO)return;
//MessageBeep(MB_OK);
 undo_frame=CurrentFrame;
 SaveAnimationFile(gszUndoFile,TRUE);
 EnableMenuItem(GetMenu(ghwnd_main),IDM_ACTOR_TOOL_UNDO,MF_ENABLED);
}

void Restore_UndoA(void){
 if(UNDO_ACTIVE == NO)return;
 SetCursor(ghcurSave);
 LoadAnimationFile(gszUndoFile,FALSE);
 CurrentFrame=undo_frame;
// SetScrollRange(ghwnd_xscl,SB_CTL,1,(int)Nframes,FALSE);
// SetScrollPos(ghwnd_xscl,SB_CTL,(int)CurrentFrame,TRUE);
 SendMessage(ghwnd_xscl,TBM_SETRANGE,(WPARAM)TRUE,(LPARAM)MAKELONG(1,Nframes));
 SendMessage(ghwnd_xscl,TBM_SETPOS,TRUE,(LPARAM)CurrentFrame);
 ReDrawStageDisplay(TRUE);
 if(ghwndOpenGLview == NULL)PerspectiveView(0,1);
 else UpdateGLview(TRUE);
 if(coords_visible)UpdateRuler(0);
 UPDATETIMELINES(IDC_TIMEL_UPDATE)
 SetCursor(ghcurSave);
}