LOADMESH.C

Go to the documentation of this file.

// loadmesh.cpp  -- This file contains the code to load
//                  the mesh models
//

#define MODULE_LOADER

#include "render.h"

extern char gszHomeDir[];

extern char TempPath[];

typedef double quaternion[4];

static void InterpolateRobot(double mr, long n, skel *sk1, skel *sk2);
static long RenderReadNurbs(long, long clen);
static long *RenderReadSkeleton(long clen, short version, skel **sp, long *);
static short R_ReadAxis(long, long clen);
static short R_ReadFaces(long, long  clen, int version);
static short R_ReadVertices(long, long clen);
static short R_ReadVertText(long, long clen, BOOL);
static short R_ReadFaceMapping(long ObjectID, long clen);
static short R_ReadImaps(long, long clen, long frame,
                    char *objectfilename, char *str, BOOL new_type);
static unsigned char *ReadShaderFromBuffer(long id, matl *Mat, unsigned char *b);
static short R_ReadMaterial(long id, long, long clen);
static void CompleteImageMapLoading(long, char *);
static void LoadEmbededImageMaps(long, long clen, char *objectfilename);
static short R_ReadMorphShader(long clen,
                    char *objectfilename, char *str);
static void R_MorphVector(long, vector b, ivector Mx, double mr);
static int IdentifyImageFileType(char *fn);

HANDLE fp;
DWORD dwRead;
static char str[10]={0,0,0,0,0, 0,0,0,0,0};
static long newface,newvert;
static int  number_of_file_extensions=6;
static char *image_file_extensions[]={".gif",".tga",".tif",".jpg",".png",".bmp"};
static double ruler_length;
static int IdentifyImageFileType(char *fn){
 int i; char last4[5];
 last4[4]=0;
 strncpy(last4,(fn+strlen(fn)-4),4);
 strlwr(last4);
 for(i=0;i<number_of_file_extensions;i++){
   if(strncmp((char *)last4,image_file_extensions[i],4) == 0)return i;
 }
 return -1; 
}

char R_getl(long *val){
 long l,l0,l1,l2,l3;
 ReadFile(fp,&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);
}

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

char R_getusht(unsigned short * val){
 unsigned short s,s0,s1;
 ReadFile(fp,&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 R_MorphVector(long ObjectID, vector b, ivector Mx, double mr){
 long i,j;
 for(i=0;i<3;i++){
   R_getl(&j); j=j+Object[ObjectID].Centre[i]-Mx[i];
   b[i]=(b[i]-(double)j)*mr + (double)j;
 }
}

#define MORPH1(a,b,m) { a = (unsigned char)(((double)b -(double)a)*(m) + (double)a);}
#define MORPH2(a,b,m) { a = (unsigned char)(((double)b -(double)a)*(m) + (double)a);}

static unsigned char *ReadMorphShaderFromBuffer(long id, matl *Mat, unsigned char *b){
 char tempname[256],tempparam[512];  // must be long enough for longest !
 long version,active,in_use,ln,lp;
 version=GetLongFromBuffer(b); b+= 4;
 active =GetLongFromBuffer(b); b+= 4;
 in_use =GetLongFromBuffer(b); b+= 4;
 Mat->shaderID[id] = -1;  // NOT used until loaded
 if(in_use){
   ln=GetLongFromBuffer(b); b+= 4; // length of name
   lp=GetLongFromBuffer(b); b+= 4; // length of parameter list
   memcpy(tempname,b,ln+1);  b += ln+1;
   memcpy(tempparam,b,lp+1); b += lp+1;
// // Use shader MORPH function
//   if(active && LoadExte rnalTexture(tempname,tempparam) == OK){ // needs to be thought out
//     Mat->shaderID[id]=Nshader-1;
//   }
 }
 return b;
}

static short MorphMaterial(long id, long ObjectID, long clen, double mr){
 long i,j,v,l,n;
 unsigned char *buffer=NULL,*b,color[3],texco[3];
 matl *Mat;
 buffer=(unsigned char *)X__Malloc(clen);
 if(buffer == NULL)return -1;
 ReadFile(fp,buffer,clen,&dwRead,NULL);
 b=buffer; n=GetLongFromBuffer(b); b+= 4;  
 if(n > 0){
   //if(debug != NULL)fprintf(debug,"Reading %ld MORPH materials\n",n);
   n=min(n,Object[ObjectID].NoMats);
   for(i=0;i<n;i++){
     Mat=(Object[ObjectID].Tbase+(long)i);
     b+= 4; b+= 32; 
     memcpy(color,b,3); b+= 3;
     memcpy(texco,b,3); b+= 3;
     for(j=0;j<3;j++)MORPH1(Mat->color[j],color[j],1.0-mr)
     for(j=0;j<3;j++)MORPH1(Mat->texco[j],texco[j],1.0-mr)
     b += 5*3;  b+= 24; 
     for(j=0;j<3;j++){l=GetLongFromBuffer(b); b+= 4; MORPH2(Mat->ax.bo[j],l,mr) }
     for(j=0;j<3;j++){l=GetLongFromBuffer(b); b+= 4; MORPH2(Mat->ax.bu[j],l,mr) }
     for(j=0;j<3;j++){l=GetLongFromBuffer(b); b+= 4; MORPH2(Mat->ax.bv[j],l,mr) }
     VECCOPY(Mat->ax.bo,Mat->ax.boin)
     VECCOPY(Mat->ax.bu,Mat->ax.buin)
     VECCOPY(Mat->ax.bv,Mat->ax.bvin)
     for(j=0;j<4;j++)b=ReadMorphShaderFromBuffer(j,Mat,b);
     b+= 20;   b += 16*4;  b += 16*4; 
     if(id > 1)b += 512; // to skip over extra parameters
   }
 }
 X__Free(buffer);
 return 0;
}

static short MorphFaces(long ObjectID, long  clen, int version, double mo){
  long i,j,nf,sf;
  unsigned char color[3];
  unsigned char *buffer=NULL,*b;
  face   *f;
  if     (version == 0)nf=clen/18;
  else if(version == 1)nf=clen/24;
  else                 nf=clen/20;
  if(nf == 0)return -1;
  sf=sizeof(face);
  buffer=(unsigned char *)X__Malloc(clen);
  if(buffer == NULL)return -1;
  ReadFile(fp,buffer,clen,&dwRead,NULL);
  nf=min(nf,Object[ObjectID].NoFaces);
  f=Object[ObjectID].Fbase;
  b=buffer;
  //if(debug != NULL)fprintf(debug,"Morphing %ld faces\n",nf);
  for(i=0;i<nf;i++,f++){
    if(version == 0)  b+= 6; else b+= 12; 
    memcpy(color,b,3);b+=3;
    if(version == 2)  b+= 5; else b+= 9;
    for(j=0;j<3;j++)MORPH1(f->color[j],color[j],1.0-mo)
  }
  X__Free(buffer);
  return 0;
}

long LoadMorphObject(long ObjectID, short mo, char *FileName,double mr,
                     char *QmorphFile,double qr){
 unsigned char *buffer=NULL,*b;
 long CHUNKsize,FORMsize,i,j,nm;
 ivector Mx,Mv,Mq;
 vector V0,V1,VM;
 vertex *v;
 face   *f;
 int    same=1;
 Mx[0]=0; Mx[1]=0; Mx[2]=0;
 if((fp=GetRenderRelativeHandle((char *)strlwr(FileName),NULL,NULL))
   == INVALID_HANDLE_VALUE){ Render_Message(20,1,NULL);   goto X__ERROR;
 }
 ReadFile(fp,str,4,&dwRead,NULL);
 if(dwRead != 4 || strcmp(str,"FORM") != 0){
   Render_Message(21,1,NULL);   CloseHandle(fp);   goto X__ERROR;
 }
 ReadFile(fp,&FORMsize,4,&dwRead,NULL); ReadFile(fp,str,4,&dwRead,NULL);
 if(dwRead != 4 || (strcmp(str,"OFXM"))){
   Render_Message(22,1,NULL); CloseHandle(fp);   goto X__ERROR;
 }
loop:
 if(!ReadFile(fp,str,4,&dwRead,NULL))goto end;
 if(dwRead != 4)goto end;
 if (R_getl(&CHUNKsize) != 1)goto end;
 if(strcmp(str,"AXIS") == 0){/* Axis is assumed to be first chunk */
   R_getl(&j); Mx[0] = j; R_getl(&j); Mx[1] = j; R_getl(&j); Mx[2] = j; 
   R_MorphVector(ObjectID,Object[ObjectID].Abase.bo,Mx,mr); /* Tx origin */
   R_MorphVector(ObjectID,Object[ObjectID].Abase.bu,Mx,mr); /* Tx X      */
   R_MorphVector(ObjectID,Object[ObjectID].Abase.bv,Mx,mr); /* Tx X      */
   VECCOPY(Object[ObjectID].Abase.bo,Object[ObjectID].Abase.boin)
   VECCOPY(Object[ObjectID].Abase.bu,Object[ObjectID].Abase.buin)
   VECCOPY(Object[ObjectID].Abase.bv,Object[ObjectID].Abase.bvin)
 }
 else if (strcmp(str,"VERT") == 0){ 
   nm=CHUNKsize/12;
   nm=min(nm,Object[ObjectID].NoVertices);
   v=Object[ObjectID].Vbase;
   for(i=0;i<nm;i++){
     R_getl(&j); Mv[0] = j+Object[ObjectID].Centre[0]-Mx[0];
     R_getl(&j); Mv[1] = j+Object[ObjectID].Centre[1]-Mx[1];
     R_getl(&j); Mv[2] = j+Object[ObjectID].Centre[2]-Mx[2];
     v[i].p[0] = (v[i].p[0]-(double)Mv[0])*mr + (double)Mv[0];
     v[i].p[1] = (v[i].p[1]-(double)Mv[1])*mr + (double)Mv[1];
     v[i].p[2] = (v[i].p[2]-(double)Mv[2])*mr + (double)Mv[2];
   }
 }
 else if(strcmp(str,"SFCE") == 0){if(MorphFaces(ObjectID,CHUNKsize,0,mr) < 0); goto end;}
 else if(strcmp(str,"LFCE") == 0){if(MorphFaces(ObjectID,CHUNKsize,1,mr) < 0); goto end;}
 else if(strcmp(str,"NFCE") == 0){if(MorphFaces(ObjectID,CHUNKsize,2,mr) < 0) goto end;}
 else if(strcmp(str,"MTL1") == 0){MorphMaterial(1,ObjectID,CHUNKsize,mr); goto end;}
 else if(strcmp(str,"MTL2") == 0){MorphMaterial(2,ObjectID,CHUNKsize,mr); goto end;}
 else if(strcmp(str,"IMAP") == 0)goto end; // Dont morph maps
 else if(strcmp(str,"IMA2") == 0)goto end;
 else if(strcmp(str,"EMAP") == 0)goto end;
 else R_getchunk(CHUNKsize); /* read any unused chunks */
 goto loop;
end: CloseHandle(fp);
 return 1;
 X__ERROR:
 return 0;
}

// END of MORPHING code  ////////////////////////////////////////////

static long *RenderReadSkeleton(long clen, short version, skel **sp, long *ns){
 short ss;
 long  s;
 skel *Skeleton;
 long n,i,j,k,l,l0,l1,l2,*jj,*Skid;
 char name[32];
 Skeleton=NULL;
 Skid=NULL;
 R_getl(&n); *ns=n;
 if((*sp=(skel *)X__Malloc(n*(long)sizeof(skel))) != NULL)Skeleton=*sp;
 for(i=0;i<n;i++){ /* dump the original skeleton */
   R_getl(&l0);  R_getl(&l1);  R_getl(&l2);  
   if(version > 2)R_getl(&s);
   else{R_getsht(&ss); s=(long)ss;}
   if(Skeleton != NULL){
     (Skeleton+i)->id=(long)s;
     (Skeleton+i)->p[0] = (double)(l0);
     (Skeleton+i)->p[1] = (double)(l1);
     (Skeleton+i)->p[2] = (double)(l2);
     VECCOPY((Skeleton+i)->p,(Skeleton+i)->pcopy)
   }
   if(version > 0){
     ReadFile(fp,name,sizeof(char)*16,&dwRead,NULL);
     if(version > 3){
      R_getl(&l);
      (Skeleton+i)->weight=(double)l/1000.0;
      R_getl(&l);
      (Skeleton+i)->wrange=(double)l/1000.0;
      R_getl(&l);
      (Skeleton+i)->wzone=(double)l/1000.0;
     }
     else { (Skeleton+i)->weight=1.0; (Skeleton+i)->wrange=1000.0; (Skeleton+i)->wzone=1.0;}
   }
   if(version > 1){
     for(j=0;j<3;j++){R_getl(&l);}
     for(j=0;j<3;j++){R_getl(&l);}
     for(j=0;j<3;j++){R_getl(&l);}
     for(j=0;j<8;j++)for(k=0;k<3;k++)R_getl(&l);
   }
 }
 R_getl(&n);  /* get number of vertices in skeleton structure */
 if(n > 0){
   if(n == newvert){ /* if skeleton assignment is consitent with newvert */
     if((Skid=(long *)X__Malloc(n*(long)sizeof(long))) != NULL)jj=Skid;
   }
   for(i=0;i<n;i++){
     if(version > 2)R_getl(&s);
     else {R_getsht(&ss); s=(long)ss;}
     if(Skid != NULL)*jj++ = (long)s;
   }
 }
 return Skid;
}

typedef struct tVECTOR4tag {
 tDOUBLE x,y,z,w;
 BOOL   selected;
 char   pad[4];
} tvector4;

static long RenderReadNurbs(long ObjectID, long clen){
 DWORD dwRead;
 BOOL readit=TRUE;
 long i,j,k,N;
 nurbs *n,*Np;
 vector4 *p;
 tvector4 P;
 tDOUBLE tD;
//{ char ttt[256];
//sprintf(ttt,"size of prop %ld  vec4=%ld tvec4=%ld vec=%ld BOOL=%ld tD=%ld",
//sizeof(NurbsProperties),
//sizeof(vector4),sizeof(tvector4),
//sizeof(vector),
//sizeof(BOOL),sizeof(tDOUBLE));
//MessageBox(NULL,ttt,"Write",MB_OK);
//}
 ReadFile(fp,&N,sizeof(long),&dwRead,NULL);
 if(N == 0)return -1;
 if((Np=(nurbs *)X__Malloc(N*sizeof(nurbs))) == NULL)return -1;
 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,&tD,sizeof(tDOUBLE),&dwRead,NULL);
     n->kvU[i]=(double)tD;
   }
   for(i=0;i<n->numV + n->orderV; i++){
     ReadFile(fp,&tD,sizeof(tDOUBLE),&dwRead,NULL);
     n->kvV[i]=(double)tD;
   }
   for(i=0;i<n->numV; i++)
   for(j=0;j<n->numU; j++){
     ReadFile(fp,&P,sizeof(tvector4),&dwRead,NULL);
     p=&(n->points[i][j]);
     p->x=(double)P.x;
     p->y=(double)P.y;
     p->z=(double)P.z;
     p->w=(double)P.w;
   }
 }
 if(readit){
   Object[ObjectID].Nbase=Np;
   Object[ObjectID].NoNurbs=N;
 }
 return 0;
}

static void CompleteImageMapLoading(long ObjectID, char *objectfilename){
 // Load any outstanding image maps that haven been found as embedded maps
 // in the MFX file.
 int i,n,l,m;
 imap *Map;
 if((n=Object[ObjectID].NoMaps) > 0 &&
    (Map=Object[ObjectID].Mbase) != NULL){
   //if(debug != NULL)fprintf(debug,"\n",n);
   for(i=0;i<n;i++,Map++){
     //if(debug != NULL){fprintf(debug,"Getting Non Embedded Parts Map %ld Object[%s]\n",i,objectfilename); fflush(debug);}
     if(SetupImageMap(Map,objectfilename) != 1){
       // Map not loaded so drop the map - this action should never be done - each individual map should be switched out
       Render_Message(28,0,NULL);
       if((m=Object[ObjectID].NoFaces) > 0)for(l=0;l<m;l++){
         if(Object[ObjectID].Fbase[l].ffmap >= 0)/* map    */
          if(Object[ObjectID].Fbase[l].ffmap == i) /* this one */
             Object[ObjectID].Fbase[l].ffmap = -1;
       } /*  clear to no map */
     }
   }
 }
}

#define temp_image_name "OFX_R_$$"

static void LoadEmbededImageMaps(long ObjectID, long clen, char *objectfilename){
 HANDLE fq;
 char *buffer;
 char name[256],tempfile[256];
 long i,j,n,l,m,v,in_use,f_size;
 int id;
 DWORD dwRead,dwSize,dwWrite;
 imap *Map;
 R_getl(&n); if(n != Object[ObjectID].NoMaps){
   MessageBox(NULL,"Map reading error",NULL,MB_OK);
   R_getchunk(clen-4);
   return;
 }
 //if(debug != NULL)fprintf(debug,"\nLoading %ld embedded maps\n",n);
 if((n=Object[ObjectID].NoMaps) > 0 &&
    (Map=Object[ObjectID].Mbase) != NULL){
   for(i=0;i<n;i++,Map++){
   for(j=0;j<4;j++){ // four types of map
     R_getl(&v);     // version
     R_getl(&in_use);
     //if(debug != NULL)fprintf(debug,"Map %ld (of %ld) Image %ld  in-use=%ld\n",i+1,n,j,in_use);
     if(!in_use)continue;
     R_getl(&l);  // string name length
     R_getl(&f_size);  // file size
     ReadFile(fp,name,l+1,&dwRead,NULL);
     //if(debug != NULL)fprintf(debug,"Embed map %ld, (part %ld)  name [%s] length=%ld size= %ld\n",i,j,name,l,f_size);
     if((buffer=(unsigned char*)X__Malloc(f_size)) == NULL){
       R_getchunk(f_size);
       continue;
     }
     ReadFile(fp,buffer,f_size,&dwRead,NULL);
     id=IdentifyImageFileType(name);
     if(id < 0){
       MessageBox(NULL,"Bad Type",NULL,MB_OK);
     }
     if(!CheckSingleRenderImageMap(Map,name,objectfilename,tempfile,j)){
       if(id < 0){
// USE this for loading directly from the buffer // still TODO
//         LoadSingleRenderImageMapFromFile(buffer,Map,"ZZZZ",image_file_extensions[id]);
         goto FREEPOINT;
       }
       sprintf(tempfile,"%s%s%s",TempPath,temp_image_name,image_file_extensions[id]);
       // MessageBox(NULL,tempfile,"TempFile",MB_OK);
       //if(debug != NULL)fprintf(debug,"Temp file [%s]\n",tempfile);
       fq=CreateFile(tempfile,GENERIC_WRITE,FILE_SHARE_WRITE,NULL,CREATE_ALWAYS,
                    FILE_ATTRIBUTE_NORMAL,(HANDLE)NULL);
       if(fq == INVALID_HANDLE_VALUE){
         MessageBox(NULL,tempfile,"Bad Handle",MB_OK);
       }
       else{
         dwSize=f_size;
         if(WriteFile(fq,buffer,dwSize,&dwWrite,NULL) != 0 && dwWrite == dwSize){
           CloseHandle(fq);
           LoadSingleRenderImageMap(Map,name,objectfilename,tempfile,j);
           remove(tempfile);
         }
         else CloseHandle(fq);
       }
     }
     FREEPOINT: X__Free(buffer); 
   }
   }
 }
}

static short R_ReadImaps(long ObjectID, long clen, long frame, char *objectfilename,
                        char *str, BOOL new_type){
  unsigned char *buffer=NULL,*b;
  imap *temp_map,*Map;
  unsigned char t_colour[3];
  char brushmaptype,moziac,p,r,q,t;
  char fsurf[256],frefl[256],fbump[256],ftran[256],tempstr[256];
  long i,j,k,l,m,brushangle;
  long m_p,ff_p,fd_p,lf_p,
       m_r,ff_r,fd_r,lf_r,
       m_b,ff_b,fd_b,lf_b,
       m_t,ff_t,fd_t,lf_t;
  short s;
  buffer=(unsigned char *)X__Malloc(clen);
  if(buffer == NULL)return -1;
  ReadFile(fp,buffer,clen,&dwRead,NULL);
  b=buffer;
  j=GetLongFromBuffer(b); b+= 4;  /* read number of maps */
  if(j > 0){
    temp_map = (imap *)X__Malloc(j*sizeof(imap));
    if(temp_map == NULL){
      Render_Message(13,0,NULL);
      X__Free(buffer);
      return -1;
    }
    memset(temp_map,0,j*sizeof(imap));
    Object[ObjectID].Mbase=temp_map;
    Object[ObjectID].NoMaps=j;
    for(i=0;i<j;i++){
      Map=(temp_map+(long)i);
      Map->bLoadedS=FALSE; Map->bLoadedR=FALSE;
      Map->bLoadedB=FALSE; Map->bLoadedT=FALSE;
      Map->bAnimS=Map->bAnimR=Map->bAnimB=Map->bAnimT=FALSE;
      Map->map     = PLANE;
      Map->angle   = 1.0;
      Map->moziac  = NO;
      Map->p24R     = Map->p24G     = Map->p24B     = NULL;
      Map->p24Rrefl = Map->p24Grefl = Map->p24Brefl = NULL;
      Map->p24Rbump = Map->p24Gbump = Map->p24Bbump = NULL;
      Map->p24Rtran = Map->p24Gtran = Map->p24Btran = NULL;
      Map->p[0]=(double)GetLongFromBuffer(b); b+= 4;
      Map->p[1]=(double)GetLongFromBuffer(b); b+= 4;
      Map->p[2]=(double)GetLongFromBuffer(b); b+= 4;
      VECCOPY(Map->p,Map->pin)
      Map->x[0]=(double)GetLongFromBuffer(b); b+= 4;
      Map->x[1]=(double)GetLongFromBuffer(b); b+= 4;
      Map->x[2]=(double)GetLongFromBuffer(b); b+= 4;
      VECCOPY(Map->x,Map->xin)
      Map->y[0]=(double)GetLongFromBuffer(b); b+= 4;
      Map->y[1]=(double)GetLongFromBuffer(b); b+= 4;
      Map->y[2]=(double)GetLongFromBuffer(b); b+= 4;
      VECCOPY(Map->y,Map->yin)
      m_p =GetLongFromBuffer(b); b+= 4; b+= 12; // skip anim flags no longer used
      m_r =GetLongFromBuffer(b); b+= 4; b+= 12;
      m_b =GetLongFromBuffer(b); b+= 4; b+= 12;
      m_t =GetLongFromBuffer(b); b+= 4; b+= 12;
      l=GetLongFromBuffer(b); b+= 4; /* used by skeleton for br. assign. not used by renderer */
      l=GetLongFromBuffer(b); b+= 4; brushmaptype=(char)l;
      brushangle=GetLongFromBuffer(b); b+= 4;
      for(k=0;k<4;k++){
        m=GetLongFromBuffer(b); b+= 4; /* dump the brush lock info */
      }
      memcpy(tempstr,b,32); b+= 32;
      p = *b++;  // =1 => surface map present
      r = *b++;
      q = *b++;
      t = *b++;  // =1 => transparent map present     
      Map->kt = *b++;
      Map->pp=GetShortFromBuffer(b); b+= 2; /* these will be set to -1 */
      Map->rp=GetShortFromBuffer(b); b+= 2; /* if a map of this type   */
      Map->bp=GetShortFromBuffer(b); b+= 2; /* is not used in Material */
      b+=2;                                 /* no transparency slider  */
      if(t > 0)Map->tp=255; else Map->tp=0; // if there is a tansparency map we set fraction to max
      memcpy(t_colour,b,3); b+=3;  /* not used yet */
      memcpy(t_colour,b,3); b+=3;
      memcpy(t_colour,b,3); b+=3;  /* ------------ */
      memcpy(Map->kc,b,3); b+=3;   /* key colour   */
      memset(fsurf,0,256);   memcpy(fsurf,b,250); b+=256; 
      if((m=strlen(fsurf)) == 0 || m > 248)p=0; // dump the map - might be corrupt
      memset(frefl,0,256);   memcpy(frefl,b,250); b+=256;
      if((m=strlen(frefl)) == 0 || m > 248)r=0; // dump the map - might be corrupt
      memset(fbump,0,256);   memcpy(fbump,b,250); b+=256;
      if((m=strlen(fbump)) == 0 || m > 248)q=0; // dump the map - might be corrupt
      memset(ftran,0,256);   memcpy(ftran,b,250); b+=256;
      if((m=strlen(ftran)) == 0 || m > 248)t=0; // dump the map - might be corrupt
      if(new_type){
        b+= 4;  // version
        Map->bDecal=(BOOL)GetLongFromBuffer(b); b+= 4;
        Map->bShaded=(BOOL)GetLongFromBuffer(b); b+= 4;
        Map->bTiled=(BOOL)GetLongFromBuffer(b); b+= 4;
      }
      else{ // check to see if any face uses this and reqires NO tiling ??
        Map->bShaded=TRUE; 
        Map->bTiled=TRUE;   
        Map->bDecal=FALSE;
      }
      moziac=NO;
      if(brushmaptype == PLANE_MOZIAC)   { brushmaptype = PLANE;    moziac=YES;}
      if(brushmaptype == CYLINDER_MOZIAC){ brushmaptype = CYLINDER; moziac=YES;}
      if(p && m_p == ANIMBRUSH)Map->bAnimS=TRUE;
      if(r && m_r == ANIMBRUSH)Map->bAnimR=TRUE;
      if(q && m_b == ANIMBRUSH)Map->bAnimB=TRUE;
      if(t && m_t == ANIMBRUSH)Map->bAnimT=TRUE;
      if(p) strcpy(Map->filename,fsurf); else Map->pp = -1;
      if(r) strcpy(Map->frefl,frefl);    else Map->rp = -1;
      if(q) strcpy(Map->fbump,fbump);    else Map->bp = -1;
      if(t) strcpy(Map->ftran,ftran);    else Map->tp = -1;
      //if(debug != NULL)fprintf(debug,"Map Name [%s] present %ld, \n",Map->filename, Map->pp);
      //if(debug != NULL)fprintf(debug,"Map Name [%s] present %ld, \n",Map->frefl, Map->rp);
      //if(debug != NULL)fprintf(debug,"Map Name [%s] present %ld, \n",Map->fbump, Map->bp);
      //if(debug != NULL)fprintf(debug,"Map Name [%s] present %ld, \n",Map->ftran, Map->tp);
      Map->map=(short)brushmaptype;
      Map->angle=360.0/(double)brushangle;
      Map->moziac=moziac;
    }
  }
  X__Free(buffer);
  return 0;
}

static unsigned char *ReadShaderFromBuffer(long id, matl *Mat, unsigned char *b){
 char tempname[256],tempparam[512];  // must be long enough for longest !
 long version,active,in_use,ln,lp;
 version=GetLongFromBuffer(b); b+= 4;
 active =GetLongFromBuffer(b); b+= 4;
 in_use =GetLongFromBuffer(b); b+= 4;
 //if(debug != NULL)fprintf(debug,"Loading shader %ld active=%ld in_use=%ld\n",id,active,in_use);
 Mat->shaderID[id] = -1;  // NOT used until loaded
 if(in_use){
   ln=GetLongFromBuffer(b); b+= 4; // length of name
   lp=GetLongFromBuffer(b); b+= 4; // length of parameter list
   memcpy(tempname,b,ln+1);  b += ln+1;
   memcpy(tempparam,b,lp+1); b += lp+1;
   if(active && LoadExternalTexture(tempname,tempparam) == OK){
     Mat->shaderID[id]=Nshader-1;
     //if(debug != NULL)fprintf(debug,"Shader %ld loaded from [%s] is active\n"
     //     ,Nshader-1,tempname); 
   }
   //else if(debug != NULL)fprintf(debug,"Shader (active=%ld) not loaded\n",active);
 }
 return b;
}

static short R_ReadMaterial(long id, long ObjectID, long clen){
 long i,j,v,l,n;
 unsigned char *buffer=NULL,*b;
 matl *temp_mat,*Mat;
 buffer=(unsigned char *)X__Malloc(clen);
 if(buffer == NULL)return -1;
 ReadFile(fp,buffer,clen,&dwRead,NULL);
 b=buffer;
 n=GetLongFromBuffer(b); b+= 4;  /* read number of materials */
 //{char ttt[255]; sprintf(ttt,"Loading %ld materials",n); MessageBox(NULL,ttt,NULL,MB_OK);}
 if(n > 0){
   //if(debug != NULL)fprintf(debug,"Reading %ld materials\n",n);
   temp_mat = (matl *)X__Malloc(n*sizeof(matl));
   if(temp_mat == NULL){
     Render_Message(13,0,NULL);
     X__Free(buffer);
     return -1;
   }
   Object[ObjectID].Tbase=temp_mat;
   Object[ObjectID].NoMats=n;
   for(i=0;i<n;i++){
     Mat=(temp_mat+(long)i);
     v=GetLongFromBuffer(b); b+= 4; // version
     //if(debug!=NULL)fprintf(debug,"Material %ld [%s]\n",i,b); 
     b+=32; //skip name
     memcpy(Mat->color,b,3); b+= 3;
     memcpy(Mat->texco,b,3); b+= 3;
     b += 5*3;  // 5 colours to be used later
     l=GetLongFromBuffer(b); b+= 4;  Mat->gloss=min(15,l/255);
     l=GetLongFromBuffer(b); b+= 4;  Mat->refl=l;
     l=GetLongFromBuffer(b); b+= 4;  Mat->transp=l;
     l=GetLongFromBuffer(b); b+= 4;  if(l < 100)l=1000; Mat->refractive_index=l;   //1000 = 1.0
     l=GetLongFromBuffer(b); b+= 4;  Mat->bInternalShader=(BOOL)l;
     l=GetLongFromBuffer(b); b+= 4;  Mat->internalShaderID=l;
     for(j=0;j<3;j++){l=GetLongFromBuffer(b); b+= 4; Mat->ax.bo[j]=(double)l;}
     for(j=0;j<3;j++){l=GetLongFromBuffer(b); b+= 4; Mat->ax.bu[j]=(double)l;}
     for(j=0;j<3;j++){l=GetLongFromBuffer(b); b+= 4; Mat->ax.bv[j]=(double)l;}
     VECCOPY(Mat->ax.bo,Mat->ax.boin)
     VECCOPY(Mat->ax.bu,Mat->ax.buin)
     VECCOPY(Mat->ax.bv,Mat->ax.bvin)
     for(j=0;j<4;j++)b=ReadShaderFromBuffer(j,Mat,b);
     l=GetLongFromBuffer(b); b+= 4;  Mat->bSmooth=(BOOL)l;
     l=GetLongFromBuffer(b); b+= 4;  Mat->bShiny=(BOOL)l;
     l=GetLongFromBuffer(b); b+= 4;  Mat->bClear=(BOOL)l;
     l=GetLongFromBuffer(b); b+= 4;  Mat->bGlassEdge=(BOOL)l;
     l=GetLongFromBuffer(b); b+= 4;  Mat->bUseSurfaceMapping=(BOOL)l;
     for(j=0;j<16;j++){l=GetLongFromBuffer(b); b+= 4; Mat->params[j]=(unsigned char)l;}
     b += 16*4; // ignore the 16 pab lings
     //if(debug != NULL)fprintf(debug,"smooth=%ld shiny=%ld internal(%ld)ID=%ld\n",
     //   Mat->bSmooth,Mat->bShiny,Mat->bInternalShader,Mat->internalShaderID);
     //if(debug != NULL)fprintf(debug,"reflectivity=%ld transparency=%ld gloss=%ld\n",
     //   Mat->refl,Mat->transp,Mat->gloss);
     if(id > 1){ // for material versions > 1
       memcpy(Mat->other_properties,b,512); b+= 512;
       sscanf(Mat->other_properties,"%lf %lf %lf %lf %lf %lf",
       &(Mat->mmw_params[0]),&(Mat->mmw_params[1]),&(Mat->mmw_params[2]),
       &(Mat->mmw_params[3]),&(Mat->mmw_params[4]),&(Mat->mmw_params[5]));
     }
   }
 }
 X__Free(buffer);
 return 0;
}

static short R_ReadFaces(long ObjectID, long  clen, int version){
  long i,sf;
  long mm;
  unsigned char texture,brush,pad,attrib;
  unsigned char *buffer=NULL,*b;
  face   *f;
  if     (version == 0)newface=clen/18;
  else if(version == 1)newface=clen/24;
  else                 newface=clen/20;
  if(newface == 0)return -1;
  sf=sizeof(face);
  mm=newface*(long)sf;
  Object[ObjectID].Fbase=(face  *)X__Malloc(mm);
  Object[ObjectID].NoFaces=newface;
  f=Object[ObjectID].Fbase;
  if(f == NULL){Render_Message(9,0,NULL); return -1;}
  buffer=(unsigned char *)X__Malloc(clen);
  if(buffer == NULL)return -1;
  ReadFile(fp,buffer,clen,&dwRead,NULL);
  b=buffer;
  for(i=0;i<newface;i++){
    if(version == 0){
      f->V[0]=(UNSIGNED)GetUshortFromBuffer(b); b+= 2;
      f->V[1]=(UNSIGNED)GetUshortFromBuffer(b); b+= 2;
      f->V[2]=(UNSIGNED)GetUshortFromBuffer(b); b+= 2;
    }
    else{
      f->V[0]=(UNSIGNED)GetLongFromBuffer(b); b+= 4;
      f->V[1]=(UNSIGNED)GetLongFromBuffer(b); b+= 4;
      f->V[2]=(UNSIGNED)GetLongFromBuffer(b); b+= 4;
    }
    memcpy(f->color,b,3); b+=3;
    if(version == 2){
      f->bShiny = FALSE;
      f->bSmooth= *b++;
      f->ffmat   = GetShortFromBuffer(b); b+= 2;
      f->ffmap   = GetShortFromBuffer(b); b+= 2;
    }
    else{ // old face map attributes now done through material
      *b++;   *b++;  *b++; // spec trans refl
      attrib = *b++;       // attrib
      *b++;                // param 
      f->ffmap   = (short)(*b++);
      f->ffmat   = -1;  // No material for old faces
      if(attrib & 0x80)f->bSmooth=TRUE; else f->bSmooth=FALSE;
      if(attrib & 0x20)f->bShiny=TRUE; else f->bShiny=FALSE;
      if(!(attrib & 0x40))f->ffmap = -1;  // NO image map
      *b++;   *b++;   *b++; // shader - axis - pad (ignored)
    }
    f->bFmc=FALSE;
    f->pn[0][0]=0.0; f->pn[0][1]=0.0; f->pn[0][2]=0.0;
    f->pn[1][0]=0.0; f->pn[1][1]=0.0; f->pn[1][2]=0.0;
    f->pn[2][0]=0.0; f->pn[2][1]=0.0; f->pn[2][2]=0.0;
    f->n[0]=0.0; f->n[1]=0.0; f->n[2]=0.0;
    f->c=0.0;
    f++;
  }
  X__Free(buffer);
  return 0;
}

static short R_ReadVertices(long ObjectID, long clen){
  vertex   *v;
  long i,mm,sv;
  unsigned char *buffer=NULL,*b;
  newvert=clen/12;
  if(newvert == 0)return -1;
  sv=sizeof(vertex);
  mm=newvert*(long)sv;
  if(newvert > 65535L && sizeof(UNSIGNED) < 4){
    Render_Message(16,0,NULL);
    return -1;
  }
  Object[ObjectID].Vbase=(vertex *)X__Malloc(mm);
  Object[ObjectID].NoVertices=newvert;
  v=Object[ObjectID].Vbase;
  if(v == NULL){
    Render_Message(9,0,NULL);
    return -1;
  }
  buffer=(unsigned char *)X__Malloc(clen);
  if(buffer == NULL)return -1;
  ReadFile(fp,buffer,clen,&dwRead,NULL);
  b=buffer;
  for(i=0;i<newvert;i++){
    v->p[0]=(double)GetLongFromBuffer(b); b+= 4;
    v->p[1]=(double)GetLongFromBuffer(b); b+= 4;
    v->p[2]=(double)GetLongFromBuffer(b); b+= 4;
    v->x=0; v->y=0; // mapping coords
    v->u=0; v->v=0; // mapping coords
    v++;
  }
  X__Free(buffer);
  return 0;
}

static short R_ReadVertText(long ObjectID, long clen, BOOL vtx2){
  vertex *v;
  long i,n,xx,id;
  unsigned char *buffer=NULL,*b;
  n=clen/12;
  i=Object[ObjectID].NoVertices;
  if(n == 0)return 0;
  if(n > i)return -1;
  buffer=(unsigned char *)X__Malloc(clen);
  if(buffer == NULL)return -1;
  ReadFile(fp,buffer,clen,&dwRead,NULL);
  b=buffer;
  v=Object[ObjectID].Vbase;
  for(i=0;i<n;i++){
    id=GetLongFromBuffer(b); b+= 4;
    if(vtx2)id=i;
    xx=GetLongFromBuffer(b); b+= 4; v[id].u=(double)xx*0.000001;
    xx=GetLongFromBuffer(b); b+= 4; v[id].v=(1.0 - (double)xx*0.000001); // to match ordinary map
  }
  X__Free(buffer);
  return 0;
}

static short R_ReadFaceMapping(long ObjectID, long clen){
  long i,j,nn,ix,iy;
  face *f;
  unsigned char *buffer=NULL,*b;
  nn=clen/28;
  i=Object[ObjectID].NoFaces;
  if(nn > i)return -1;
  if(nn == 0)return 0;
  buffer=(unsigned char *)X__Malloc(clen);
  if(buffer == NULL)return -1;
  ReadFile(fp,buffer,clen,&dwRead,NULL);
  b=buffer;
  f=Object[ObjectID].Fbase;
  for(i=0;i<nn;i++){
    f->bFmc=(BOOL)GetLongFromBuffer(b); b+= 4;
    for(j=0;j<3;j++){
      ix=GetLongFromBuffer(b); b+= 4;
      iy=GetLongFromBuffer(b); b+= 4;
      f->uu[j]=(double)ix*0.000001;
      f->vv[j]=(1.0 - (double)iy*0.000001); // to match OFX mapping scheme
      f->ww[j]=0.5;
      //if(debug != NULL)fprintf(debug,"Face %ld Mapped=%ld V %ld x=%lf y=%lf\n",i,f->bFmc,j,f->uu[j],f->vv[j]);
    }
    f++;
  }
  X__Free(buffer);
  return 0;
}


long FindNumberVertices(char *ofile, long *nvs){
 long CHUNKsize,FORMsize;
 char FileName[256];
 strcpy(FileName,ofile);
 *nvs = -1;
 if((fp=GetRenderRelativeHandle((char *)strlwr(FileName),NULL,NULL))
       == INVALID_HANDLE_VALUE){
   return 0;
 }
 ReadFile(fp,str,4,&dwRead,NULL);
 if (dwRead != 4 || strcmp(str,"FORM") != 0)goto end;
 ReadFile(fp,&FORMsize,4,&dwRead,NULL);
 ReadFile(fp,str,4,&dwRead,NULL);
 if (dwRead != 4 || (strcmp(str,"OFXM") != 0 && strcmp(str,"AAPO") != 0))goto end;
loop:
 if(!ReadFile(fp,str,4,&dwRead,NULL))goto end;
 if(dwRead != 4 )goto end;
 if(R_getl(&CHUNKsize) != 1)goto end;
 if(strcmp(str,"VERT") == 0){
   *nvs=CHUNKsize/12;
   goto end;
 }
 else R_getchunk(CHUNKsize);
 goto loop;
end:
 CloseHandle(fp);
 return 1;
}

long R_LoadObject(long ObjectID, char *FileName, long frame, short robo, 
                  double robo_ratio,
                   char *robo_file1, char *robo_file2){
 long CHUNKsize,FORMsize,l;
 long nsk,*Skids=NULL;
 skel *Skeleton=NULL;
 // All object values set to ZERO or NULL before reading 
 if((fp=GetRenderRelativeHandle((char *)strlwr(FileName),NULL,NULL))
       == INVALID_HANDLE_VALUE){
   Render_Message(30,1,FileName);
   return 0;
 }
 newface=0; newvert=0; nsk=0;
 ReadFile(fp,str,4,&dwRead,NULL);
 //if(debug != NULL)fprintf(debug,"Reading Model from[%s]\n",FileName);
 if(strcmp(str,"FORM") != 0){
   Render_Message(21,1,NULL);
   return 0;
 }
 ReadFile(fp,&FORMsize,sizeof(long),&dwRead,NULL);
 ReadFile(fp,str,4,&dwRead,NULL);
 //MessageBox(NULL,str,"ReadingChunk",MB_OK);
 // allow old models
 if(dwRead != 4 || (strcmp(str,"OFXM") != 0  && strcmp(str,"AAPO") != 0)){
   Render_Message(22,1,NULL);
   return 0;
 }
 Object[ObjectID].Centre[0]=0;   /* initialize in case no axis */
 Object[ObjectID].Centre[1]=0;   /* present */
 Object[ObjectID].Centre[2]=0;

 Object[ObjectID].Abase.bo[0]=0;
 Object[ObjectID].Abase.bo[1]=0;
 Object[ObjectID].Abase.bo[2]=0;
 Object[ObjectID].Abase.bu[0]=UNIT;
 Object[ObjectID].Abase.bu[1]=0;
 Object[ObjectID].Abase.bu[2]=0;
 Object[ObjectID].Abase.bv[0]=0;
 Object[ObjectID].Abase.bv[1]=UNIT;
 Object[ObjectID].Abase.bv[2]=0;
loop:
 if(!ReadFile(fp,str,4,&dwRead,NULL))goto end;
 //MessageBox(NULL,str,"Reading Chunk",MB_OK);
 if(dwRead != 4)goto end;
 if (R_getl(&CHUNKsize) != 1)goto end;
 if     (strcmp(str,"VERT") == 0){if(R_ReadVertices(ObjectID,CHUNKsize)       < 0)return -1;}
 else if(strcmp(str,"VTEX") == 0){if(R_ReadVertText(ObjectID,CHUNKsize,FALSE) < 0)return -1;}
 else if(strcmp(str,"VTX2") == 0){if(R_ReadVertText(ObjectID,CHUNKsize,TRUE)  < 0)return -1;}
 else if(strcmp(str,"SFCE") == 0){if(R_ReadFaces(ObjectID,CHUNKsize,0)        < 0)return -1;}
 else if(strcmp(str,"LFCE") == 0){if(R_ReadFaces(ObjectID,CHUNKsize,1)        < 0)return -1;}
 else if(strcmp(str,"NFCE") == 0){if(R_ReadFaces(ObjectID,CHUNKsize,2)        < 0)return -1;}
 else if(strcmp(str,"FTEX") == 0){if(R_ReadFaceMapping(ObjectID,CHUNKsize)    < 0)return -1;}
 else if(strcmp(str,"AXIS") == 0){if(R_ReadAxis(ObjectID,CHUNKsize)           < 0)return -1;}
 else if(strcmp(str,"IMAP") == 0)R_ReadImaps(ObjectID,CHUNKsize,frame,FileName,str,FALSE);
 else if(strcmp(str,"IMA2") == 0)R_ReadImaps(ObjectID,CHUNKsize,frame,FileName,str,TRUE);
 else if(strcmp(str,"EMAP") == 0)LoadEmbededImageMaps(ObjectID,CHUNKsize,FileName);
 else if(strcmp(str,"MTL1") == 0)R_ReadMaterial(1,ObjectID,CHUNKsize);
 else if(strcmp(str,"MTL2") == 0)R_ReadMaterial(2,ObjectID,CHUNKsize);
 else if(strcmp(str,"SK04") == 0 && robo == YES)Skids=RenderReadSkeleton(CHUNKsize,4,&Skeleton,&nsk);
 else if(strcmp(str,"SK03") == 0 && robo == YES)Skids=RenderReadSkeleton(CHUNKsize,3,&Skeleton,&nsk);
 else if(strcmp(str,"SK02") == 0 && robo == YES)Skids=RenderReadSkeleton(CHUNKsize,2,&Skeleton,&nsk);
 else if(strcmp(str,"SK01") == 0 && robo == YES)Skids=RenderReadSkeleton(CHUNKsize,1,&Skeleton,&nsk);
 else if(strcmp(str,"SKEL") == 0 && robo == YES)Skids=RenderReadSkeleton(CHUNKsize,0,&Skeleton,&nsk);
 else if(strcmp(str,"NURB") == 0){
   if(RenderReadNurbs(ObjectID,CHUNKsize) < 0)return -1;
   MeshNurbsSurfaces(ObjectID);
 }
 else if(strcmp(str,"UNIT") == 0){
   long dummy;
   char dummys[16];
   R_getl(&dummy); ruler_length=(double)dummy;
   ReadFile(fp,dummys,8,&dwRead,NULL);
   R_getl(&dummy);   R_getl(&dummy);   R_getl(&dummy);
   R_getl(&dummy);   R_getl(&dummy);   R_getl(&dummy); /* don't use : is relative ruler */
 }
 else R_getchunk(CHUNKsize);
 goto loop;
end:
 CloseHandle(fp);
 CompleteImageMapLoading(ObjectID,FileName);
 Object[ObjectID].Skeleton=Skeleton;
 Object[ObjectID].Skids=Skids;
 Object[ObjectID].NoSkeleton=nsk;
 return 1;
}

void  R_getchunk(long clen){
 SetFilePointer(fp,clen,NULL,FILE_CURRENT);
}

static short R_ReadAxis(long ObjectID, long clen){
 long j;
 R_getl(&j); Object[ObjectID].Centre[0]=j; /* origin of Object (in object coords */
 R_getl(&j); Object[ObjectID].Centre[1]=j;
 R_getl(&j); Object[ObjectID].Centre[2]=j;
 R_getl(&j); Object[ObjectID].Abase.bo[0]=j;  /* shader axis point */
 R_getl(&j); Object[ObjectID].Abase.bo[1]=j;
 R_getl(&j); Object[ObjectID].Abase.bo[2]=j;
 R_getl(&j); Object[ObjectID].Abase.bu[0]=j;  /* texture axis off x */
 R_getl(&j); Object[ObjectID].Abase.bu[1]=j;
 R_getl(&j); Object[ObjectID].Abase.bu[2]=j;
 R_getl(&j); Object[ObjectID].Abase.bv[0]=j;  /* texture axis off y */
 R_getl(&j); Object[ObjectID].Abase.bv[1]=j;
 R_getl(&j); Object[ObjectID].Abase.bv[2]=j;
 VECCOPY(Object[ObjectID].Abase.bo,Object[ObjectID].Abase.boin)
 VECCOPY(Object[ObjectID].Abase.bu,Object[ObjectID].Abase.buin)
 VECCOPY(Object[ObjectID].Abase.bv,Object[ObjectID].Abase.bvin)
 return 0;
}


#define EPSILON 1.0e-6

void InvertRotationMatrix(double T[4][4], double t[4][4]){
 int i,j;
 double a[3][3];
 double det;
 R_null_transform(t);
 for(i=0;i<3;i++)for(j=0;j<3;j++)a[i][j]=T[i][j];
 det=a[0][0]*(a[1][1]*a[2][2] - a[2][1]*a[1][2])
    -a[0][1]*(a[1][0]*a[2][2] - a[2][0]*a[1][2])
    +a[0][2]*(a[1][0]*a[2][1] - a[2][0]*a[1][1]);
 if(fabs(det) < 1.e-10)return;
 det = 1.0/det;
 t[0][0] = +(a[1][1]*a[2][2] - a[2][1]*a[1][2])*det;
 t[1][0] = -(a[1][0]*a[2][2] - a[2][0]*a[1][2])*det;
 t[2][0] = +(a[1][0]*a[2][1] - a[2][0]*a[1][1])*det;
 t[0][1] = -(a[0][1]*a[2][2] - a[2][1]*a[0][2])*det;
 t[1][1] = +(a[0][0]*a[2][2] - a[2][0]*a[0][2])*det;
 t[2][1] = -(a[0][0]*a[2][1] - a[2][0]*a[0][1])*det;
 t[0][2] = +(a[0][1]*a[1][2] - a[1][1]*a[0][2])*det;
 t[1][2] = -(a[0][0]*a[1][2] - a[1][0]*a[0][2])*det;
 t[2][2] = +(a[0][0]*a[1][1] - a[1][0]*a[0][1])*det;
}

#ifdef _SUNSTYLE
#else
static void MatrixToQuaternion(double m[4][4], quaternion q){
#endif
 double w4,x2;
 q[0]=0.25*(1.0+m[0][0]+m[1][1]+m[2][2]);
 if(q[0] > EPSILON){
   q[0]=sqrt(q[0]);
   w4=1.0/(4.0*q[0]);
   q[1]=(m[1][2]-m[2][1])*w4;
   q[2]=(m[2][0]-m[0][2])*w4;
   q[3]=(m[0][1]-m[1][0])*w4;
 }
 else{
   q[0]=0.0;
   q[1]= -0.5*(m[1][1]+m[2][2]);
   if(q[1] > EPSILON){
     q[1]=sqrt(q[1]);
     x2=1.0/(2.0*q[1]);
     q[2]=m[0][1]*x2;
     q[3]=m[0][2]*x2;
   }
   else{
     q[1]=0.0;
     q[2]=0.5*(1.0-m[2][2]);
     if(q[2] > EPSILON){
       q[2]=sqrt(q[2]);
       q[3]=m[1][2]/(2.0*q[2]);
     }
     else{
       q[2]=0.0;
       q[3]=1.0;
     }
   }
 }
 return;
}

static void QuaternionToMatrix(quaternion q, double m[4][4]){
 double w,x,y,z,x2,y2,z2;
 w=q[0]; x=q[1]; y=q[2]; z=q[3]; x2=x*x; y2=y*y; z2=z*z;
 m[0][0]=1.0-2*y2-2*z2; m[0][1]=2*x*y+2*w*z;   m[0][2]=2*x*z-2*w*y;
 m[1][0]=2*x*y-2*w*z;   m[1][1]=1.0-2*x2-2*z2; m[1][2]=2*y*z+2*w*x;
 m[2][0]=2*x*z+2*w*y;   m[2][1]=2*y*z-2*w*x;   m[2][2]=1.0-2*x2-2*y2;
 m[3][3]=1.0; m[0][3]=m[1][3]=m[2][3]=m[3][0]=m[3][1]=m[3][2]=0.0;
 return;
}

static void Slerp(double mr, quaternion q1, quaternion q2, quaternion q){
 double sum,beta1,beta2,theta;
 sum=q1[0]*q2[0]+q1[1]*q2[1]+q1[2]*q2[2]+q1[3]*q2[3];
 if(sum < 0.0)sum=0.0;
 if(sum > 1.0)sum=1.0;
 theta=acos(sum);
 if(theta < EPSILON){ beta1=1.0-mr; beta2=mr;}
 else{
  beta1=sin((1.0-mr)*theta)/sin(theta);
  beta2=sin(mr*theta)/sin(theta);
 }
 q[0]=beta1*q1[0]+beta2*q2[0];
 q[1]=beta1*q1[1]+beta2*q2[1];
 q[2]=beta1*q1[2]+beta2*q2[2];
 q[3]=beta1*q1[3]+beta2*q2[3];
}

static int  nSkeleton;
static skel *Skeleton;

static void ApplyTransformToChildren(int id, double T[4][4]){
 static double x,y,z;
 static double sst[4][4],t1[4][4],t2[4][4];
 int i;
 for(i=1;i<nSkeleton;i++){ /* must start at one since root is never a child */
   if(Skeleton[i].id == id){
     R_tram(t1,-(Skeleton+id)->p[0],-(Skeleton+id)->p[1],-(Skeleton+id)->p[2]);
     R_m4by4((Skeleton+i)->Q,t1,t2);
     R_tram(t1, (Skeleton+id)->p[0], (Skeleton+id)->p[1], (Skeleton+id)->p[2]);
     R_m4by4(t1,t2,sst);
     R_m4by4(T,sst,Skeleton[i].T);
     ApplyTransformToChildren(i,Skeleton[i].T);
   }
 }
 return;
}

static void InterpolateRobot(double mr, long n, skel *sk1, skel *sk2){
 int i;
 quaternion q,q1,q2;
 nSkeleton=n;
 Skeleton=sk1;
 if(mr < 1.0){
   /* interpopate rotation matrices using Quaternion tweening */
   /* this interpolation always from last frame rotation as origin */
   quaternion Qi={1.0,0.0,0.0,0.0};
   double Q[4][4],Ri[4][4];
   for(i=0;i<nSkeleton;i++){
     InvertRotationMatrix((sk2+i)->R,Ri);
     R_m4by4((Skeleton+i)->R,Ri,Q);
     MatrixToQuaternion(Q,q2);
     Slerp(mr,Qi,q2,q);
     QuaternionToMatrix(q,Q);
     R_m4by4(Q,(sk2+i)->R,(Skeleton+i)->Q);   // Q is rotation applied to bone "i" to be applied about the parent node.
   }
 }
 else{
   for(i=0;i<nSkeleton;i++)R_c4to4((Skeleton+i)->R,(Skeleton+i)->Q);
 }
 ApplyTransformToChildren(0,Skeleton[0].T);
 return;
}

void RenderTransformToRobot(long O,
                            long *Skid, skel *Skel, double mr,
                            char *robo_f1, char *robo_f2){
  long i,j,n1=0,n2=0;
  FILE *frobot;
  skel *sk1=NULL,*sk2=NULL;
  vertex *v;
  double x1,y1,z1;
  if((frobot = fopen(robo_f1,"r")) != NULL){
    fscanf(frobot,"%ld\n",&n1);
    if(n1 > 0){  /* sk1 is the Robot  sk2 is version is moving from */
      if((sk1=Skel) == NULL)goto FINISHED;
      for(i=0;i<n1;i++){
        R_null_transform(sk1->R);
        R_null_transform(sk1->Q);
        R_null_transform(sk1->T);
        for(j=0;j<4;j++)fscanf(frobot,GET_MATX,
         &sk1[i].R[j][0], &sk1[i].R[j][1],
         &sk1[i].R[j][2], &sk1[i].R[j][3]);
      }
    }
    fclose(frobot);
  }
  if((frobot = fopen(robo_f2,"r")) != NULL){
    fscanf(frobot,"%ld\n",&n2);
    if(n2 > 0){
      if((sk2 = (skel *)X__Malloc(n2*(long)sizeof(skel))) == NULL)
           goto FINISHED;
      for(i=0;i<n2;i++){
        R_null_transform(sk2->R);
        R_null_transform(sk2->Q);
        R_null_transform(sk2->T);
        for(j=0;j<4;j++)fscanf(frobot,GET_MATX,
         &sk2[i].R[j][0], &sk2[i].R[j][1],
         &sk2[i].R[j][2], &sk2[i].R[j][3]);
      }
    }
    fclose(frobot);
  }
  if(n1 != n2 || n1 == 0 || n2 == 0)goto FINISHED;
  InterpolateRobot(mr,n1,sk1,sk2);
  v=Object[O].Vbase;
  for(i=0;i<Object[O].NoVertices;i++){
    R_m4by1(sk1[Skid[i]].T,v[i].p[0],v[i].p[1],v[i].p[2],&x1,&y1,&z1);
    v[i].p[0]=x1;
    v[i].p[1]=y1;
    v[i].p[2]=z1;
  }
  FINISHED:
  if(sk2 != NULL)X__Free(sk2);
  return;
}

static double GetBoneRelativeDistance(vector v, vector s, vector sp, vector d, double len, double *l, vector r){
 vector dp,q;
 double ll;
 VECSUB((double)v,(double)s,dp)
 ll=DOT(dp,d);
 if(ll < 0){ // closest point is behind start
   *l=0.0;     // fraction of bone to offset vector
   //*l=-0.1;     // fraction of bone to offset vector  //RSFx
   VECSUB((double)v,(double)s,r)
 }
 else if(ll > len){ // closest point is beyond end
   *l=1.0;
   //*l=1.1;   //RSFx
   VECSUB((double)v,(double)sp,r)
 }
 else{
   *l=ll/len;
   VECSUM((double)s,ll*d,q)
   VECSUB((double)v,q,r)
 }  
 return sqrt(DOT(r,r));  // closest distance of v to bone from (s to sp) 
} 

static void ApplyParentDeform(skel *s, skel *sp, vector p, vertex *v){//get pskp  (p is suggested position
  double dist,lab,h,h1;
  vector d,r;
  VECSUB(sp->p,s->p,d)
  VECSCALE(1.0/s->bLength,d,d);
  dist=GetBoneRelativeDistance(v->p,s->p,sp->p,d,s->bLength,&lab,r);  // original vertex's relative position
  h=1.0-lab; // lab is 0 at parent/child junction
  if(h < 0.0 || h > 1.0){
    if(dist > s->wrange)h=0.0;
    else h=(dist/s->wrange)*s->weight;
  }
  else h=h*h*s->weight;
  h1=1.0-h;
  VECSUM(h*p,h1*(v->p),v->pskp)  //this deforms the parent vertex
  v->bskp=TRUE;
}
static void ApplyChildDeform(skel *s, skel *sp, vector p, vertex *v){//get pskc (p is 
  double dist,lab,h,h1;
  vector d,r;
  VECSUB(sp->p,s->p,d)
  VECSCALE(1.0/s->bLength,d,d);
  dist=GetBoneRelativeDistance(v->p,s->p,sp->p,d,s->bLength,&lab,r);  // original vertex's relative position
  h=lab; // lab is 1 at parent/child junction
  if(h < 0.0 || h > 1.0){
    if(dist > s->wrange*ruler_length)h=0.0;
    else h=(dist/(s->wrange*ruler_length))*s->weight;
  }
  else h=h*h*s->weight;  // use a Zero Weight to exclude this bone or reduce its influence
  h1=1.0-h;
  VECSUM(h*p,h1*(v->p),v->pskc)  //this deforms the parent vertex
  v->bskc=TRUE;
}


void RenderRubberBones(long O, int nSk, long *Skid, skel *Skeleton){
 // Skid identifiles to which skeleton node the vertex belongs
 // Skeleton is the obkject's skeleton
 int i,j,pid,ppid;
 double x,y,z;
 double Q[4][4],Qi[4][4],t1[4][4],t2[4][4];
 vector p;
 vertex *v;
 // start by transforming skeleton
 for(i=1;i<nSk;i++){
   VECSUB((Skeleton+((Skeleton+i)->id))->p,(Skeleton+i)->p,p)
   (Skeleton+i)->bLength=sqrt(DOT(p,p)); // length of bone 
   R_m4by1((Skeleton+i)->T,(Skeleton+i)->p[0],(Skeleton+i)->p[1],(Skeleton+i)->p[2],&x,&y,&z);
   (Skeleton+i)->p[0]=x; (Skeleton+i)->p[1]=y; (Skeleton+i)->p[2]=z;
   Skeleton->weight=min(1.0,Skeleton->weight);
 }
 v=Object[O].Vbase;
 for(j=0;j<Object[O].NoVertices;j++)v[j].bskc=v[j].bskp=FALSE;
 // apply model by deforming the mesh around bone i and its parent by applying weighted Q(i) to parent and q-1(i) to (i).
 for(i=1;i<nSk;i++){
   pid=Skeleton[i].id;
   R_c4to4(Skeleton[i].Q,Q);
   for(j=0;j<3;j++)Q[3][j]=Q[j][3]=0.0; Q[3][3]=1.0;
   InvertRotationMatrix(Q,Qi);
   R_tram(t1,-(Skeleton+pid)->p[0],-(Skeleton+pid)->p[1],-(Skeleton+pid)->p[2]);
   R_m4by4(Q,t1,t2);
   R_tram(t1, (Skeleton+pid)->p[0], (Skeleton+pid)->p[1], (Skeleton+pid)->p[2]);
   R_m4by4(t1,t2,Q);  // transform parent vertices by rotating round parent end of bone
   R_tram(t1,-(Skeleton+pid)->p[0],-(Skeleton+pid)->p[1],-(Skeleton+pid)->p[2]);
   R_m4by4(Qi,t1,t2);
   R_tram(t1, (Skeleton+pid)->p[0], (Skeleton+pid)->p[1], (Skeleton+pid)->p[2]);
   R_m4by4(t1,t2,Qi);  // transform vertices by rotating round parent end of bone by inverse transform
//fprintf(debug,"Bone %d parent %d\nRotation Matrix\n",i,pid);
//for(j=0;j<4;j++)fprintf(debug,"%8.3f %8.3f %8.3f %8.3f\n", Skeleton[i].Q[j][0], Skeleton[i].Q[j][1], Skeleton[i].Q[j][2], Skeleton[i].Q[j][3]);
//fprintf(debug,"Transform Matrix\n");for(j=0;j<4;j++)fprintf(debug,"%8.3f %8.3f %8.3f %8.3f\n",Q[j][0],Q[j][1],Q[j][2],Q[j][3]);
   for(j=0;j<Object[O].NoVertices;j++){
     if(Skid[j] == pid){ // apply deform to parent bone
       ppid=(Skeleton+pid)->id; // parent's parent ID
       R_m4by1(Q,v[j].p[0],v[j].p[1],v[j].p[2],&p[0],&p[1],&p[2]);
       ApplyParentDeform((Skeleton+pid),(Skeleton+ppid),p,(v+j)); // p is new postion of vertex (v+j)
     }
     else if(Skid[j] == i){// child (this bone)
       R_m4by1(Qi,v[j].p[0],v[j].p[1],v[j].p[2],&p[0],&p[1],&p[2]);
       ApplyChildDeform((Skeleton+i),(Skeleton+pid),p,(v+j));
     }
   }
 }
 // all new positions found from blend
 for(i=0;i<Object[O].NoVertices;i++){
   if(Skid[i] > 0) { // not the root
     if(v[i].bskp && v[i].bskc){ 
       v[i].p[0]=0.5*(v[i].pskp[0]+v[i].pskc[0]);
       v[i].p[1]=0.5*(v[i].pskp[1]+v[i].pskc[1]);
       v[i].p[2]=0.5*(v[i].pskp[2]+v[i].pskc[2]);
     }
     else if(v[i].bskc)VECCOPY(v[i].pskc,v[i].p)
     else if(v[i].bskp)VECCOPY(v[i].pskp,v[i].p)
   }
 }
 for(i=1;i<nSk;i++){ // put back the skeleton
   VECCOPY((Skeleton+i)->pcopy,(Skeleton+i)->p)
 }
 return;
}