LOADSCPT.C

Go to the documentation of this file.

/*    FILE LOADSCPT.CPP   */
//
// The code in this file reads script files and builds the
// animation in RAM it call to the LOADMESH file to read
// mesh models


#define MODULE_READER

#include "render.h"

extern FILE *CF;
extern short End_of_animation;
extern BOOL bKeepObjectsInRAM;

static int CheckForExistingObject(char * objectname){
 int i,j;
 if(!bKeepObjectsInRAM)return -1;
 if(FirstObject > 0)for(i=0;i<FirstObject;i++){
   if(!Object[i].in_use && stricmp(objectname,Object[i].FileNameKey) == 0){ // this one
     if(Object[i].NoVbackup == 0){Object[i].NoVertices=0; Object[i].Vbase=NULL;}
     else if((Object[i].Vbase = (vertex *)X__Malloc(Object[i].NoVbackup*sizeof(vertex))) != NULL){
       if(Object[i].Vbackup != NULL){
         memcpy(Object[i].Vbase,Object[i].Vbackup,Object[i].NoVbackup*sizeof(vertex));
         Object[i].NoVertices=Object[i].NoVbackup;
       }
       else return -1;  
     }
     else return -1;
     if(Object[i].NoFbackup == 0){Object[i].NoFaces=0; Object[i].Fbase=NULL;}
     else if((Object[i].Fbase = (face *)X__Malloc(Object[i].NoFbackup*sizeof(face))) != NULL){
       if(Object[i].Fbackup != NULL){
         memcpy(Object[i].Fbase,Object[i].Fbackup,Object[i].NoFbackup*sizeof(face));
         Object[i].NoFaces=Object[i].NoFbackup;
       }
       else return -1;  
     }
     else return -1;
     if(Object[i].NoTbackup == 0){Object[i].NoMats=0; Object[i].Tbase=NULL;}
     else if((Object[i].Tbase = (matl *)X__Malloc(Object[i].NoTbackup*sizeof(matl))) != NULL){
       if(Object[i].Tbackup != NULL){
         memcpy(Object[i].Tbase,Object[i].Tbackup,Object[i].NoTbackup*sizeof(matl));
         Object[i].NoMats=Object[i].NoTbackup;
       }
       else return -1;  
     }
     else return -1;
     //if(debug != NULL)fprintf(debug,"(Looking for, up to %ld) for [%s] with [%s]in RAM at %ld ...  Loaded\n",FirstObject,objectname,Object[i].FileNameKey,i);
     return i; 
   }
 }
 return -1;
}

static BOOL CopyObjectToBackup(long i){
 if(!bKeepObjectsInRAM)return FALSE;
 if(Object[i].NoVertices == 0){Object[i].NoVbackup=0; Object[i].Vbackup=NULL;}
 else if((Object[i].Vbackup = (vertex *)X__Malloc(Object[i].NoVertices*sizeof(vertex))) != NULL){
   if(Object[i].Vbackup != NULL){
     memcpy(Object[i].Vbackup,Object[i].Vbase,Object[i].NoVertices*sizeof(vertex));
     Object[i].NoVbackup=Object[i].NoVertices;
   }
   else return FALSE;  
 }
 else return FALSE;
 if(Object[i].NoFaces == 0){Object[i].NoFbackup=0; Object[i].Fbackup=NULL;}
 else if((Object[i].Fbackup = (face *)X__Malloc(Object[i].NoFaces*sizeof(face))) != NULL){
   if(Object[i].Fbackup != NULL){
     memcpy(Object[i].Fbackup,Object[i].Fbase,Object[i].NoFaces*sizeof(face));
     Object[i].NoFbackup=Object[i].NoFaces;
   }
   else return FALSE;  
 }
 else return FALSE;
 if(Object[i].NoMats == 0){Object[i].NoTbackup=0; Object[i].Tbackup=NULL;}
 else if((Object[i].Tbackup = (matl *)X__Malloc(Object[i].NoMats*sizeof(matl))) != NULL){
   if(Object[i].Tbackup != NULL){
     memcpy(Object[i].Tbackup,Object[i].Tbase,Object[i].NoMats*sizeof(matl));
     Object[i].NoTbackup=Object[i].NoMats;
   }
   else return FALSE;  
 }
 else return FALSE; 
 //if(debug != NULL)fprintf(debug,"Copied to backup V=%ld F=%ld M=%ld\n",Object[i].NoVertices,Object[i].NoFaces,Object[i].NoMats);
 return TRUE;
}

void FreeFrameObjects(void){
 long i;
// return; ////////////////
 if(ObjectCount > 0){
   for(i=0;i<ObjectCount;i++){
     if(!Object[i].in_use)continue;
     Object[i].in_use=FALSE;
     if(Object[i].Vbase != NULL)X__Free(Object[i].Vbase); Object[i].Vbase=NULL; Object[i].NoVertices=0;
     if(Object[i].Fbase != NULL)X__Free(Object[i].Fbase); Object[i].Fbase=NULL; Object[i].NoFaces=0;
     if(Object[i].Tbase != NULL)X__Free(Object[i].Tbase); Object[i].Vbase=NULL; Object[i].NoMats=0;
     if(Object[i].Mbase != NULL)FreeMovieMapImages(i);
     //if(debug != NULL)fprintf(debug,"Freed Frame object %ld \n",i); 
  }
 }
}

void FreeAllObjects(void){
 long i;
 if(Shader != NULL)FreeExternalTextures(); // These need to be retained until animation is over
 Shader=NULL; Nshader=0;
 if(ObjectCount > 0){
   for(i=0;i<ObjectCount;i++){
     if(Object[i].Vbackup != NULL)X__Free(Object[i].Vbackup);
     if(Object[i].Fbackup != NULL)X__Free(Object[i].Fbackup);
     if(Object[i].Skeleton  != NULL)X__Free(Object[i].Skeleton);
     if(Object[i].Skids  != NULL)X__Free(Object[i].Skids);
     if(Object[i].effect_param_list != NULL)X__Free(Object[i].effect_param_list);
     if(Object[i].Mbase != NULL)X__Free(Object[i].Mbase);
     if(Object[i].Tbackup != NULL)X__Free(Object[i].Tbackup); 
     if(Object[i].Nbase != NULL){
       FreeNurbs(Object[i].NoNurbs,Object[i].Nbase);
       Object[i].NoNurbs=0;
       Object[i].Nbase=NULL;
     }
     //if(debug != NULL)fprintf(debug,"Free all of object %ld \n",i); 
   }
 }
 if(Object != NULL){X__Free(Object); Object = NULL; ObjectCount=0;}
}

static void read_vec(vector v){
 if(fscanf(CF,GET_VEC,&v[0],&v[1],&v[2]) != 3){
   Render_Message(6,0,NULL);
 }
}

/* Read the ASCII script file .SCR and assemble the Actors */

int GetCommand(long firstframe, long frame, long nAnimStart,
                      char *outfile_root){
 BOOL bNew;
 long i,ObjectID,animator_id;
 long a=0,b=0,c,d,e,f;
 double p,t,al,du,sx,sy,sz,gbtr[4][4],tr1[4][4],tr2[4][4],
        qmorph_ratio,robo_ratio,i_ratio=0.0;
 short imo,mo,robo=NO;
 char   Com[16],second_morph[256],robo_file1[256],robo_file2[256],
        morphfile[256],tempfile[256],namefile[256],*cc;
 object *temp_object;
 light  *temp_light;
 ParticleSystem *temp_particles;
 XIP    *temp_xip;
 long   flag;
 while (fscanf(CF,"%s",Com) != EOF){
  imo=0;
  switch(Com[0]) {
    case 'e' :  // camera 'eye'
      read_vec(ViewPoint);
      fscanf(CF,GET_VEC,&CamPhi,&CamTheta,&CamAlpha);
      fscanf(CF,GET_VEC,&CamSx,&CamSy,&CamSz);
      fscanf(CF,"%ld %ld",&a,&b); CamIm=b;  /* camera internal */
      fscanf(CF,GET_DOB,&CamIma);
      break;
    case 'E' :  // camera 'eye 2 ' 
      read_vec(ViewPoint);
      fscanf(CF,GET_VEC,&CamPhi,&CamTheta,&CamAlpha);
      fscanf(CF,GET_VEC,&CamSx,&CamSy,&CamSz);
      fscanf(CF,"%ld %ld",&a,&b); CamIm=b;  /* camera internal */
      fscanf(CF,GET_DOB,&CamIma);
      { // read extra camera parameters
        double d1,d2,d3;
        fscanf(CF,GET_VEC,&CamFocalLength,&CamFnumber,&CamFocusDepth); // focus depth in OFX units
        fscanf(CF,GET_VEC,&CamFocusDepthM,&CamRuler,&d1); // Focus depth in Metre here
        if((int)d1 == 0 || (int)d1 == 1)CamPolarisation=1; // None or Horizontal use TE(S)perpendicular 
        else CamPolarisation=2; // set at Vertical etc.  use TM(P)parallel
        // CamRuler is the same as animation ruler CamPolarisation is an integer list (0=None etc.) 
        fscanf(CF,GET_VEC,&CamStereoSeparation,&CamParallaxDepth,&d1);
        for(i=0;i<7;i++)fscanf(CF,GET_VEC,&d1,&d2,&d3);
      }
      break;
    case 'i' :   // image processor - post process
      fscanf(CF,"%ld %ld %ld %ld",&imo,&a,&c,&b);
      fscanf(CF,GET_DOB,&i_ratio);
      if(ImageProcesses == NULL)temp_xip = (XIP *)X__Malloc(sizeof(XIP));
      else                      temp_xip = (XIP *)X__Realloc(ImageProcesses,
                                    (nImageProcesses+1)*sizeof(XIP));
      if(temp_xip == NULL)return -1;
      temp_xip[nImageProcesses].imo=(long)imo;
      temp_xip[nImageProcesses].first_frame=a;
      temp_xip[nImageProcesses].this_frame=c;
      temp_xip[nImageProcesses].last_frame=b;
      temp_xip[nImageProcesses].fmr=i_ratio;
      temp_xip[nImageProcesses].parameters=NULL;
      temp_xip[nImageProcesses].mparameters=NULL;
      { char itempfile[512];
        fscanf(CF," %[^\n]",itempfile); c=strlen(itempfile)+1;
        if((temp_xip[nImageProcesses].parameters=(char *)X__Malloc(c)) != NULL)
          strcpy(temp_xip[nImageProcesses].parameters,itempfile);
        if(imo == 1){
          fscanf(CF," %[^\n]",itempfile); c=strlen(itempfile)+1;
          if((temp_xip[nImageProcesses].mparameters=(char *)X__Malloc(c)) != NULL)
            strcpy(temp_xip[nImageProcesses].mparameters,itempfile);
        }
      }
      ImageProcesses=temp_xip;
      nImageProcesses++;
      break;
    case 'l' :
      if(Lights == NULL)temp_light = (light *)X__Malloc(sizeof(light));
      else              temp_light = (light *)X__Realloc(Lights,
                                        (Nlights+1)*sizeof(light));
      if(temp_light == NULL){
        Render_Message(7,0,NULL);
        if(Lights != NULL)X__Free(Lights);
        Lights=NULL;
        return -1;
      }
      Lights=temp_light;
      Lights[Nlights].dc=FALSE;
      Lights[Nlights].dc_c=1.0;
      Lights[Nlights].dc_l=0.0;
      Lights[Nlights].dc_q=0.0;
      fscanf(CF,"%ld",&a); Lights[Nlights].type=a;
      fscanf(CF,"%ld %ld %ld",&a,&b,&c);
      fscanf(CF,GET_DOB,&Lights[Nlights].Intensity);
      Lights[Nlights].Intensity=1.0;
      Lights[Nlights].color[0] = (unsigned char)a;
      Lights[Nlights].color[1] = (unsigned char)b;
      Lights[Nlights].color[2] = (unsigned char)c;
      read_vec(Lights[Nlights].p);
      VECCOPY(Lights[Nlights].p,Lights[Nlights].pin)
      fscanf(CF,GET_VEC,&Lights[Nlights].dPhi
                       ,&Lights[Nlights].dTheta
                       ,&Lights[Nlights].dAlpha);
      /* Theta axis bank  (Not used)                  */
      /* Phi is direction   Alpha is elevation angle  */
      fscanf(CF,"%ld %ld",&a,&b);  /* light internals */
      Lights[Nlights].AnimatorID=a;
      Lights[Nlights].internal_type=b;
      fscanf(CF,GET_DOB,&Lights[Nlights].internal_size);
      fscanf(CF,"%ld",&a);  /* light depth cue */
      Lights[Nlights].dc=a;
      fscanf(CF,GET_DOB,&Lights[Nlights].dc_c);
      fscanf(CF,GET_DOB,&Lights[Nlights].dc_l);
      fscanf(CF,GET_DOB,&Lights[Nlights].dc_q);
      if(Lights[Nlights].type == SPOTLIGHT){
        fscanf(CF,GET_DOB,&Lights[Nlights].cone1);    /* angle  */
        fscanf(CF,GET_DOB,&Lights[Nlights].falloff);  /* degree */
      }
      Nlights++;
      break;

    case 'p' :  // particle system
      if(ParticleS == NULL)temp_particles = (ParticleSystem *)X__Malloc(sizeof(ParticleSystem));
      else                 temp_particles = (ParticleSystem *)X__Realloc(ParticleS,
                                        (Nparticles+1)*sizeof(ParticleSystem));
      if(temp_particles == NULL){
        Render_Message(7,0,NULL);
        if(ParticleS != NULL)X__Free(ParticleS);
        ParticleS=NULL; Nparticles=0;
        return -1;
      }
      ParticleS=temp_particles;
      ParticleS[Nparticles].particles=NULL;
      fscanf(CF,"%ld %ld %ld",&a,&b,&c);
      ParticleS[Nparticles].id=a;
      ParticleS[Nparticles].iid=b;
      ParticleS[Nparticles].bSingle=(BOOL)c;
      //ParticleS[Nparticles].bSingle=FALSE;
      fscanf(CF,"%s",ParticleS[Nparticles].ImageName);
      //  Read the particle system parameters
      fscanf(CF,"  %d %d %d %d\n",&a,&b,&c,&d);
      ParticleS[Nparticles].particle_size_scale=a;
      ParticleS[Nparticles].particle_speed_scale=b;
      ParticleS[Nparticles].bSteadyState=(BOOL)c;
      ParticleS[Nparticles].bSpinOff=(BOOL)d;
      fscanf(CF,"  %d %d %d %d\n",&a,&b,&c,&d);
      ParticleS[Nparticles].Rate=a;         ParticleS[Nparticles].bBurst=(BOOL)b; 
      ParticleS[Nparticles].bGround=(BOOL)c; ParticleS[Nparticles].blend_type=(BOOL)d;  
      fscanf(CF,"  %d %d %d\n",&a,&b,&c);
      ParticleS[Nparticles].colour_start[0]=a; 
      ParticleS[Nparticles].colour_start[1]=b; 
      ParticleS[Nparticles].colour_start[2]=c;
      fscanf(CF,"  %d %d %d\n",&a,&b,&c);
      ParticleS[Nparticles].colour_end[0]=a; 
      ParticleS[Nparticles].colour_end[1]=b; 
      ParticleS[Nparticles].colour_end[2]=c;
      fscanf(CF,"  %d %d %d %d\n",&a,&b,&c,&d);
      ParticleS[Nparticles].alpha_start=a; 
      ParticleS[Nparticles].size_start=b; 
      ParticleS[Nparticles].alpha_end=c; 
      ParticleS[Nparticles].size_end=d; 
      fscanf(CF,"  %d %d %d\n",&a,&b,&c);
      ParticleS[Nparticles].life=a; 
      ParticleS[Nparticles].speed=b;
      ParticleS[Nparticles].theta=c;
      fscanf(CF,"  %d %d %d %d %d\n",&a,&b,&c,&d,&e);
      ParticleS[Nparticles].vcolour=a; ParticleS[Nparticles].valpha=b;
      ParticleS[Nparticles].vsize=c;   ParticleS[Nparticles].vlife=d;  ParticleS[Nparticles].vspeed=e;
      fscanf(CF,"  %d %d %d \n",&a,&b,&c);
      ParticleS[Nparticles].ew_start=a; ParticleS[Nparticles].ud_start=b; ParticleS[Nparticles].ns_start=c;  
      fscanf(CF,"  %d %d %d \n",&a,&b,&c);
      ParticleS[Nparticles].ew_end=a; ParticleS[Nparticles].ud_end=b; ParticleS[Nparticles].ns_end=c;  
      //  Read the particle system settings
      read_vec(ParticleS[Nparticles].pin);
      fscanf(CF,GET_VEC,&ParticleS[Nparticles].dPhi,&ParticleS[Nparticles].dTheta,&ParticleS[Nparticles].dAlpha);
      fscanf(CF,GET_VEC,&ParticleS[Nparticles].sx,&ParticleS[Nparticles].sy,&ParticleS[Nparticles].sz);
      fscanf(CF,"%ld",&a);  ParticleS[Nparticles].im=a;
      fscanf(CF,GET_DOB,&ParticleS[Nparticles].ima);
      fscanf(CF,"%ld",&a); ParticleS[Nparticles].dframe=a;
      fscanf(CF,GET_DOB,&t); ParticleS[Nparticles].mratio=t;
      read_vec(ParticleS[Nparticles].vel);  // velocity of particle system
      read_vec(ParticleS[Nparticles].spin);
      fscanf(CF,GET_VEC,&ParticleS[Nparticles].sdPhi,&ParticleS[Nparticles].sdTheta,&ParticleS[Nparticles].sdAlpha);
      fscanf(CF,GET_VEC,&ParticleS[Nparticles].ssx,&ParticleS[Nparticles].ssy,&ParticleS[Nparticles].ssz);
      fscanf(CF,"%ld",&a);  ParticleS[Nparticles].sim=a;
      fscanf(CF,GET_DOB,&ParticleS[Nparticles].sima);
      Nparticles++;
      break;
     case 'G' :  // GROUND2
     case 'g' :  // ground
       memset(&Ground,0,sizeof(ground));
       fscanf(CF,"%ld",&a); Ground.type=a;
       fscanf(CF,"%ld %ld %ld",&a,&b,&c);
       memset(&Ground.map,0,sizeof(imap));
       Ground.color[0] = (unsigned char)a;
       Ground.color[1] = (unsigned char)b;
       Ground.color[2] = (unsigned char)c;
       Ground.ambient_light=ambient_light*0.8;
       Ground.texture = -1;
       if(Ground.type == PLAIN)Ground.texture=0;
       else if(Ground.type > 127){
         fscanf(CF,"%ld %ld %ld",&a,&b,&c);
         Ground.acolor[0] = (unsigned char)a;
         Ground.acolor[1] = (unsigned char)b;
         Ground.acolor[2] = (unsigned char)c;
         Ground.texture = Ground.type-128;
         Ground.type = TEXTU;
         if(Ground.texture == 0)Ground.type=PLAIN;
         else if(Ground.texture > 15){  /* external shader  NOT USED NOW */
           fscanf(CF,"  %[^\n]",namefile); /* no parameters yet */
         }
       }
       if(Ground.type == BRUM || Ground.type == TBRUM || Ground.type == MBRUM){
         fscanf(CF,"  %[^\n]",namefile);
         strcpy(Ground.map.filename,namefile);
         Ground.map.pp = 100; /* strength use to indicate */
         Ground.map.rp =  -1; /* brush is STATIC only     */
         Ground.map.bp =  -1;
         Ground.map.tp =  -1;
       }
       SKIPH1:
       read_vec(Ground.p);
       fscanf(CF,GET_VEC,&p,&t,&al);
       fscanf(CF,GET_VEC,&sx,&sy,&sz);
       fscanf(CF,"%ld %ld",&a,&b);  /* ground internals */
       fscanf(CF,GET_DOB,&du);
       fscanf(CF,GET_DOB,&Ground.refl); Ground.refl *= 0.01;
       Ground.height=sz;
       Ground.x[0]=Ground.p[0]+(double)UNIT*sx*4.0;  /* ground is flat */
       Ground.x[1]=Ground.p[1];
       Ground.x[2]=Ground.p[2];
       Ground.y[0]=Ground.p[0];
       Ground.y[1]=Ground.p[1]-(double)UNIT*sy*4.0;
       Ground.y[2]=Ground.p[2];       /* this may change */
       R_Nground=1;
       Ground.mapped=FALSE;
       if(Ground.type == TEXTU){
         vecsub(Ground.x,Ground.p,Ground.x);
         vecsub(Ground.y,Ground.p,Ground.y);
         if(b > 0){
           if(b == 1)R_rotz(tr1,du*PI/180.0);
           if(b == 2)R_rotx(tr1,du*PI/180.0);
           if(b == 3)R_roty(tr1,du*PI/180.0);
           R_rotz(tr2,p*PI/180.0);
           R_m4by4(tr2,tr1,gbtr);
         }
         else R_rotz(gbtr,p*PI/180.0);
         R_m4by1(gbtr, Ground.x[0], Ground.x[1],
                       Ground.x[2],&Ground.x[0],
                      &Ground.x[1],&Ground.x[2]);
         R_m4by1(gbtr, Ground.y[0], Ground.y[1],
                       Ground.y[2],&Ground.y[0],
                       &Ground.y[1],&Ground.y[2]);
         vecsum(Ground.x,Ground.p,Ground.x);
         vecsum(Ground.y,Ground.p,Ground.y);
       }
       else if(Ground.type == BRUM || Ground.type == TBRUM || Ground.type == MBRUM){
         Ground.map.p[0]=0.0;
         Ground.map.p[1]=0.0;
         Ground.map.p[2]=0.0;
         Ground.map.x[0]=Ground.map.p[0]+UNIT*4*sx;
         Ground.map.x[1]=Ground.map.p[1];
         Ground.map.x[2]=Ground.map.p[2];
         Ground.map.y[0]=Ground.map.p[0];
         Ground.map.y[1]=Ground.map.p[1]-UNIT*4*sy;
         Ground.map.y[2]=Ground.map.p[2];
         if(b > 0){
           if(b == 1)R_rotz(tr1,du*PI/180.0);
           if(b == 2)R_rotx(tr1,du*PI/180.0);
           if(b == 3)R_roty(tr1,du*PI/180.0);
           R_rotz(tr2,p*PI/180.0);
           R_m4by4(tr2,tr1,gbtr);
         }
         else R_rotz(gbtr,p*PI/180.0);
         R_m4by1(gbtr, Ground.map.x[0], Ground.map.x[1],
                       Ground.map.x[2],&Ground.map.x[0],
                      &Ground.map.x[1],&Ground.map.x[2]);
         R_m4by1(gbtr, Ground.map.y[0], Ground.map.y[1],
                       Ground.map.y[2],&Ground.map.y[0],
                      &Ground.map.y[1],&Ground.map.y[2]);
         vecsum(Ground.map.p,Ground.p,Ground.map.p);
         vecsum(Ground.map.x,Ground.p,Ground.map.x);
         vecsum(Ground.map.y,Ground.p,Ground.map.y);
         VECCOPY(Ground.map.p,Ground.map.pin)
         VECCOPY(Ground.map.x,Ground.map.xin)
         VECCOPY(Ground.map.y,Ground.map.yin)
         if(SetupImageMap(&Ground.map,"dummy") == 1 && Ground.map.pp == 100){
           if(Ground.type ==  BRUM)Ground.maptype=SINGLE;
           if(Ground.type == TBRUM)Ground.maptype=TILE;
           if(Ground.type == MBRUM){
             Ground.maptype=TILE;
             Ground.map.moziac=YES;
           }
           Ground.mapped=TRUE;
         }
         else Ground.type=PLAIN;  /* could not load map */
       }
       if(Com[0] == 'G'){
          fscanf(CF,GET_DOB,&t); // temperature
       }
       VECCOPY(Ground.p,Ground.pin)
       VECCOPY(Ground.x,Ground.xin)
       VECCOPY(Ground.y,Ground.yin)
       break;
     case 'S':
       {int j; double dummy;
        for(j=0;j<32;j++)fscanf(CF,GET_DOB,&dummy);
       }
       break; 
     case 's' :
       fscanf(CF,"%ld %ld %ld %ld %ld %ld ",&a,&b,&c,&d,&e,&f);
       Sky.Horizon[0]=a; Sky.Horizon[1]=b; Sky.Horizon[2]=c;
       Sky.Zenith[0]=d; Sky.Zenith[1]=e; Sky.Zenith[2]=f;
       fscanf(CF,GET_DOB,&Sky.blendratio);
       fscanf(CF,GET_DOB,&object_ambient_light);
       fscanf(CF,GET_DOB,&ground_ambient_light);
       fscanf(CF,"%ld %ld %ld %ld %ld %ld ",&a,&b,&c,&d,&e,&f);
       Sky.Zblend[0]=a; Sky.Zblend[1]=b; Sky.Zblend[2]=c;
       Sky.Hblend[0]=d; Sky.Hblend[1]=e; Sky.Hblend[2]=f;
       fscanf(CF,"%ld",&a);
       Sky.type = (short)a;
       Sky.mapped=FALSE;
       memset(&Sky.map,0,sizeof(imap));
       skyYscale=2.2111; skyXscale=0.888; skyBmax=199;
       if(Sky.type > SKYGRADED){
         fscanf(CF,"  %[^\n]",namefile);
         strcpy(Sky.map.filename,namefile);
         Sky.map.pp = 100; /* strength use to indicate */
         Sky.map.rp =  -1; /* brush is STATIC only     */
         Sky.map.bp =  -1;
         Sky.map.tp =  -1;
         Sky.map.p[0]=0.0;
         Sky.map.p[1]=0.0;
         Sky.map.p[2]=UNIT*1000;                 // this provides a sky map which will 
         Sky.map.x[0]=Sky.map.p[0]+UNIT*5000;    // be used when doing a raytracing
         Sky.map.x[1]=Sky.map.p[1];              // it gives a cylindrical map
         Sky.map.x[2]=Sky.map.p[2];
         Sky.map.y[0]=Sky.map.p[0];
         Sky.map.y[1]=Sky.map.p[1]+UNIT*5000;
         Sky.map.y[2]=Sky.map.p[2];
         VECCOPY(Sky.map.p,Sky.map.pin)
         VECCOPY(Sky.map.x,Sky.map.xin)
         VECCOPY(Sky.map.y,Sky.map.yin)
         if(SetupImageMap(&Sky.map,"dummy") == 1 && Sky.map.pp == 100){ // MAP NOT loaded will return pp = -1
           Sky.mapped=TRUE;
           Sky.map.map=PLANE;
           skyYscale=(double)(Sky.map.ymax-1)/90.0;
           skyXscale=(double)(Sky.map.xmax)/360.0;
           skyBmax=Sky.map.ymax-1;
         }
         else Sky.mapped=FALSE;
       }
       SKIPH2:
       Nsky=1;
       break;
     case 'o' :
       fscanf(CF," %ld",&animator_id); 
       fscanf(CF," %[^\n]",tempfile);  /* note single space in format */
       { char messages[255];
         sprintf(messages,"Loading %s",tempfile);
         Render_Message(91,0,messages);
       }
       strcpy(namefile,tempfile);
       bNew=FALSE;
       ObjectID=CheckForExistingObject(namefile);
// check to see if already loaded, if so, don't create again 
// only check up to previous frames and not assigned in this frame
// do it by free count
       if(ObjectID < 0){
         if(Object == NULL)temp_object = (object *)X__Malloc(sizeof(object));
         else              temp_object = (object *)X__Realloc(Object,
                                         (ObjectCount+1)*sizeof(object));
         if(temp_object == NULL){
           Render_Message(7,0,NULL);
           if(Object != NULL)X__Free(Object);
           Object=NULL;
           return -1;
         }
         //if(debug != NULL)fprintf(debug,"\nNew Object for [%s]\n",namefile);  
         Object=temp_object;
         memset(&(Object[ObjectCount]),0,sizeof(object));
         ObjectID=ObjectCount;
         ObjectCount++;
         bNew=TRUE;
       }
       
       Object[ObjectID].AnimatorID=animator_id;
       Object[ObjectID].self_shadow=TRUE;
       Object[ObjectID].cast_shadow=TRUE;
       Object[ObjectID].show_shadow=TRUE;
       Object[ObjectID].wireframe=FALSE;
       Object[ObjectID].visibility=NO;
       Object[ObjectID].morphratio=1.0;
       fscanf(CF,"%ld",&a); mo=a;
       robo=NO;
       if(mo == 4){ /* robot  note the special read with leading spaces */
         robo=YES;  // get the robot transforfm file names
         fscanf(CF," %[^\n]",tempfile);  /* note single space */
         strcpy(robo_file1,tempfile);
         fscanf(CF,"  %[^\n]",tempfile);   /* note double space */
         strcpy(robo_file2,tempfile);
         fscanf(CF,GET_DOB,&robo_ratio);
         mo=0;     /* robots can't morph */
       }
       if(mo > 0){  // get the morph ratio and morph file
         long mvs,ovs,swp;
         fscanf(CF,GET_DOB,&Object[ObjectID].morphratio);
         fscanf(CF,"  %[^\n]",tempfile);    /* note double space */
         strcpy(morphfile,tempfile);
       }
       // now load the Main Object
       if(bNew){
         if(R_LoadObject(ObjectID,namefile,frame+nAnimStart,robo,robo_ratio,
                         robo_file1,robo_file2) <= 0){
           Render_Message(34,1,namefile);
           return (-1);
         }
         strcpy(Object[ObjectID].FileNameKey,namefile);
         if(Object[ObjectID].NoFaces > 0){
           long i;  // test to make sure object counts are OK
           face *f=Object[ObjectID].Fbase;
           vertex *v=Object[ObjectID].Vbase;
           for(i=0;i<Object[ObjectID].NoFaces;i++){
             if(f[i].ffmat >= Object[ObjectID].NoMats)Object[ObjectID].NoMats = -1;
             if(f[i].ffmap >= Object[ObjectID].NoMaps)Object[ObjectID].NoMaps = -1;
             // Assign the FACE based vertex mapping coordinates from the vertex U/V coords.
             // if vertex coords exist and the FACE has NO faces vertex mapping coords.
             f[i].ww[0]=f[i].ww[1]=f[i].ww[2]=0.5;
             if(!f[i].bFmc){
               f[i].uu[0]=(v+f[i].V[0])->u; f[i].vv[0]=(v+f[i].V[0])->v;     
               f[i].uu[1]=(v+f[i].V[1])->u; f[i].vv[1]=(v+f[i].V[1])->v;     
               f[i].uu[2]=(v+f[i].V[2])->u; f[i].vv[2]=(v+f[i].V[2])->v;
               //if(debug != NULL){int kk; for(kk=0;kk<3;kk++)fprintf(debug,
               //"Assign FC from VC %ld %ld - (%lf %lf)\n",i,kk,f[i].uu[kk],f[i].vv[kk]);}
             }     
           }
         }
         AssignMappingCoordinatesToVertices(&Object[ObjectID]);
         CopyObjectToBackup(ObjectID);
       }
       Object[ObjectID].in_use=TRUE;
       CompleteMovieMapLoading(ObjectID,Object[ObjectID].FileNameKey);
       //if(debug != NULL)fprintf(debug,"Object [%s] loaded\n",namefile);
       if(robo == YES && Object[ObjectID].Skids != NULL && Object[ObjectID].Skeleton != NULL){
         RenderTransformToRobot(ObjectID,
                           Object[ObjectID].Skids,
                           Object[ObjectID].Skeleton,
                           robo_ratio,
                           robo_file1,robo_file2);
         RenderRubberBones(ObjectID,Object[ObjectID].NoSkeleton,Object[ObjectID].Skids,Object[ObjectID].Skeleton);
       }
       // Now apply the morph to the loaded object
       if(mo > 0){ // now load the morph file
         strcpy(namefile,morphfile);
         if(mo > 1){/* Q morph is not used removed for now */
           mo=1;
           fscanf(CF,GET_DOB,&qmorph_ratio);
           fscanf(CF,"  %[^\n]",tempfile);  /* note double space */
           strcpy(second_morph,tempfile);
         }
         // load the morph object and apply it to the main object  
         if(LoadMorphObject(ObjectID, mo,namefile,Object[ObjectID].morphratio,
            second_morph,qmorph_ratio) == 0)Render_Message(35,1,namefile);
       }
       // Now get the transformations and parameters for the object
       read_vec(Object[ObjectID].Offset);
       fscanf(CF,GET_VEC,&Object[ObjectID].fi
                        ,&Object[ObjectID].theta
                        ,&Object[ObjectID].alpha);
       fscanf(CF,GET_VEC,&Object[ObjectID].sx
                        ,&Object[ObjectID].sy
                        ,&Object[ObjectID].sz);
       fscanf(CF,"%ld %ld",&a,&b); /* a is zero for expansion */
       Object[ObjectID].im=b;   // internal rotation 0=NONE 1=xaxis etc.
       fscanf(CF,GET_DOB,&Object[ObjectID].ima); // angle of internal rotation
       fscanf(CF,"%ld",&a); Object[ObjectID].effect=a;    // Vertex Effect
       fscanf(CF,GET_DOB,&Object[ObjectID].effectratio);  
       // Three integer flags
       fscanf(CF,"%ld %ld %ld",&Object[ObjectID].self_shadow,
         &Object[ObjectID].cast_shadow,&Object[ObjectID].show_shadow);
       // if any object effects have been set we read their parameters
       if(a > 20){ // vertex effect
         c=0L;  
         Object[ObjectID].effect_param_list=NULL;
         fscanf(CF,"  %s",tempfile);  /* note 2 spaces */ 
         b=strlen(tempfile)+1L;
         if((Object[ObjectID].effect_param_list=(char *)X__Malloc(b)) == NULL){
           Object[ObjectID].effect=0;
           goto NOFX;
         }
         else strcpy(Object[ObjectID].effect_param_list,tempfile);
         c += b;
         while(1){
           fscanf(CF,"%s",tempfile);  // get the bits of the string
           if(strcmp(tempfile,"~") == 0) break;
           b=strlen(tempfile)+2L;
           c += b;
           if((Object[ObjectID].effect_param_list=(char *)
               X__Realloc(Object[ObjectID].effect_param_list,c)
              ) == NULL){ Object[ObjectID].effect=0; goto NOFX; }
           else {
             strcat(Object[ObjectID].effect_param_list," ");
             strcat(Object[ObjectID].effect_param_list,tempfile);
           }
         }
         /* Determine if F/X is internal */

         sscanf(Object[ObjectID].effect_param_list,"%s",tempfile);
         Object[ObjectID].effect=50; // ALL effects are eternam now
         NOFX:;
       }
       break;
     case 'b' : return 1; break;  // end of integrated frame
     case 'f' : return 0; break;  // end of frame
     case 'q' :
       fclose(CF);
       CF=NULL;
       End_of_animation=1;
       WindowedRenderMessage(WRM_COMPLETE);
       return (-1);
     default:   break;
  }
 }
 Render_Message(37,1,NULL);
 return (-1);
}