/*************
* FUNCTION: OpenIFF
* DESCRIPTION: open iff file and parse to begin of file
* INPUT: iff iff handle
* filename name of file
* filesize size of file is returned in this variable
* OUTPUT: error string
*************/
static char *OpenIFF(struct IFFHandle **iff, char *filename, ULONG *filesize)
{
struct ContextNode *cn;
// Allocate IFF_File structure.
*iff = AllocIFF();
if(!*iff)
return errors[ERR_MEM];
#ifdef __AMIGA__
// Set up IFF_File for AmigaDOS I/O.
(*iff)->iff_Stream = Open(filename, MODE_OLDFILE);
#else
(*iff)->iff_Stream = Open_(filename, MODE_OLDFILE);
#endif
if(!(*iff)->iff_Stream)
return errors[ERR_OPENFILE];
InitIFFasDOS(*iff);
// Start the IFF transaction.
if(OpenIFF(*iff, IFFF_READ))
return errors[ERR_LWOBFILE];
if(ParseIFF(*iff, IFFPARSE_RAWSTEP))
return errors[ERR_LWOBFILE];
cn = CurrentChunk(*iff);
if((cn->cn_ID != ID_FORM) || (cn->cn_Type != ID_LWOB))
return errors[ERR_LWOBFILE];
*filesize = cn->cn_Size;
return NULL;
}
/*************
* DESCRIPTION: save a surface definition
* INPUT: filename name of surface file
* OUTPUT: error string or NULL if all ok
*************/
char *SURFACE::Save(char *filename)
{
struct IFFHandle *iff;
// Allocate IFF_File structure.
iff = AllocIFF();
if(!iff)
return errors[ERR_MEM];
// Set up IFF_File for AmigaDOS I/O.
#ifdef __AMIGA__
iff->iff_Stream = Open(filename, MODE_NEWFILE);
#else
iff->iff_Stream = Open_(filename, MODE_NEWFILE);
#endif
if(!iff->iff_Stream)
{
IFFCleanup(iff);
return errors[ERR_OPEN];
}
InitIFFasDOS(iff);
// Start the IFF transaction.
if(OpenIFF(iff, IFFF_WRITE))
{
IFFCleanup(iff);
return errors[ERR_IFFPARSE];
}
PUSH_CHUNK(ID_RMAT);
// write surface
Write(iff);
IFFCleanup(iff);
return NULL;
}
/*************
* DESCRIPTION: load a surface definition
* INPUT: filename name of surface file
* OUTPUT: error string or NULL if all ok
*************/
char *SURFACE::Load(char *filename)
{
long error = 0;
struct IFFHandle *iff;
struct ContextNode *cn;
iff = AllocIFF();
if (!iff)
return errors[ERR_MEM];
#ifdef __AMIGA__
iff->iff_Stream = Open(filename, MODE_OLDFILE);
#else
iff->iff_Stream = Open_(filename, MODE_OLDFILE);
#endif
if (!(iff->iff_Stream))
{
IFFCleanup(iff);
return errors[ERR_OPEN];
}
InitIFFasDOS(iff);
error = OpenIFF(iff, IFFF_READ);
if (error)
{
IFFCleanup(iff);
return errors[ERR_IFFPARSE];
}
error = ParseIFF(iff, IFFPARSE_RAWSTEP);
if (error)
{
IFFCleanup(iff);
return errors[ERR_IFFPARSE];
}
cn = CurrentChunk(iff);
if(!cn)
{
IFFCleanup(iff);
return errors[ERR_IFFPARSE];
}
if((cn->cn_ID != ID_FORM) || (cn->cn_Type != ID_RMAT))
{
IFFCleanup(iff);
return errors[ERR_NORMATFILE];
}
while(!error || error == IFFERR_EOC)
{
error = ParseIFF(iff, IFFPARSE_RAWSTEP);
if(error != IFFERR_EOC)
{
// Get a pointer to the context node describing the current context
cn = CurrentChunk(iff);
if (cn)
{
switch (cn->cn_ID)
{
case ID_FORM:
switch(cn->cn_Type)
{
case ID_SURF:
if(!Read(iff, NULL))
{
IFFCleanup(iff);
return errors[ERR_RMATCORRUPT];
}
break;
}
break;
}
}
}
}
if (error != IFFERR_EOF)
{
return errors[ERR_IFFPARSE];
}
IFFCleanup(iff);
return NULL;
}
virtual std::unique_ptr<File> Open(const char* str)
{
return std::unique_ptr<File>(Open_(str));
}
char *PROJECT::Load(char *filename, DISPLAY *disp)
{
long error = 0;
struct IFFHandle *iff;
struct ContextNode *cn;
char *err;
OBJECT *where = NULL;
int dir = INSERT_HORIZ;
// there is currently no active camera read
camera[0] = 0;
iff = AllocIFF();
if (!iff)
return errors[ERR_MEM];
#ifdef __AMIGA__
iff->iff_Stream = Open(filename, MODE_OLDFILE);
#else
iff->iff_Stream = Open_(filename, MODE_OLDFILE);
#endif
if (!(iff->iff_Stream))
{
IFFCleanup(iff);
return errors[ERR_OPEN];
}
InitIFFasDOS(iff);
error = OpenIFF(iff, IFFF_READ);
if (error)
{
IFFCleanup(iff);
return errors[ERR_IFFPARSE];
}
error = ParseIFF(iff, IFFPARSE_RAWSTEP);
if (error)
{
IFFCleanup(iff);
return errors[ERR_IFFPARSE];
}
cn = CurrentChunk(iff);
if(!cn)
{
IFFCleanup(iff);
return errors[ERR_IFFPARSE];
}
if((cn->cn_ID != ID_FORM) || (cn->cn_Type != ID_RSCN))
{
IFFCleanup(iff);
return errors[ERR_NORSCNFILE];
}
while(!error || error == IFFERR_EOC)
{
error = ParseIFF(iff, IFFPARSE_RAWSTEP);
if(error != IFFERR_EOC)
{
// Get a pointer to the context node describing the current context
cn = CurrentChunk(iff);
if (cn)
{
switch (cn->cn_ID)
{
case ID_VERS:
if(!ReadULONG(iff,&rscn_version,1))
{
IFFCleanup(iff);
return errors[ERR_RSCNFILE];
}
if(rscn_version > VERSION)
{
IFFCleanup(iff);
return errors[ERR_WRONGVERS];
}
break;
case ID_FORM:
switch(cn->cn_Type)
{
case ID_GNRL:
err = ParseGeneral(iff,disp);
if(err)
{
IFFCleanup(iff);
return err;
}
break;
case ID_FRAM:
err = ParseFrame(iff);
if(err)
{
IFFCleanup(iff);
return err;
}
break;
case ID_SRFS:
err = ParseSurfaces(iff);
if(err)
{
IFFCleanup(iff);
return err;
}
break;
case ID_CAMR:
where = ParseCamera(iff, where, dir);
if(!where)
{
IFFCleanup(iff);
return errors[ERR_RSCNFILE];
}
dir = INSERT_HORIZ;
break;
case ID_SPHR:
where = ParseSphere(iff, where, dir);
if(!where)
{
IFFCleanup(iff);
return errors[ERR_RSCNFILE];
}
dir = INSERT_HORIZ;
break;
case ID_PLAN:
where = ParsePlane(iff, where, dir);
if(!where)
{
IFFCleanup(iff);
return errors[ERR_RSCNFILE];
}
dir = INSERT_HORIZ;
break;
case ID_PLGT:
case ID_SLGT:
case ID_DLGT:
where = ParseLight(iff, where, dir, cn->cn_Type);
if(!where)
{
IFFCleanup(iff);
return errors[ERR_RSCNFILE];
}
dir = INSERT_HORIZ;
break;
case ID_MESH:
where = ParseMesh(iff, where, dir);
if(!where)
{
IFFCleanup(iff);
return errors[ERR_RSCNFILE];
}
dir = INSERT_HORIZ;
break;
case ID_EXTN:
where = ParseExternal(iff, where, dir);
if(!where)
{
IFFCleanup(iff);
return errors[ERR_RSCNFILE];
}
dir = INSERT_HORIZ;
break;
case ID_BOX:
where = ParseBox(iff, where, dir);
if(!where)
{
IFFCleanup(iff);
return errors[ERR_RSCNFILE];
}
dir = INSERT_HORIZ;
break;
case ID_CYLR:
where = ParseCylinder(iff, where, dir);
if(!where)
{
IFFCleanup(iff);
return errors[ERR_RSCNFILE];
}
dir = INSERT_HORIZ;
break;
case ID_CONE:
where = ParseCone(iff, where, dir);
if(!where)
{
IFFCleanup(iff);
return errors[ERR_RSCNFILE];
}
dir = INSERT_HORIZ;
break;
case ID_CSG:
where = ParseCSG(iff, where, dir);
if(!where)
{
IFFCleanup(iff);
return errors[ERR_RSCNFILE];
}
dir = INSERT_HORIZ;
break;
case ID_SOR:
where = ParseSOR(iff, where, dir);
if(!where)
{
IFFCleanup(iff);
return errors[ERR_RSCNFILE];
}
dir = INSERT_HORIZ;
break;
case ID_HIER:
dir = INSERT_VERT;
break;
}
break;
}
}
}
else
{
cn = CurrentChunk(iff);
if (cn)
{
if((cn->cn_ID == ID_FORM) && (cn->cn_Type == ID_HIER))
{
if(dir == INSERT_HORIZ)
{
while(where->GetPrev())
where = (OBJECT*)where->GetPrev();
if(where->GoUp())
where = (OBJECT*)where->GoUp();
}
else
dir = INSERT_HORIZ;
}
}
}
}
if (error != IFFERR_EOF)
{
return errors[ERR_IFFPARSE];
}
IFFCleanup(iff);
// we have to set the active camera
disp->camera = (CAMERA*)GetObjectByName(camera);
if(!disp->camera)
err = errors[ERR_NOCAMERA];
else
err = NULL;
// and translate track names to track objects
// and the surface names to surface pointers
TranslateNames();
return err;
}
/*************
* DESCRIPTION: save the current project to disk
* INPUT: project projectname (the project is saved to a
* directory with this name)
* disp current display
* OUTPUT: error string if failed, else NULL;
*************/
char *PROJECT::Save(char *filename, DISPLAY *disp)
{
struct IFFHandle *iff;
ULONG data[2];
float fdata[2];
UBYTE ubdata;
VIEW *view = disp->view;
OBSERVER obsv;
int i;
// Allocate IFF_File structure.
iff = AllocIFF();
if(!iff)
return errors[ERR_MEM];
// Set up IFF_File for AmigaDOS I/O.
#ifdef __AMIGA__
iff->iff_Stream = Open(filename, MODE_NEWFILE);
#else
iff->iff_Stream = Open_(filename, MODE_NEWFILE);
#endif
if(!iff->iff_Stream)
{
IFFCleanup(iff);
return errors[ERR_OPEN];
}
InitIFFasDOS(iff);
// Start the IFF transaction.
if(OpenIFF(iff, IFFF_WRITE))
{
IFFCleanup(iff);
return errors[ERR_IFFPARSE];
}
PUSH_CHUNK(ID_RSCN);
data[0] = VERSION;
WRITE_LONG_CHUNK(ID_VERS, data, 1);
PUSH_CHUNK(ID_GNRL);
data[0] = global.xres;
data[1] = global.yres;
WRITE_LONG_CHUNK(ID_RESO, data, 2);
if(global.renderdpic)
WRITE_CHUNK(ID_PICT, global.renderdpic, strlen(global.renderdpic)+1);
if(global.picformat)
WRITE_CHUNK(ID_PTYP, global.picformat, strlen(global.picformat)+1);
ubdata = disp->display;
WRITE_CHUNK(ID_DISP, &ubdata, sizeof(UBYTE));
// changed with v2.1: no longer current viewmode, now current view number
for(i=0; i<4; i++)
{
if(disp->views[i] == disp->view)
{
ubdata = i;
WRITE_CHUNK(ID_VIEW, &ubdata, sizeof(UBYTE));
}
}
WRITE_LONG_CHUNK(ID_GRID, &disp->gridsize, 1);
data[0] = 0;
if(disp->grid)
data[0] |= RSCN_GENERAL_GRID;
if(disp->gridsnap)
data[0] |= RSCN_GENERAL_GRIDSNAP;
if(disp->multiview)
data[0] |= RSCN_GENERAL_VIEWFOUR;
if(global.show)
data[0] |= RSCN_GENERAL_SHOW;
if(global.enablearea)
data[0] |= RSCN_GENERAL_ENABLEAREA;
if(global.enableback)
data[0] |= RSCN_GENERAL_ENABLEBACK;
if(global.enablerefl)
data[0] |= RSCN_GENERAL_ENABLEREFL;
WRITE_LONG_CHUNK(ID_FLGS, data, 1);
// write views
for(i=0; i<4; i++)
{
obsv.vpos = disp->views[i]->vpos;
obsv.valign = disp->views[i]->valign;
obsv.dist = disp->views[i]->dist;
obsv.viewpoint = disp->views[i]->viewpoint;
obsv.zoom = disp->views[i]->zoom;
obsv.viewmode = disp->views[i]->viewmode;
WRITE_LONG_CHUNK(ID_OBSV, &obsv, 12);
}
WRITE_LONG_CHUNK(ID_FILT, &disp->filter_flags, 1);
WRITE_LONG_CHUNK(ID_FLEN, &global.flen, 1);
WRITE_LONG_CHUNK(ID_FHGT, &global.fheight, 1);
WRITE_LONG_CHUNK(ID_FCOL, &global.fog, 3);
WRITE_LONG_CHUNK(ID_FILD, &global.xmin, 4);
WRITE_LONG_CHUNK(ID_HSAM, &global.hyper_samples, 4);
WRITE_LONG_CHUNK(ID_HMIN, &global.hyper_min_dens, 4);
WRITE_LONG_CHUNK(ID_HMAX, &global.hyper_max_dens, 4);
POP_CHUNK();
PUSH_CHUNK(ID_SRFS);
WriteSurfaces(iff);
POP_CHUNK();
PUSH_CHUNK(ID_FRAM);
fdata[0] = 0.;
fdata[1] = 0.;
WRITE_LONG_CHUNK(ID_TIME, fdata, 2);
data[0] = 0;
if(global.quick)
data[0] |= RSCN_FRAME_QUICK;
if(global.randjit)
data[0] |= RSCN_FRAME_RANDJIT;
WRITE_LONG_CHUNK(ID_FLGS, data, 1);
WRITE_CHUNK(ID_CAMR, disp->camera->GetName(), strlen(disp->camera->GetName())+1);
WRITE_LONG_CHUNK(ID_AMBT, &global.ambient, 3);
WRITE_LONG_CHUNK(ID_ANTC, &global.anticont, 3);
WRITE_LONG_CHUNK(ID_ANTS, &global.antialias, 1);
WRITE_LONG_CHUNK(ID_BCKC, &global.backcol, 3);
WRITE_LONG_CHUNK(ID_MOBJ, &global.minobjects, 1);
if(global.backpic)
WRITE_CHUNK(ID_BCKP, global.backpic, strlen(global.backpic)+1);
if(global.reflmap)
WRITE_CHUNK(ID_REFM, global.reflmap, strlen(global.reflmap)+1);
ubdata = global.softshad;
WRITE_CHUNK(ID_SOFT, &ubdata, sizeof(UBYTE));
ubdata = global.distrib;
WRITE_CHUNK(ID_MBLR, &ubdata, sizeof(UBYTE));
ubdata = global.octreedepth;
WRITE_CHUNK(ID_ODPT, &ubdata, sizeof(UBYTE));
POP_CHUNK();
WriteObjects(iff,FALSE);
POP_CHUNK();
IFFCleanup(iff);
return NULL;
}
