3DSCON2.C

Go to the documentation of this file.

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

/* 3DSCON2.C     revised 3DCON model loader - code uses 3DSFTK library and some of its code */

#define MODULE_SAPC

#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <windows.h>

#define  _DSCRUCT_SUB 1

#include "mstruct.h"
#include "dstruct.h"

#include "3dstype.h"
#include "3dsprim.h"
#include "3dserr.h"
#include "chunkinf.h"
#include "3dsftkst.h"
#include "3dsutil.h"
#include "dumpchnk.h"
#include "chunk3ds.h"
#include "3dsmatr.h"
#include "kfutils.h"

#include "3dscon.h"

extern HWND      dlg;
extern HWND      hWndParent;
extern HINSTANCE hInstance;

extern BOOL CALLBACK DlgProcScale(HWND hwnd,UINT msg,WPARAM wparam,LPARAM lparam);
extern BOOL CALLBACK DlgProc(HWND hwnd,UINT msg,WPARAM wparam,LPARAM lparam);

extern void UpdateProgress(FILE *);
extern int (*X__pri)(const char *,...);

#define DOS386
#define _X__FAR
#define PI  3.1415926

#define DEFAULT_SCALE (1024.0*8.0*2.0)

#ifndef min
#define min(a,b)  ( ((a) < (b)) ? (a) : (b) )
#endif
#ifndef max
#define max(a,b)  ( ((a) > (b)) ? (a) : (b) )
#endif

double scale_3ds;
int silent_3ds;
double gmax[3],gmin[3],gcentre[3];

static long3ds DumpLevel3ds = 2;
static int FirstVertex = -1, FirstFace = -1, CurrentMaterial = -1, CurrentImageMap = -1, CurrentImageMapType = -1;
static int ObjectFirstVertex = -1, ObjectFirstFace = -1;
static int ActiveMaterial= -1, ActiveImageMap = -1;
static int CurrentVertices=-1;
static char CurrentImageMapFile[256]="";
static char CurrentObjectName[256]="";

typedef struct tagEXTRAVERTEX3DS {
 int   *adj;  // list of vertices adjaent to this one
 int   n;  // number of adjavent vertices
} extravertex3DS;

static void mes3ds(char *s){
// if(silent_3ds)return;
// X__pri("%s",s);
}

static void InsertInVertexList(FILE *outfile, long vi, long  vj){
 long i,j,id;
 int n,*adj;
 extravertex3DS *vip,*vjp;
 id=(MainVp+vi)->id;
 //fprintf(outfile,"Vertex %d  linked to  %d",vi,vj); 
 if(id == 0){ // no exta data structure yet - so create one.
  (MainVp+vi)->id=id=(long)(malloc(sizeof(extravertex3DS)));
   vip=(extravertex3DS *)id;
   vip->adj=NULL;
   vip->n=0;
   //fprintf(outfile," NEW (no adjacenty yet)" );
 }
 else{
   vip=(extravertex3DS *)id;
  //fprintf(outfile," Currently %d adjacent ",vip->n );
 } 
 //fprintf(outfile,"\n");
 if(vip->n > 0){
   for(i=0;i<vip->n;i++){
     if(vip->adj[i] == vj){
       //fprintf(outfile,"%d is already in the %d list\n",vj,vi); 
       return;  // "vj" is already adjacent to "vi"
     }
   }
 }
 vjp=(extravertex3DS *)((MainVp+vj)->id);
 if(vjp != NULL && vjp->n > 0){
   //fprintf(outfile,"VJ(%d) has a list of %d entries ",vj,vjp->n);
   for(j=0;j<vjp->n;j++){
     if(vjp->adj[j] == vi){
       //fprintf(outfile," and VI is in it");
       return; //"vi" is already adjacent to "vj" and in its connection list
     }
   }
   //fprintf(outfile,"\n");   
 }
 if(vip->n == 0){ // allocate space to add connection
   if((vip->adj = (int *)malloc((vip->n + 1)*sizeof(int))) == NULL){
     mes3ds("out of memory\n");  return;
   }
 }
 else{
   if((vip->adj = (int *)realloc(vip->adj,(vip->n + 1)*sizeof(int))) == NULL){
     mes3ds("out of memory\n");  return;
   }
 }
 vip->adj[vip->n] = vj;  // "vj" is added to the connection list for "vi"
 (vip->n)++;
 //fprintf(outfile,"Making edge  IV->VJ %d  -> %d adding %d(VJ) to the %d(VI)  list now with %d entries \n",vi,vj, vj,vi,vip->n);
 CreateEdge(vi,vj);  // make the edge
}

static void ClearEdgeVertexList(FILE *outfile){
  vertex *vp;
  int i,id;
  extravertex3DS *vip;
  if(Nvert > FirstVertex){
    for(i=FirstVertex; i < Nvert ; i++){
      id=(MainVp+i)->id;
      if(id != 0){ 
        vip=(extravertex3DS *)id;
        if(vip != NULL){
          if(vip->adj != NULL)free(vip->adj);
          //fprintf(outfile,"Clearing vertex %d with %d connections.\n",i,vip->n);
          free(vip);
          (MainVp+i)->id=0;
        }  
      }
    }
  }
}

static void CreateEdges(FILE *outfile, FaceArray *d){ 
     ushort3ds i;
     int bError;
     int v1,v2,v3;
     UpdateEdgeHeap(Nedge+3*d->faces); // revise later
     for(i = 0; i < d->faces; i++)      {
       v1 = d->facelist[i].v1 + FirstVertex;   if (v1 >= Nvert){bError=1; continue;}  // this is an error
       v2 = d->facelist[i].v2 + FirstVertex;   if (v2 >= Nvert){bError=1; continue;}  // this is an error
       v3 = d->facelist[i].v3 + FirstVertex;   if (v3 >= Nvert){bError=1; continue;}  
       //fprintf(outfile,"Face %d  (%d %d %d)\n",i,v1,v2,v3);
       InsertInVertexList(outfile,v1,v2); //fprintf(outfile,"\n");
       InsertInVertexList(outfile,v2,v3); //fprintf(outfile,"\n");
       InsertInVertexList(outfile,v3,v1); //fprintf(outfile,"\n");
     }
     UpdateEdgeHeap(Nedge+3*d->faces); // revise later
     ClearEdgeVertexList(outfile);
}

static short RequestItemSelect(short Nitems, char **ItemList, char *Message){
 return 1;
}

void rescale_model(short option, FILE *outfile){
  vertex *vp;
  skel   *sp;
  char str[128];
  long i;
  float maxd=1.e-30;
  double scan,x,y,z;
  gcentre[0] = (gmax[0]+gmin[0])/2.0;
  gcentre[1] = (gmax[1]+gmin[1])/2.0;
  gcentre[2] = (gmax[2]+gmin[2])/2.0;
  maxd=max(maxd,(gmax[0]-gmin[0]));
  maxd=max(maxd,(gmax[1]-gmin[1]));
  maxd=max(maxd,(gmax[2]-gmin[2]));
  //fprintf(outfile,"Gmax %lf %lf %lf  Gmin %lf %lf %lf  Maxd %lf\n",gmax[0],gmax[1],gmax[2],gmin[0],gmin[1],gmin[2],maxd);
  if(option == 0){
    scale_3ds=4.0*(float)DEFAULT_SCALE/maxd;
  }
  else if(option == 1){ /* scale set by param  centre from file */
    struct SC {double scan,xc,yc,zc,c;} Sc;
    Sc.xc=gcentre[0]; Sc.yc=gcentre[1]; Sc.zc=gcentre[2]; Sc.c=0;
    Sc.scan=4.0*(double)(DEFAULT_SCALE)/(double)maxd;
    scale_3ds=(float)Sc.scan;
    if(DialogBoxParam(hInstance,MAKEINTRESOURCE(DLG_SCALE),hWndParent,
                     (DLGPROC)DlgProcScale,(LPARAM)&Sc)){
      scale_3ds=(float)Sc.scan;
      if(Sc.c == 1){gcentre[0]=gcentre[1]=gcentre[2]=0.0;}
      else{gcentre[0]=Sc.xc; gcentre[1]=Sc.yc; gcentre[2]=Sc.zc;}
   }
  }
  vp=MainVp; for(i=0;i<Nvert;i++,vp++){
    x=((double)(vp->xyz[0]))/DEFAULT_SCALE; y=((double)(vp->xyz[1]))/DEFAULT_SCALE; z=((double)vp->xyz[2])/DEFAULT_SCALE;
    x = (x - gcentre[0])*scale_3ds; 
    y = (y - gcentre[1])*scale_3ds; 
    z = (z - gcentre[2])*scale_3ds;
    vp->xyz[0]=(long)x; vp->xyz[1]=(long)y; vp->xyz[2]=(long)z;
  }
  sp=MainSp; while(sp != NULL){
    x=((double)sp->xyz[0])/DEFAULT_SCALE; ((double)y=sp->xyz[1])/DEFAULT_SCALE; ((double)z=sp->xyz[2])/DEFAULT_SCALE;
    x = (x - gcentre[0])*scale_3ds; 
    y = (y - gcentre[1])*scale_3ds; 
    z = (z - gcentre[2])*scale_3ds; 
    sp->xyz[0]=(long)x; sp->xyz[1]=(long)y; sp->xyz[2]=(long)z;
    sp=sp->last;
  }
}

static void ReportChunkHeader(FILE *outfile, chunk3ds *chunk, ushort3ds indentlevel){
   //fprintf(outfile, "\n%sChunk %s (%0xH) \n%sLength is %d (%0xH) \n", indent(indentlevel),
   //        ChunkTagToString3ds(chunk->tag), chunk->tag, indent(indentlevel), chunk->size, chunk->size);
}       

void GetActiveTextureIDs(char *matname){
 int i;
 ActiveMaterial = -1;
 ActiveImageMap = -1;
 if(nMats > 0){
   for(i=0;i<nMats; i++){
     if((strcmpi(matname,iMat[i].name)) == 0)ActiveMaterial=i;
   }
 }
 if(nImaps > 0){
   for(i=0;i<nImaps; i++){
     if((strcmpi(matname,iMap[i].N)) == 0)ActiveImageMap=i;
   }
 }
}


void ProcessChunk3ds(FILE *outfile,  /* file formated text gets output to - revised from 3DSFTK library*/
      chunk3ds *chunk, /* chunk that is being dumped */
      ushort3ds indentlevel, /* level of indentation for the chunk */
      skel *CurrentSp
      ){
 chunk3ds *child;
 ReportChunkHeader(outfile, chunk, indentlevel);
 switch(chunk->tag){
   case  MAT_ENTRY :{ //RSFx
     //fprintf(outfile,"Material Entry\n");
     strcpy(CurrentImageMapFile,"");
     CurrentImageMapType = -1;
     CreateMaterial(FALSE);
     CreateImageMap();
     strcpy(iMat[nMats-1].name,"Dummy");
     iMat[nMats-1].bShiny=FALSE;
     strcpy(iMap[nImaps-1].N,"Dummy");
     CurrentMaterial=nMats-1;
     CurrentImageMap=nImaps-1;
   }
   break;
   case  MAT_TEXMAP : {
     //fprintf(outfile,"Texmap\n");
     CurrentImageMapType=1;
   }
   break;
   case  MAT_OPACMAP : {
     //fprintf(outfile,"Opacitymap\n");
     CurrentImageMapType=4;
   }
   break;
   case  MAT_REFLMAP :{
     //fprintf(outfile,"Refelction Map\n");
     CurrentImageMapType=2;
   }
   break;
   case  MAT_BUMPMAP :
     CurrentImageMapType=3;
     //fprintf(outfile,"Bumpmap\n");
   break;
   case  MAT_SPECMAP :  // not used by OpenFX
     CurrentImageMapType=5;
     //fprintf(outfile,"Specularmap\n");
   break;
   case MAT_NAME:   { //RSFx
    MatName *d;
    ReadChunkData3ds(chunk);
    d = chunk->data;
    //fprintf(outfile, "%sMaterial name(1) %s\n", indent(indentlevel), d->name);
    strcpy(iMat[nMats-1].name,d->name);
    strcpy(iMap[nImaps-1].N,d->name);
    break;
   }
   case MAT_MAPNAME: { // filename for the map 
    char *pext;
    MatMapname *d;
    ReadChunkData3ds(chunk);
    d = chunk->data;
    //fprintf(outfile, "%sMap name(1) %s\n", indent(indentlevel), d->name);
    strcpy(CurrentImageMapFile,d->name); 
    strlwr(CurrentImageMapFile);

    // if non supported OFX file type change type to JPG and set path to current folder //RSFx
    pext=strstr(CurrentImageMapFile,".dds");
    if(pext !=NULL)strcpy(pext,".jpg");   
  
    if(CurrentImageMap >=0 && CurrentImageMapType > 0){ //
      if(CurrentImageMapType == 1){ //Surface Texture
        iMap[CurrentImageMap].s = 1;
        if((iMap[CurrentImageMap].S=(char *)X__Malloc(strlen(CurrentImageMapFile)+1)) == NULL)iMap[CurrentImageMap].s=0;
        else strcpy(iMap[CurrentImageMap].S,CurrentImageMapFile);
      }      
      if(CurrentImageMapType == 2){ //Reflect Texture
        iMap[CurrentImageMap].r = 1;
        if((iMap[CurrentImageMap].R=(char *)X__Malloc(strlen(CurrentImageMapFile)+1)) == NULL)iMap[CurrentImageMap].r=0;
        else strcpy(iMap[CurrentImageMap].R,CurrentImageMapFile);
      }
      if(CurrentImageMapType == 3){ //Bump Texture
        iMap[CurrentImageMap].b = 1;
        if((iMap[CurrentImageMap].B=(char *)X__Malloc(strlen(CurrentImageMapFile)+1)) == NULL)iMap[CurrentImageMap].b=0;
        else strcpy(iMap[CurrentImageMap].B,CurrentImageMapFile);
      }
      if(CurrentImageMapType == 4){ //Tramsparency Texture
        iMap[CurrentImageMap].t = 1;
        if((iMap[CurrentImageMap].T=(char *)X__Malloc(strlen(CurrentImageMapFile)+1)) == NULL)iMap[CurrentImageMap].t=0;
        else strcpy(iMap[CurrentImageMap].T,CurrentImageMapFile);
      }
    }
    break;
   }
   case NAMED_OBJECT: { //RSFx
     NamedObject *d;
     ReadChunkData3ds(chunk);
     //fprintf(outfile,"NAMED_OBJECT ******************\n");
     d = chunk->data;
     ObjectFirstVertex = Nvert; ObjectFirstFace = Nface;
     strcpy(CurrentObjectName,d->name); CurrentObjectName[16]=0; 
     //fprintf(outfile, "%sName: %s [%s]\n", indent(indentlevel), d->name, CurrentObjectName);
     break;
   }
   case POINT_ARRAY:{ //   VERTICES RSFx
       PointArray *d;
       ushort3ds i;
       vertex *Vp;
       long x,y,z;
       double xc=0.0,yc=0.0,zc=0.0,xf,yf,zf;
       CreateSkeleton(CurrentSp);
       CurrentSp=MainSp;
       MainSp->xyz[0]=0;
       MainSp->xyz[1]=0;
       MainSp->xyz[2]=0;
       strcpy(MainSp->name,CurrentObjectName);
       ReadChunkData3ds(chunk);
       d = chunk->data;
       //fprintf(outfile, "%s POINT ARRARY %u Vertices  SP name [%s] \n", indent(indentlevel), d->vertices, MainSp->name);
       FirstVertex=Nvert; 
       CurrentVertices=d->vertices;
       UpdateVertexHeap(Nvert+d->vertices);
       for(i = 0; i < d->vertices; i++)  {
         xf = d->pointlist[i].x;
         yf = d->pointlist[i].y;
         zf = d->pointlist[i].z;
         xc += xf;
         yc += yf;
         zc += zf;
         if(xf < gmin[0])gmin[0]=xf; if(xf > gmax[0])gmax[0]=xf;
         if(yf < gmin[1])gmin[1]=yf; if(yf > gmax[1])gmax[1]=yf;
         if(zf < gmin[2])gmin[2]=zf; if(zf > gmax[2])gmax[2]=zf;
         x=(long)(xf*DEFAULT_SCALE);
         y=(long)(yf*DEFAULT_SCALE);
         z=(long)(zf*DEFAULT_SCALE);
         CreateVertex();
         Vp=(MainVp+Nvert-1);
         Vp->sp = MainSp;
         Vp->id=0; // used for temporary pointer to structure used to build the EdgeList.
         Vp->xyz[0]=x; Vp->xyz[1]=y; Vp->xyz[2]=z;
         //fprintf(outfile, "%sVertex %i at %f, %f, %f\n", indent(indentlevel), i, xf, yf, zf);
      }
      xc /= (double)(d->vertices);  
      yc /= (double)(d->vertices);  
      zc /= (double)(d->vertices); 
      MainSp->xyz[0]=(long)(xc*DEFAULT_SCALE);
      MainSp->xyz[1]=(long)(yc*DEFAULT_SCALE);
      MainSp->xyz[2]=(long)(zc*DEFAULT_SCALE);
      break;
   }
   case TEX_VERTS: { //RSFx
     vertex *Vp;
     TexVerts *d;
     ushort3ds i;
     ReadChunkData3ds(chunk);
     d = chunk->data;
     //fprintf(outfile, "%s%u Texture Vertices\n", indent(indentlevel), d->numcoords);
     if(d->numcoords == CurrentVertices){ // This corresponds to the vertices.
       Vp=(MainVp+FirstVertex);
       for(i = 0; i < d->numcoords; i++, Vp++){
         Vp->x=d->textvertlist[i].u;
         Vp->y=d->textvertlist[i].v;
         //fprintf(outfile, "%sVertex %i with tex vert of %f, %f\n", indent(indentlevel), i, d->textvertlist[i].u, d->textvertlist[i].v);
       }
     }
     break;
   }
   case FACE_ARRAY: { //RSFx
     FaceArray *d;
     face *Fp;
     ushort3ds i;
     int v1,v2,v3;
     int bError=0;
     ReadChunkData3ds(chunk);
     d = chunk->data;
     //fprintf(outfile, "%sFACE_ARRAY %u Faces\n", indent(indentlevel), d->faces);
     FirstFace=Nface;
     UpdateFaceHeap(Nface+d->faces);
     for(i = 0; i < d->faces; i++)      {
       v1 = d->facelist[i].v1 + FirstVertex;   if (v1 >= Nvert){bError=1; continue;}  // this is an error
       v2 = d->facelist[i].v2 + FirstVertex;   if (v2 >= Nvert){bError=1; continue;}  // this is an error
       v3 = d->facelist[i].v3 + FirstVertex;   if (v3 >= Nvert){bError=1; continue;}  
       CreateFace(v1,v2,v3);
       // set other properties accordingly - maps etc..
       //fprintf(outfile, "%sFace %i vertices %i, %i, %i and flag %x\n", indent(indentlevel), i, d->facelist[i].v1, d->facelist[i].v2, d->facelist[i].v3, d->facelist[i].flag);
       Fp=(MainFp+FirstFace+i);
       Fp->bSmooth=1;
       Fp->material = -1; // ActiveMaterial; //  Probably the last material - but will be corrected 
       Fp->imagemap = -1; // ActiveImageMap; //  if MESH_MAT_CHUNK is read.
       Fp->x[0]=(MainVp+v1)->x;  Fp->y[0]=(MainVp+v1)->y;
       Fp->x[1]=(MainVp+v2)->x;  Fp->y[1]=(MainVp+v2)->y;
       Fp->x[2]=(MainVp+v3)->x;  Fp->y[2]=(MainVp+v3)->y;
       Fp->gp=1;
     }
     if(!bError){  // create edges.
        CreateEdges(outfile,d) ;
        UpdateEdgeHeap(Nedge);
        //fprintf(outfile,"%d faces and %d edges\n",Nface,Nedge);
     }
     break;
   }
   case MSH_MAT_GROUP: { // assign named material to current object faces
     MshMatGroup *d;
     int i,fid;
     face *Fp;
     ReadChunkData3ds(chunk);
     d = chunk->data;
     //fprintf(outfile, "%sMESH_MAT_GROUP Material Name Of %s\n", indent(indentlevel), d->matname);
     //fprintf(outfile, "%sAssigned to %i faces\n", indent(indentlevel), d->faces);
     GetActiveTextureIDs(d->matname);
     //fprintf(outfile,"Active IDs  %d %d \n",ActiveMaterial,ActiveImageMap);
     for(i = 0; i < d->faces; i++)      {
       fid=d->facelist[i];
       //fprintf(outfile,"%sFace ID %i\n", indent(indentlevel),fid);  
       Fp=(MainFp+ObjectFirstFace+fid);
       Fp->material = ActiveMaterial;
       Fp->imagemap = ActiveImageMap;
     }
     break;
   }

   case MESH_VERSION :{
    MeshVersion *d;
    ReadChunkData3ds(chunk);
    d = chunk->data;
    //fprintf(outfile, "%sVersion %u\n", indent(indentlevel), d->version);
    break;
   }
   case M3D_VERSION :      {
    M3dVersion *d;
    ReadChunkData3ds(chunk);
    d = chunk->data;
    //fprintf(outfile, "%sVersion %u\n", indent(indentlevel), d->version);
    break;
   }
   case POINT_FLAG_ARRAY:      {
   PointFlagArray *d;
   ushort3ds i;
   d = ReadChunkData3ds(chunk);
   //fprintf(outfile, "%sPOINT_FLAG_ARRAY %u Flags\n", indent(indentlevel), d->flags);
   if (DumpLevel3ds == MaximumDump3ds)   {
      for (i = 0; i < d->flags; i++)      {
         //fprintf(outfile, "%sFlag %i is %u\n", indent(indentlevel), i, d->flaglist[i]);
   }
   }
   break;
   }
   case MAT_MAP_TILING:  {
   MatMapTiling *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sMap flags of", indent(indentlevel));
   //if (d->tiling & TEX_DECAL)fprintf(outfile, " TEX_DECAL");
   //if (d->tiling & TEX_MIRROR)fprintf(outfile, " TEX_MIRROR");
   //if (d->tiling & TEX_UNUSED1)fprintf(outfile, " TEX_UNUSED1");
   //if (d->tiling & TEX_INVERT)fprintf(outfile, " TEX_INVERT");
   //if (d->tiling & TEX_NOWRAP)fprintf(outfile, " TEX_NOWRAP");
   //if (d->tiling & TEX_SAT)fprintf(outfile, " TEX_SAT");
   //if (d->tiling & TEX_ALPHA_SOURCE)fprintf(outfile, " TEX_ALPHA_SOURCE");
   //if (d->tiling & TEX_TINT)fprintf(outfile, " TEX_TINT");
   //if (d->tiling & TEX_DONT_USE_ALPHA)fprintf(outfile, " TEX_DONT_USE_ALPHA");
   //if (d->tiling & TEX_RGB_TINT)fprintf(outfile, " TEX_RGB_TINT");
   //if (d->tiling == 0)printf(outfile, " NONE");
   //fprintf(outfile, "\n");
   break;
   }
   case MAT_MAP_COL1 :  {
   MatMapCol1 *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   
   //fprintf(outfile, "%sColor R: %u,", indent(indentlevel), d->red);
   //fprintf(outfile, "G: %u,", d->green);  
   //fprintf(outfile, "B: %u\n", d->blue);
   
   break;
   }
   case MAT_MAP_COL2 :      {
   MatMapCol2 *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sColor R: %u,", indent(indentlevel), d->red);
   //fprintf(outfile, "G: %u,", d->green);  
   //fprintf(outfile, "B: %u\n", d->blue);
   break;
   }
   case MAT_MAP_RCOL :      {
   MatMapRCol *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sColor R: %u,", indent(indentlevel), d->red);
   //fprintf(outfile, "G: %u,", d->green);  
   //fprintf(outfile, "B: %u\n", d->blue);
   break;
   }
   case MAT_MAP_GCOL :      {
   MatMapGCol *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sColor R: %u,", indent(indentlevel), d->red);
   //fprintf(outfile, "G: %u,", d->green);  
   //fprintf(outfile, "B: %u\n", d->blue);
   break;
   }
   case MAT_MAP_BCOL :
      {
   MatMapBCol *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   
   //fprintf(outfile, "%sColor R: %u,", indent(indentlevel), d->red);
   //fprintf(outfile, "G: %u,", d->green);  
   //fprintf(outfile, "B: %u\n", d->blue);
   
   break;
   }
   case MAT_MAP_TEXBLUR:      {
   MatMapTexblur *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sMap bluring of %f\n", indent(indentlevel), d->percent);
   break;
   }
   case MAT_MAP_USCALE:      {
   MatMapUScale *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sMap U scale of %f\n", indent(indentlevel), d->scale);
   break;
   }
   case MAT_MAP_VSCALE:      {
   MatMapVScale *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sMap V scale of %f\n", indent(indentlevel), d->scale);
   break;
   }
   case MAT_MAP_UOFFSET:      {
   MatMapUOffset *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sMap U offset of %f\n", indent(indentlevel), d->offset);
   break;
   }
   case MAT_MAP_VOFFSET:      {
   MatMapVOffset *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sMap V offset of %f\n", indent(indentlevel), d->offset);
   break;
   }
   case MAT_MAP_ANG:      {
   MatMapAng *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sMap rotation angle of %f\n", indent(indentlevel), d->angle);
   break;
   }
   case MAT_BUMP_PERCENT :      {
   MatBumpPercent *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sPercentage of %i%%\n", indent(indentlevel), d->intpercentage);
   break;
   }
   case COLOR_F :   {
   ColorF *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sColor R: %f,", indent(indentlevel), d->red);
   //fprintf(outfile, "G: %f,", d->green);
   //fprintf(outfile, "B: %f\n", d->blue);
   break;
   }
   case LIN_COLOR_F :      {
   LinColorF *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sColor R: %f,", indent(indentlevel), d->red);
   //fprintf(outfile, "G: %f,", d->green);
   //fprintf(outfile, "B: %f\n", d->blue);
   break;
   }
   case COLOR_24 :      {
   Color24 *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sColor R: %u,", indent(indentlevel), d->red);
   //fprintf(outfile, "G: %u,", d->green);  
   //fprintf(outfile, "B: %u\n", d->blue);
   break;
   }
   case LIN_COLOR_24 :{
   LinColor24 *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sColor R: %u,", indent(indentlevel), d->red);
   //fprintf(outfile, "G: %u,", d->green);  
   //fprintf(outfile, "B: %u\n", d->blue);
   break;
   }      
   case INT_PERCENTAGE :      {
   IntPercentage *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sPercentage of %i%%\n", indent(indentlevel), d->intpercentage);
   break;
   }
   case FLOAT_PERCENTAGE :      {
   FloatPercentage *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sPercentage of %f\n", indent(indentlevel), d->floatpercentage);
   break;
   }
   case MASTER_SCALE :      {
   MasterScale *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sMaster Scale %f\n", indent(indentlevel), d->masterscale);
   break;
   }
   case BIT_MAP :      {
   BitMap *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sBitmap name %s\n", indent(indentlevel), d->bitmap);
   break;
   }
   case V_GRADIENT:   {
   VGradient *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sMidpoint %f\n", indent(indentlevel), d->gradpercent);
   break;
   }
   case LO_SHADOW_BIAS:   {
   LoShadowBias *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sBias of %f\n", indent(indentlevel), d->bias);
   break;
   }
   case HI_SHADOW_BIAS:      {
   HiShadowBias *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sBias of %f\n", indent(indentlevel), d->bias);
   break;
   }
    case RAY_BIAS:      {
   RayBias *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sBias of %f\n", indent(indentlevel), d->bias);
   break;
   }
   case SHADOW_MAP_SIZE:      {
   ShadowMapSize *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sSize of %i\n", indent(indentlevel), d->shadowmapsize);
   break;
   }
   case SHADOW_SAMPLES:      {
   ShadowSamples *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sSize of %i\n", indent(indentlevel), d->shadowsamples);
   break;
   }
   case SHADOW_RANGE:      {
   ShadowRange *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sRange of %i\n", indent(indentlevel), d->shadowrange);
   break;
   }
   case SHADOW_FILTER:      {
   ShadowFilter *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sFilter of %f\n", indent(indentlevel), d->shadowfilter);
   break;
   }
   case O_CONSTS:      {
   OConsts *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sPlane at %f, %f, %f\n", indent(indentlevel), d->oconsts.x, d->oconsts.y, d->oconsts.z);
   break;
   }
   case FOG:      {
   Fog *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sNear plane at %f\n", indent(indentlevel), d->nearplanedist);
   //fprintf(outfile, "%sNear density of %f\n", indent(indentlevel), d->nearplanedensity);
   //fprintf(outfile, "%sFar plane at %f\n", indent(indentlevel), d->farplanedist);
   //fprintf(outfile, "%sFar density of %f\n", indent(indentlevel), d->farplanedensity);
   break;
   }
   case LAYER_FOG:      {
   LayerFog *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sFog Z range is %f to %f.\n", indent(indentlevel), d->zmin, d->zmax);
   //fprintf(outfile, "%sFog density is %f.\n", indent(indentlevel), d->density);
   //fprintf(outfile, "%sFog type of %x.\n", indent(indentlevel), d->type);
   break;
   }
   case DISTANCE_CUE:      {
   DistanceCue *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sNear plane at %f\n", indent(indentlevel), d->nearplanedist);
   //fprintf(outfile, "%sNear density of %f\n", indent(indentlevel), d->nearplanedimming);
   //fprintf(outfile, "%sFar plane at %f\n", indent(indentlevel), d->farplanedist);
   //fprintf(outfile, "%sFar density of %f\n", indent(indentlevel), d->farplanedimming);
   break;
   }
   case VIEW_TOP:
   case VIEW_BOTTOM:
   case VIEW_LEFT:
   case VIEW_RIGHT:
   case VIEW_FRONT:
   case VIEW_BACK:      {
   ViewStandard *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sTarget at %f, %f, %f\n", indent(indentlevel), d->viewtargetcoord.x, d->viewtargetcoord.y, d->viewtargetcoord.z);
   //fprintf(outfile, "%sView width of %f\n", indent(indentlevel), d->viewwidth);
   break;
   }
   case VIEW_USER:      {
   ViewUser *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sTarget at %f, %f, %f\n", indent(indentlevel), d->viewtargetcoord.x, d->viewtargetcoord.y, d->viewtargetcoord.z);
   //fprintf(outfile, "%sView width of %f\n", indent(indentlevel), d->viewwidth);
   //fprintf(outfile, "%sHorizontal view angle of %f\n", indent(indentlevel), d->xyviewangle);
   //fprintf(outfile, "%sVertical view angle of %f\n", indent(indentlevel), d->yzviewangle);
   //fprintf(outfile, "%sBank angle of %f\n", indent(indentlevel), d->bankangle);
   break;
   }
   case VIEW_CAMERA:       {
   ViewCamera *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sCamera name %s\n", indent(indentlevel), d->name);
   break;
   }
   case MSH_BOXMAP:{
   MshBoxmap *d;
   ushort3ds i;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sBoxmap consists of the following materials:\n", indent(indentlevel));
   for(i = 0; i < 6; i++)
      //fprintf(outfile, "%s%s\n", indent(indentlevel), d->matnames[i]);
   break;
   }
   case MESH_TEXTURE_INFO:      {
   MeshTextureInfo *d;
   ushort3ds i;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sMap Type of %i\n", indent(indentlevel), d->maptype);
   //fprintf(outfile, "%sX Tiling of %f\n", indent(indentlevel), d->xtiling);
   //fprintf(outfile, "%sY Tiling of %f\n", indent(indentlevel), d->ytiling);
   //fprintf(outfile, "%sIcon position of %f, %f, %f\n", indent(indentlevel), d->iconpos.x, d->iconpos.y, d->iconpos.z);
   //for (i = 0; i < 12; i+=3)   {
   //fprintf(outfile, "%s[%i] %f [%i] %f [%i] %f\n", indent(indentlevel), i, d->xmatrix[i], i+1, d->xmatrix[i+1], i+2, d->xmatrix[i+2]);
   //}
   //fprintf(outfile, "%sScaling Value of %f\n", indent(indentlevel), d->iconscaling);
   //fprintf(outfile, "%sPlanar Icon Width of %f\n", indent(indentlevel), d->iconwidth);
   //fprintf(outfile, "%sPlanar Icon Height of %f\n", indent(indentlevel), d->iconheight);
   //fprintf(outfile, "%sCylinder Icon Height of %f\n", indent(indentlevel), d->cyliconheight);
   break;
   }
   case MESH_MATRIX:      {
   MeshMatrix *d;
   ushort3ds i;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   for (i = 0; i < 12; i+=3)   {
      //fprintf(outfile, "%s[%i] %f [%i] %f [%i] %f\n", indent(indentlevel), i, d->xmatrix[i], i+1, d->xmatrix[i+1], i+2, d->xmatrix[i+2]);
   }
   break;
   }
   case PROC_NAME:    {
      ProcName *d;

      d = ReadChunkData3ds(chunk);

      //fprintf(outfile, "%sProcedure Name of %s\n", indent(indentlevel), d->name);

      break;
   }
   case MESH_COLOR:      {
   MeshColor *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sColor index of %i\n", indent(indentlevel), d->color);
   break;
   }
   case N_DIRECT_LIGHT:   {
   NDirectLight *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sLight at %f, %f, %f\n", indent(indentlevel), d->lightpos.x, d->lightpos.y, d->lightpos.z);
   break;
   }
   case DL_EXCLUDE:      {
   DlExclude *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sExclude %s.\n", indent(indentlevel), d->name);
   break;
   }
   case DL_OUTER_RANGE:
   case DL_INNER_RANGE:      {
   DlOuterRange *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sRange of %f.\n", indent(indentlevel), d->range);
   break;
   }
   case DL_MULTIPLIER:      {
   DlMultiplier *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sMultiple of %f.\n", indent(indentlevel), d->multiple);
   break;
   }
   case DL_SPOT_ROLL:      {
   DlSpotRoll *d;
   d = ReadChunkData3ds(chunk);

   //fprintf(outfile, "%sRoll angle of %f.\n", indent(indentlevel), d->angle);
   break;
   }
   case DL_SPOT_ASPECT:      {
   DlSpotAspect *d;
   d = ReadChunkData3ds(chunk);
   //fprintf(outfile, "%sSpot aspect of %f.\n", indent(indentlevel), d->aspect);
   break;
   }
   case DL_SPOT_PROJECTOR:      {
   DlSpotProjector *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sFilename of %s.\n", indent(indentlevel), d->name);
   break;
   }
   case DL_RAY_BIAS:      {
   DlRayBias *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sBias of %f.\n", indent(indentlevel), d->bias);
   break;
   }
   case DL_SPOTLIGHT:      {
   DlSpotlight *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sTarget at %f, %f, %f\n", indent(indentlevel), d->spotlighttarg.x, d->spotlighttarg.y, d->spotlighttarg.z);
   //fprintf(outfile, "%sHotspot cone of %f, ", indent(indentlevel), d->hotspotangle);
   //fprintf(outfile, "Falloff cone of %f\n",  d->falloffangle);
   break;
   }
   case DL_LOCAL_SHADOW2:      {
   DlLocalShadow2 *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sShadow bias of %f\n", indent(indentlevel), d->localshadowbias);
   //fprintf(outfile, "%sShadow filter of %f\n", indent(indentlevel), d->localshadowfilter);
   //fprintf(outfile, "%sShadow map size of %f\n", indent(indentlevel), d->localshadowmapsize);
   
   break;
   }
   case N_CAMERA:      {
   NCamera *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   
   //fprintf(outfile, "%sCamera at %f, %f, %f\n", indent(indentlevel), d->camerapos.x, d->camerapos.y, d->camerapos.z);
   //fprintf(outfile, "%sTarget at %f, %f, %f\n", indent(indentlevel), d->targetpos.x, d->targetpos.y, d->targetpos.z);
   //fprintf(outfile, "%sBank angle of %f", indent(indentlevel), d->camerabank);
   //fprintf(outfile, " and a foc of %f\n", d->camerafocallength);
   break;
   }
   case CAM_RANGES:      {
   CamRanges *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sCamera near range is %f and far range is %f.\n", indent(indentlevel), d->nearplane, d->farplane);
   break;
   }
   case VIEWPORT_LAYOUT:      {
   ViewportLayout *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sForm of %i\n", indent(indentlevel), d->form);
   //fprintf(outfile, "%sTop of %i\n", indent(indentlevel), d->top);
   //fprintf(outfile, "%sReady of %i\n", indent(indentlevel), d->ready);
   //fprintf(outfile, "%sWState of %i\n", indent(indentlevel), d->wstate);
   //fprintf(outfile, "%sSwap WS of %i\n", indent(indentlevel), d->swapws);
   //fprintf(outfile, "%sSwap Port of %i\n", indent(indentlevel), d->swapport);
   //fprintf(outfile, "%sSwap Cur of %i\n", indent(indentlevel), d->swapcur);
   break;
   }
   case VIEWPORT_SIZE:      {
   ViewportSize *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sWork Area X: %i Y: %i W: %i H: %i\n", indent(indentlevel), d->xpos, d->ypos, d->width, d->height);
   break;
   }
   case VIEWPORT_DATA_3:
   case VIEWPORT_DATA:      {
   ViewportData *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sFlags of %x\n", indent(indentlevel), d->flags);
   //fprintf(outfile, "%sAxis Lockouts of %x\n", indent(indentlevel), d->axislockout);
   //fprintf(outfile, "%sWindow Position of %i, ", indent(indentlevel), d->winxpos);
   //fprintf(outfile, "%i\n", d->winypos);
   //fprintf(outfile, "%sWindow Size of %i, ", indent(indentlevel), d->winwidth);
   //fprintf(outfile, "%i\n", d->winheight);
   //fprintf(outfile, "%sWindow View of %i\n", indent(indentlevel), d->view);
   //fprintf(outfile, "%sZoom Factor of %f\n", indent(indentlevel), d->zoomfactor);
   //fprintf(outfile, "%sWorld center of %f, %f, %f\n", indent(indentlevel), d->center.x, d->center.y, d->center.z);
   //fprintf(outfile, "%sHorizontal Angle of %f\n", indent(indentlevel), d->horizang);
   //fprintf(outfile, "%sVertical Angle of %f\n", indent(indentlevel), d->vertang);
   //fprintf(outfile, "%sCamera Name of %s\n", indent(indentlevel), d->camname);
   break;
   }
   case XDATA_APPNAME:      {
   XDataAppName *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sApplication name %s\n", indent(indentlevel), d->name);
   break;
   }
   case XDATA_STRING:      {
   XDataString *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sString value of %s\n", indent(indentlevel), d->string);
   break;
   }
   case MAT_SHADING:      {
   MatShading *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sShading value of %u\n", indent(indentlevel), d->matshading);
   break;
   }
   case MAT_ACUBIC:      {
   MatAcubic *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sShade level of %i\n", indent(indentlevel), d->shadelevel);
   //fprintf(outfile, "%sAntialias level of %i\n", indent(indentlevel), d->antialias);
   //fprintf(outfile, "%sFlags of %u\n", indent(indentlevel), d->flags);
   //fprintf(outfile, "%sMap size of %u\n", indent(indentlevel), d->mapsize);
   //fprintf(outfile, "%sFrame skip of %u\n", indent(indentlevel), d->frameinterval);
   break;
   }
   case MAT_WIRESIZE:      {
   MatWireSize *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sWire frame size of %f\n", indent(indentlevel), d->wiresize);
   break;
   }

   case KFHDR:      {
   KFHdr *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sRevision level of %x\n", indent(indentlevel), d->revision);
   //fprintf(outfile, "%sFilename %s\n", indent(indentlevel), d->filename);
   //fprintf(outfile, "%sAnimation length of %i\n", indent(indentlevel), d->animlength);
   break;
   }
   case KFSEG:      {
   KFSeg *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sSegment starts at %i and ends at %i\n", indent(indentlevel), d->first, d->last);
   break;
   }
   case KFCURTIME:
      {
   KFCurtime *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   
   //fprintf(outfile, "%sCurrent frame is %i\n", indent(indentlevel), d->currframenum);
   
   break;
   }
   case NODE_ID:      {
     int i;
     KFId *d;
     d = ReadChunkData3ds(chunk);
     i = (int)d->id;
    //fprintf(outfile, "%s Node ID: %d \n", indent(indentlevel), i);
    break;
   }
   case NODE_HDR: {
   NodeHdr *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   
   //fprintf(outfile, 
   //  "%sObject name: %s\n", 
   //  indent(indentlevel), 
   //  d->objname);

   /*--- Flags 1 */
   //fprintf(outfile, 
   //  "%sFlags 1: %x\n", 
   //  indent(indentlevel), 
   //  d->flags1);
   if (DumpLevel3ds == MaximumDump3ds){

     //if (d->flags1&NODE_RENDOB_HIDE)
       //fprintf(outfile, "%sNODE_RENDOB_HIDE\n", indent(indentlevel));
     //if (d->flags1&NODE_OFF)
       //fprintf(outfile, "%sNODE_OFF\n", indent(indentlevel));
     //if (d->flags1&ATKEY1)
       //fprintf(outfile, "%sATKEY1\n", indent(indentlevel));
     //if (d->flags1&ATKEY2)
       //fprintf(outfile, "%sATKEY2\n", indent(indentlevel));
     //if (d->flags1&ATKEY3)
       //fprintf(outfile, "%sATKEY3\n", indent(indentlevel));
     //if (d->flags1&ATKEY4)
       //fprintf(outfile, "%sATKEY4\n", indent(indentlevel));
     //if (d->flags1&ATKEY5)
       //fprintf(outfile, "%sATKEY5\n", indent(indentlevel));
     //if (d->flags1&ATKEYFLAGS)
       //fprintf(outfile, "%sATKEYFLAGS\n", indent(indentlevel));
     //if (d->flags1&MARK_NODE)
       //fprintf(outfile, "%sMARK_NODE\n", indent(indentlevel));
     //if (d->flags1&DISABLE_NODE)
       //fprintf(outfile, "%sDISABLE_NODE\n", indent(indentlevel));
     //if (d->flags1&HIDE_NODE)
       //fprintf(outfile, "%sHIDE_NODE\n", indent(indentlevel));
     //if (d->flags1&FAST_NODE)
       //fprintf(outfile, "%sFAST_NODE\n", indent(indentlevel));
     //if (d->flags1&PRIMARY_NODE)
       //fprintf(outfile, "%sPRIMARY_NODE\n", indent(indentlevel));
     //if (d->flags1&NODE_CALC_PATH)
       //fprintf(outfile, "%sNODE_CALC_PATH\n", indent(indentlevel));
   }

   /*--- Flags 2 */
   //fprintf(outfile, 
   //  "%sFlags 2: %x\n", 
   //  indent(indentlevel), 
   //  d->flags2);
   if (DumpLevel3ds == MaximumDump3ds){
     //if (d->flags2&NODE_HAS_PATH)
       //fprintf(outfile, "%sNODE_HAS_PATH\n",indent(indentlevel));
     //if (d->flags2&NODE_AUTO_SMOOTH)
       //fprintf(outfile, "%sNODE_AUTO_SMOOTH\n",indent(indentlevel));
     //if (d->flags2&NODE_FROZEN)
       //fprintf(outfile, "%sNODE_FROZEN\n",indent(indentlevel));
     //if (d->flags2&NODE_ANI_HIDDEN)
       //fprintf(outfile, "%sNODE_ANI_HIDDEN\n",indent(indentlevel));
     //if (d->flags2&NODE_MOTION_BLUR)
       //fprintf(outfile, "%sNODE_MOTION_BLUR\n",indent(indentlevel));
     //if (d->flags2&NODE_BLUR_BRANCH)
       //fprintf(outfile, "%sNODE_BLUR_BRANCH\n",indent(indentlevel));
     //if (d->flags2&NODE_MORPH_MTL)
       //fprintf(outfile, "%sNODE_MORPH_MTL\n",indent(indentlevel));
     //if (d->flags2&NODE_MORPH_OB)
       //fprintf(outfile, "%sNODE_MORPH_OB\n",indent(indentlevel));
   }

   
   //if (d->parentindex == -1) 
     //fprintf(outfile, "%sNo Parent\n", indent(indentlevel));
    //     else 
     //fprintf(outfile, 
      // "%sParent %i\n", indent(indentlevel), d->parentindex);
   break;
   }
   case INSTANCE_NAME:      { //RSFx
     InstanceName *d;
    ReadChunkData3ds(chunk);
    d = chunk->data;
    //fprintf(outfile, "%sInstance name: %s\n", indent(indentlevel), d->name);
    break;
   }
   case PARENT_NAME: { //RSFx
   InstanceName *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //if (d == NULL ||d->name[0] == 0)
   //fprintf(outfile, "%sNo Parent\n", indent(indentlevel));
   //else
   //fprintf(outfile, "%sParent name: %s\n",
   //  indent(indentlevel), d->name);
   break;
   }
   case PIVOT:
      {
   Pivot *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%sPivot at %f, %f, %f\n", indent(indentlevel), d->offset.x, d->offset.y, d->offset.z);
   break;
   }
   case BOUNDBOX:      {
   BoundBox *d;
   d = chunk->data;
      if (d != NULL){
   //fprintf(outfile, "%sMinimum at %f, %f, %f\n", indent(indentlevel), d->min.x, d->min.y, d->min.z);
   //fprintf(outfile, "%sMaximum at %f, %f, %f\n", indent(indentlevel), d->max.x, d->max.y, d->max.z);
    }
   
   break;
   }
   case MORPH_SMOOTH:
      {
   MorphSmooth *d;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   
   //fprintf(outfile, "%sMorph Smoothing Angle of %f\n", indent(indentlevel), d->smoothgroupangle);
   
   break;
   }
   case POS_TRACK_TAG:      {
   PosTrackTag *d;
   ulong3ds i;
   
   ReadChunkData3ds(chunk);
   d = chunk->data;
   
   //fprintf(outfile, "%s%u Keys, %x Flags.\n", indent(indentlevel), d->trackhdr.keycount, d->trackhdr.flags);
   
   for (i = 0; i < d->trackhdr.keycount; i++) {
      //PrintKeyHeader3ds(outfile,  &(d->keyhdrlist[i]), indentlevel);
      //fprintf(outfile, "%sObject at %f, %f, %f\n", indent(indentlevel), d->positionlist[i].x, d->positionlist[i].y, d->positionlist[i].z);
   }
   
   break;
   }
   case ROT_TRACK_TAG:      {
   RotTrackTag *d;
   ulong3ds i;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%s%u Keys, %x Flags.\n", indent(indentlevel), d->trackhdr.keycount, d->trackhdr.flags);
   for (i = 0; i < d->trackhdr.keycount; i++)    {
      //PrintKeyHeader3ds(outfile, &(d->keyhdrlist[i]), indentlevel);
      //fprintf(outfile, "%sRotation of %f\n", indent(indentlevel), d->rotationlist[i].angle);
      //fprintf(outfile, "%sAxis of %f, %f, %f\n", indent(indentlevel), d->rotationlist[i].x, d->rotationlist[i].y, d->rotationlist[i].z);
   }
   
   break;
   }
   case SCL_TRACK_TAG:      {
   ScaleTrackTag *d;
   ulong3ds i;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%s%u Keys, %x Flags.\n", indent(indentlevel), d->trackhdr.keycount, d->trackhdr.flags);
   for (i = 0; i < d->trackhdr.keycount; i++) {
      //PrintKeyHeader3ds(outfile, &(d->keyhdrlist[i]), indentlevel);
      //fprintf(outfile, "%sScale of %f, %f, %f\n", indent(indentlevel), d->scalelist[i].x, d->scalelist[i].y, d->scalelist[i].z);
   }
   break;
   }
   case FOV_TRACK_TAG:      {
   FovTrackTag *d;
   ulong3ds i;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%s%u Keys, %x Flags.\n", indent(indentlevel), d->trackhdr.keycount, d->trackhdr.flags);
   for (i = 0; i < d->trackhdr.keycount; i++) {
      //PrintKeyHeader3ds(outfile, &(d->keyhdrlist[i]), indentlevel);
      //fprintf(outfile, "%sCamera Fov of %f\n", indent(indentlevel), d->fovanglelist[i]);
   }
   
   break;
   }
   case ROLL_TRACK_TAG:      {
   RollTrackTag *d;
   ulong3ds i;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%s%u Keys, %x Flags.\n", indent(indentlevel), d->trackhdr.keycount, d->trackhdr.flags);
   for (i = 0; i < d->trackhdr.keycount; i++) {
      //PrintKeyHeader3ds(outfile, &(d->keyhdrlist[i]), indentlevel);
      //fprintf(outfile, "%sCamera Roll of %f\n", indent(indentlevel), d->rollanglelist[i]);
   }
   break;
   }
   case COL_TRACK_TAG:      {
   ColTrackTag *d;
   ulong3ds i;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%s%u Keys, %x Flags.\n", indent(indentlevel), d->trackhdr.keycount, d->trackhdr.flags);
   for (i = 0; i < d->trackhdr.keycount; i++) {
      //PrintKeyHeader3ds(outfile, &(d->keyhdrlist[i]), indentlevel);
      //fprintf(outfile, "%sColor R: %f,", indent(indentlevel), d->colorlist[i].r);
      //fprintf(outfile, "G: %f,", d->colorlist[i].g);
      //fprintf(outfile, "B: %f\n", d->colorlist[i].b);
   }
   
   break;
   }
   case MORPH_TRACK_TAG:      {
   MorphTrackTag *d;
   ulong3ds i;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%s%u Keys, %x Flags.\n", indent(indentlevel), d->trackhdr.keycount, d->trackhdr.flags);
   for (i = 0; i < d->trackhdr.keycount; i++) {
      //PrintKeyHeader3ds(outfile, &(d->keyhdrlist[i]), indentlevel);
      //fprintf(outfile, "%sMorph to %s\n", indent(indentlevel), d->morphlist[i].name);
   }
   break;
   }
   case HOT_TRACK_TAG:      {
   HotTrackTag *d;
   ulong3ds i;
   
   ReadChunkData3ds(chunk);
   d = chunk->data;
   
   //fprintf(outfile, "%s%u Keys, %x Flags.\n", indent(indentlevel), d->trackhdr.keycount, d->trackhdr.flags);
   for (i = 0; i < d->trackhdr.keycount; i++) {
      //PrintKeyHeader3ds(outfile, &(d->keyhdrlist[i]), indentlevel);
      //fprintf(outfile, "%sHotspot angle of %f\n", indent(indentlevel), d->hotspotanglelist[i]);
   }
   
   break;
   }
   case FALL_TRACK_TAG:      {
   FallTrackTag *d;
   ulong3ds i;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%s%u Keys, %x Flags.\n", indent(indentlevel), d->trackhdr.keycount, d->trackhdr.flags);
   for (i = 0; i < d->trackhdr.keycount; i++) {
      //PrintKeyHeader3ds(outfile, &(d->keyhdrlist[i]), indentlevel);
      //fprintf(outfile, "%sFalloff Angle of %f\n", indent(indentlevel), d->falloffanglelist[i]);
   }
   break;
   }
   case HIDE_TRACK_TAG:      {
   HideTrackTag *d;
   ulong3ds i;
   ReadChunkData3ds(chunk);
   d = chunk->data;
   //fprintf(outfile, "%s%u Keys, %x Flags.\n", 
   //  indent(indentlevel), 
   //  d->trackhdr.keycount, d->trackhdr.flags);
   for (i = 0; i < d->trackhdr.keycount; i++) {
     //PrintKeyHeader3ds(outfile, &(d->keyhdrlist[i]), indentlevel);
   }
   break;
   }

 } /* End Switch */

  child = chunk->children;
  while (child != NULL)    {
    //fprintf(outfile,"child of parent [%s]\n",CurrentObjectName); //RSFxx
    ProcessChunk3ds(outfile, child, (ushort3ds)(indentlevel+1),CurrentSp);
    ON_ERROR_RETURN;
    child = child->sibling;
 }
}

BOOL Do3dsConvert(int argc, char **argv){
 HCURSOR hSave;
 FILE *outfile;
 float size=500.0;
 long count,fze,sc=1;
 unsigned short i,id;
 char c,argv1[512],str[512];
 if(argc < 2)return FALSE;
 strcpy(argv1,argv[1]);
 if(lpEVI == NULL){MessageBox(NULL,"Bad Pointer",NULL,MB_OK); return FALSE;}
 for(i=0;i<3;i++){
   gmax[i] = -1.0e30;
   gmin[i] =  1.0e30;
 } 
 if(Nvert > 0 || Nface > 0)return FALSE;
 if((i=strlen(argv1)) < 4 || argv1[i-4] != '.')strcat(argv1,".3DS");
 argv1[strlen(argv1)]=0;
 {
   file3ds *file= NULL;
   database3ds *db = NULL;
   chunklist3ds *meshlist=NULL, *matlist=NULL;
   //outfile=fopen("c:\\data\\dummy3ds.txt","w"); //RSFx
   outfile=stderr;
   SetDumpLevel3ds(MaximumDump3ds);
   file = OpenFile3ds(argv1, "r");
   hSave=SetCursor(LoadCursor(NULL,IDC_WAIT));

   InitDatabase3ds(&db);
   CreateDatabase3ds(file, db);
   ProcessChunk3ds(outfile, db->topchunk, 0,FirstSp);
   ReleaseDatabase3ds(&db);
   CloseFile3ds(file);
   SetCursor(hSave);
   if(dlg != NULL)DestroyWindow(dlg); dlg=NULL;
 }
 if(sc)rescale_model(1,outfile);
 else  rescale_model(0,outfile);
 //fclose(outfile); outfile=NULL; //RSFx
 return FALSE;
}