/*
=============
LoadBSPFileTexinfo
Only loads the texinfo lump, so qdata can scan for textures
=============
*/
void LoadBSPFileTexinfo( char *filename ){
int i;
FILE *f;
int length, ofs;
header = malloc( sizeof( dheader_t ) );
f = fopen( filename, "rb" );
fread( header, sizeof( dheader_t ), 1, f );
// swap the header
for ( i = 0 ; i < sizeof( dheader_t ) / 4 ; i++ )
( (int *)header )[i] = LittleLong( ( (int *)header )[i] );
if ( header->ident != IDBSPHEADER ) {
Error( "%s is not a IBSP file", filename );
}
if ( header->version != BSPVERSION ) {
Error( "%s is version %i, not %i", filename, header->version, BSPVERSION );
}
length = header->lumps[LUMP_TEXINFO].filelen;
ofs = header->lumps[LUMP_TEXINFO].fileofs;
fseek( f, ofs, SEEK_SET );
fread( texinfo, length, 1, f );
fclose( f );
numtexinfo = length / sizeof( texinfo_t );
free( header ); // everything has been copied out
SwapBSPFile( false );
}
/*
=============
WriteBSPFile
Swaps the bsp file in place, so it should not be referenced again
=============
*/
void WriteBSPFile (char *filename)
{
header = &outheader;
memset (header, 0, sizeof(dheader_t));
SwapBSPFile (true);
header->version = LittleLong (BSPVERSION);
wadfile = SafeOpenWrite (filename);
SafeWrite (wadfile, header, sizeof(dheader_t)); // overwritten later
AddLump (LUMP_PLANES, dplanes, numplanes*sizeof(dplane_t));
AddLump (LUMP_LEAFS, dleafs, numleafs*sizeof(dleaf_t));
AddLump (LUMP_VERTEXES, dvertexes, numvertexes*sizeof(dvertex_t));
AddLump (LUMP_NODES, dnodes, numnodes*sizeof(dnode_t));
AddLump (LUMP_TEXINFO, texinfo, numtexinfo*sizeof(texinfo_t));
AddLump (LUMP_FACES, dfaces, numfaces*sizeof(dface_t));
AddLump (LUMP_CLIPNODES, dclipnodes, numclipnodes*sizeof(dclipnode_t));
AddLump (LUMP_MARKSURFACES, dmarksurfaces, nummarksurfaces*sizeof(dmarksurfaces[0]));
AddLump (LUMP_SURFEDGES, dsurfedges, numsurfedges*sizeof(dsurfedges[0]));
AddLump (LUMP_EDGES, dedges, numedges*sizeof(dedge_t));
AddLump (LUMP_MODELS, dmodels, nummodels*sizeof(dmodel_t));
AddLump (LUMP_LIGHTING, dlightdata, lightdatasize);
AddLump (LUMP_VISIBILITY, dvisdata, visdatasize);
AddLump (LUMP_ENTITIES, dentdata, entdatasize);
AddLump (LUMP_TEXTURES, dtexdata, texdatasize);
fseek (wadfile, 0, SEEK_SET);
SafeWrite (wadfile, header, sizeof(dheader_t));
fclose (wadfile);
}
/**
* @sa WriteBSPFile
*/
dMapTile_t* LoadBSPFile (const char* filename)
{
dBspHeader_t* header;
/* Create this shortcut to mapTiles[0] */
curTile = &mapTiles.mapTiles[0];
/* Set the number of tiles to 1. */
mapTiles.numTiles = 1;
/* load the file header */
int size = FS_LoadFile(filename, (byte**)&header);
if (size == -1)
Sys_Error("'%s' doesn't exist", filename);
/* swap the header */
BSP_SwapHeader(header, filename);
if (header->ident != IDBSPHEADER)
Sys_Error("%s is not a IBSP file", filename);
if (header->version != BSPVERSION)
Sys_Error("%s is version %i, not %i", filename, header->version, BSPVERSION);
curTile->nummodels = CopyLump(header, LUMP_MODELS, curTile->models, sizeof(dBspModel_t));
curTile->numvertexes = CopyLump(header, LUMP_VERTEXES, curTile->vertexes, sizeof(dBspVertex_t));
curTile->numplanes = CopyLump(header, LUMP_PLANES, curTile->planes, sizeof(dBspPlane_t));
curTile->numleafs = CopyLump(header, LUMP_LEAFS, curTile->leafs, sizeof(dBspLeaf_t));
curTile->numnormals = CopyLump(header, LUMP_NORMALS, curTile->normals, sizeof(dBspNormal_t));
curTile->numnodes = CopyLump(header, LUMP_NODES, curTile->nodes, sizeof(dBspNode_t));
curTile->numtexinfo = CopyLump(header, LUMP_TEXINFO, curTile->texinfo, sizeof(dBspTexinfo_t));
curTile->numfaces = CopyLump(header, LUMP_FACES, curTile->faces, sizeof(dBspSurface_t));
curTile->numleafbrushes = CopyLump(header, LUMP_LEAFBRUSHES, curTile->leafbrushes, sizeof(curTile->leafbrushes[0]));
curTile->numsurfedges = CopyLump(header, LUMP_SURFEDGES, curTile->surfedges, sizeof(curTile->surfedges[0]));
curTile->numedges = CopyLump(header, LUMP_EDGES, curTile->edges, sizeof(dBspEdge_t));
curTile->numbrushes = CopyLump(header, LUMP_BRUSHES, curTile->dbrushes, sizeof(dBspBrush_t));
curTile->numbrushsides = CopyLump(header, LUMP_BRUSHSIDES, curTile->brushsides, sizeof(dBspBrushSide_t));
curTile->routedatasize = CopyLump(header, LUMP_ROUTING, curTile->routedata, 1);
curTile->lightdatasize[LIGHTMAP_NIGHT] = CopyLump(header, LUMP_LIGHTING_NIGHT, curTile->lightdata[LIGHTMAP_NIGHT], 1);
curTile->lightdatasize[LIGHTMAP_DAY] = CopyLump(header, LUMP_LIGHTING_DAY, curTile->lightdata[LIGHTMAP_DAY], 1);
curTile->entdatasize = CopyLump(header, LUMP_ENTITIES, curTile->entdata, 1);
/* Because the tracing functions use cBspBrush_t and not dBspBrush_t,
* copy data from curTile->dbrushes into curTile->cbrushes */
OBJZERO(curTile->brushes);
for (int i = 0; i < curTile->numbrushes; i++) {
dBspBrush_t* dbrush = &curTile->dbrushes[i];
cBspBrush_t* brush = &curTile->brushes[i];
brush->firstbrushside = dbrush->firstbrushside;
brush->numsides = dbrush->numsides;
brush->brushContentFlags = dbrush->brushContentFlags;
}
/* everything has been copied out */
FS_FreeFile(header);
/* swap everything */
SwapBSPFile();
return curTile;
}
/*
=============
LoadBSPFile
=============
*/
void LoadBSPFile (char *filename)
{
int i;
//
// load the file header
//
LoadFile (filename, (void **)&header);
// swap the header
for (i=0 ; i< sizeof(dheader_t)/4 ; i++)
((int *)header)[i] = LittleLong ( ((int *)header)[i]);
if (header->version != BSPVERSION)
Error ("%s is version %i, not %i", filename, header->version, BSPVERSION);
nummodels = CopyLump (LUMP_MODELS, dmodels, sizeof(dmodel_t));
numvertexes = CopyLump (LUMP_VERTEXES, dvertexes, sizeof(dvertex_t));
numplanes = CopyLump (LUMP_PLANES, dplanes, sizeof(dplane_t));
numleafs = CopyLump (LUMP_LEAFS, dleafs, sizeof(dleaf_t));
numnodes = CopyLump (LUMP_NODES, dnodes, sizeof(dnode_t));
numtexinfo = CopyLump (LUMP_TEXINFO, texinfo, sizeof(texinfo_t));
numclipnodes = CopyLump (LUMP_CLIPNODES, dclipnodes, sizeof(dclipnode_t));
numfaces = CopyLump (LUMP_FACES, dfaces, sizeof(dface_t));
nummarksurfaces = CopyLump (LUMP_MARKSURFACES, dmarksurfaces, sizeof(dmarksurfaces[0]));
numsurfedges = CopyLump (LUMP_SURFEDGES, dsurfedges, sizeof(dsurfedges[0]));
numedges = CopyLump (LUMP_EDGES, dedges, sizeof(dedge_t));
texdatasize = CopyLump (LUMP_TEXTURES, dtexdata, 1);
visdatasize = CopyLump (LUMP_VISIBILITY, dvisdata, 1);
lightdatasize = CopyLump (LUMP_LIGHTING, dlightdata, 1);
entdatasize = CopyLump (LUMP_ENTITIES, dentdata, 1);
free (header); // everything has been copied out
//
// swap everything
//
SwapBSPFile (false);
dmodels_checksum = FastChecksum( dmodels, nummodels*sizeof(dmodels[0]) );
dvertexes_checksum = FastChecksum( dvertexes, numvertexes*sizeof(dvertexes[0]) );
dplanes_checksum = FastChecksum( dplanes, numplanes*sizeof(dplanes[0]) );
dleafs_checksum = FastChecksum( dleafs, numleafs*sizeof(dleafs[0]) );
dnodes_checksum = FastChecksum( dnodes, numnodes*sizeof(dnodes[0]) );
texinfo_checksum = FastChecksum( texinfo, numtexinfo*sizeof(texinfo[0]) );
dclipnodes_checksum = FastChecksum( dclipnodes, numclipnodes*sizeof(dclipnodes[0]) );
dfaces_checksum = FastChecksum( dfaces, numfaces*sizeof(dfaces[0]) );
dmarksurfaces_checksum = FastChecksum( dmarksurfaces, nummarksurfaces*sizeof(dmarksurfaces[0]) );
dsurfedges_checksum = FastChecksum( dsurfedges, numsurfedges*sizeof(dsurfedges[0]) );
dedges_checksum = FastChecksum( dedges, numedges*sizeof(dedges[0]) );
dtexdata_checksum = FastChecksum( dtexdata, numedges*sizeof(dtexdata[0]) );
dvisdata_checksum = FastChecksum( dvisdata, visdatasize*sizeof(dvisdata[0]) );
dlightdata_checksum = FastChecksum( dlightdata, lightdatasize*sizeof(dlightdata[0]) );
dentdata_checksum = FastChecksum( dentdata, entdatasize*sizeof(dentdata[0]) );
}
/**
* @brief Swaps the bsp file in place, so it should not be referenced again
* @sa LoadBSPFile
*/
long WriteBSPFile (const char* filename)
{
dBspHeader_t outheader;
long size;
OBJZERO(outheader);
SwapBSPFile();
outheader.ident = LittleLong(IDBSPHEADER);
outheader.version = LittleLong(BSPVERSION);
ScopedFile bspfile;
FS_OpenFile(filename, &bspfile, FILE_WRITE);
if (!bspfile)
Sys_Error("Could not write bsp file");
FS_Write(&outheader, sizeof(outheader), &bspfile); /* overwritten later */
AddLump(&bspfile, &outheader, LUMP_PLANES, curTile->planes, curTile->numplanes * sizeof(dBspPlane_t));
AddLump(&bspfile, &outheader, LUMP_LEAFS, curTile->leafs, curTile->numleafs * sizeof(dBspLeaf_t));
AddLump(&bspfile, &outheader, LUMP_VERTEXES, curTile->vertexes, curTile->numvertexes * sizeof(dBspVertex_t));
AddLump(&bspfile, &outheader, LUMP_NORMALS, curTile->normals, curTile->numnormals * sizeof(dBspNormal_t));
AddLump(&bspfile, &outheader, LUMP_NODES, curTile->nodes, curTile->numnodes * sizeof(dBspNode_t));
AddLump(&bspfile, &outheader, LUMP_TEXINFO, curTile->texinfo, curTile->numtexinfo * sizeof(dBspTexinfo_t));
AddLump(&bspfile, &outheader, LUMP_FACES, curTile->faces, curTile->numfaces * sizeof(dBspSurface_t));
AddLump(&bspfile, &outheader, LUMP_BRUSHES, curTile->dbrushes, curTile->numbrushes * sizeof(dBspBrush_t));
AddLump(&bspfile, &outheader, LUMP_BRUSHSIDES, curTile->brushsides, curTile->numbrushsides * sizeof(dBspBrushSide_t));
AddLump(&bspfile, &outheader, LUMP_LEAFBRUSHES, curTile->leafbrushes, curTile->numleafbrushes * sizeof(curTile->leafbrushes[0]));
AddLump(&bspfile, &outheader, LUMP_SURFEDGES, curTile->surfedges, curTile->numsurfedges * sizeof(curTile->surfedges[0]));
AddLump(&bspfile, &outheader, LUMP_EDGES, curTile->edges, curTile->numedges * sizeof(dBspEdge_t));
AddLump(&bspfile, &outheader, LUMP_MODELS, curTile->models, curTile->nummodels * sizeof(dBspModel_t));
AddLump(&bspfile, &outheader, LUMP_LIGHTING_NIGHT, curTile->lightdata[0], curTile->lightdatasize[0]);
AddLump(&bspfile, &outheader, LUMP_LIGHTING_DAY, curTile->lightdata[1], curTile->lightdatasize[1]);
AddLump(&bspfile, &outheader, LUMP_ROUTING, curTile->routedata, curTile->routedatasize);
AddLump(&bspfile, &outheader, LUMP_ENTITIES, curTile->entdata, curTile->entdatasize);
size = ftell(bspfile.getFile());
fseek(bspfile.getFile(), 0L, SEEK_SET);
FS_Write(&outheader, sizeof(outheader), &bspfile);
SwapBSPFile();
return size;
}
void LoadBSPFile(const char *filename)
{
/* dummy check */
if(game == NULL || game->load == NULL)
Error("LoadBSPFile: unsupported BSP file format");
/* load it, then byte swap the in-memory version */
game->load(filename);
SwapBSPFile();
}
/*
=============
LoadBSPFile
=============
*/
void LoadBSPFile( const char *filename ) {
dheader_t *header;
// load the file header
LoadFile (filename, (void **)&header);
// swap the header
SwapBlock( (int *)header, sizeof(*header) );
if ( header->ident != BSP_IDENT ) {
Error( "%s is not a IBSP file", filename );
}
if ( header->version != BSP_VERSION ) {
Error( "%s is version %i, not %i", filename, header->version, BSP_VERSION );
}
numShaders = CopyLump( header, LUMP_SHADERS, dshaders, sizeof(dshader_t) );
nummodels = CopyLump( header, LUMP_MODELS, dmodels, sizeof(dmodel_t) );
numplanes = CopyLump( header, LUMP_PLANES, dplanes, sizeof(dplane_t) );
numleafs = CopyLump( header, LUMP_LEAFS, dleafs, sizeof(dleaf_t) );
numnodes = CopyLump( header, LUMP_NODES, dnodes, sizeof(dnode_t) );
numleafsurfaces = CopyLump( header, LUMP_LEAFSURFACES, dleafsurfaces, sizeof(dleafsurfaces[0]) );
numleafbrushes = CopyLump( header, LUMP_LEAFBRUSHES, dleafbrushes, sizeof(dleafbrushes[0]) );
numbrushes = CopyLump( header, LUMP_BRUSHES, dbrushes, sizeof(dbrush_t) );
numbrushsides = CopyLump( header, LUMP_BRUSHSIDES, dbrushsides, sizeof(dbrushside_t) );
numDrawVerts = CopyLump( header, LUMP_DRAWVERTS, drawVerts, sizeof(drawVert_t) );
numDrawSurfaces = CopyLump( header, LUMP_SURFACES, drawSurfaces, sizeof(dsurface_t) );
//numFogs = CopyLump( header, LUMP_FOGS, dfogs, sizeof(dfog_t) );
numDrawIndexes = CopyLump( header, LUMP_DRAWINDEXES, drawIndexes, sizeof(drawIndexes[0]) );
numVisBytes = CopyLump( header, LUMP_VISIBILITY, visBytes, 1 );
numLightBytes = CopyLump( header, LUMP_LIGHTMAPS, lightBytes, 1 );
entdatasize = CopyLump( header, LUMP_ENTITIES, dentdata, 1);
// numGridPoints = CopyLump( header, LUMP_LIGHTGRID, gridData, 8 );
// su44: MoHAA lumps
numStaticModels = CopyLump( header, LUMP_STATICMODELDEF, staticModels, sizeof(staticModels[0]));
numLeafStaticModels = CopyLump( header, LUMP_STATICMODELINDEXES, dleafStaticModels, sizeof(dleafStaticModels[0]));
numStaticModelVertColors = CopyLump( header, LUMP_STATICMODELDATA, staticModelVertColors, 3);
numTerraPatches = CopyLump( header, LUMP_TERRAIN, terraPatches, sizeof(terraPatches[0]));
numSideEquations = CopyLump( header, LUMP_SIDEEQUATIONS, sideEquations, sizeof(sideEquations[0]));
numSphereLights = CopyLump( header, LUMP_SPHERELIGHTS, sphereLights, sizeof(sphereLights[0]));
numLightDefs = CopyLump( header, LUMP_LIGHTDEFS, lightDefs, sizeof(lightDefs[0]));
free( header ); // everything has been copied out
// swap everything
SwapBSPFile();
}
void WriteBSPFile(const char *filename)
{
char tempname[1024];
time_t tm;
/* dummy check */
if(game == NULL || game->write == NULL)
Error("WriteBSPFile: unsupported BSP file format");
/* make fake temp name so existing bsp file isn't damaged in case write process fails */
time(&tm);
sprintf(tempname, "%s.%08X", filename, (int)tm);
/* byteswap, write the bsp, then swap back so it can be manipulated further */
SwapBSPFile();
game->write(tempname);
SwapBSPFile();
/* replace existing bsp file */
remove(filename);
rename(tempname, filename);
}
/*
=============
LoadBSPFile
=============
*/
void LoadBSPFile( char *filename ){
int i;
//
// load the file header
//
LoadFile( filename, (void **)&header );
// swap the header
for ( i = 0 ; i < sizeof( dheader_t ) / 4 ; i++ )
( (int *)header )[i] = LittleLong( ( (int *)header )[i] );
if ( header->ident != IDBSPHEADER ) {
Error( "%s is not a IBSP file", filename );
}
if ( header->version != BSPVERSION ) {
Error( "%s is version %i, not %i", filename, header->version, BSPVERSION );
}
nummodels = CopyLump( LUMP_MODELS, dmodels, sizeof( dmodel_t ) );
numvertexes = CopyLump( LUMP_VERTEXES, dvertexes, sizeof( dvertex_t ) );
numplanes = CopyLump( LUMP_PLANES, dplanes, sizeof( dplane_t ) );
numleafs = CopyLump( LUMP_LEAFS, dleafs, sizeof( dleaf_t ) );
numnodes = CopyLump( LUMP_NODES, dnodes, sizeof( dnode_t ) );
numtexinfo = CopyLump( LUMP_TEXINFO, texinfo, sizeof( texinfo_t ) );
numfaces = CopyLump( LUMP_FACES, dfaces, sizeof( dface_t ) );
numleaffaces = CopyLump( LUMP_LEAFFACES, dleaffaces, sizeof( dleaffaces[0] ) );
numleafbrushes = CopyLump( LUMP_LEAFBRUSHES, dleafbrushes, sizeof( dleafbrushes[0] ) );
numsurfedges = CopyLump( LUMP_SURFEDGES, dsurfedges, sizeof( dsurfedges[0] ) );
numedges = CopyLump( LUMP_EDGES, dedges, sizeof( dedge_t ) );
numbrushes = CopyLump( LUMP_BRUSHES, dbrushes, sizeof( dbrush_t ) );
numbrushsides = CopyLump( LUMP_BRUSHSIDES, dbrushsides, sizeof( dbrushside_t ) );
numareas = CopyLump( LUMP_AREAS, dareas, sizeof( darea_t ) );
numareaportals = CopyLump( LUMP_AREAPORTALS, dareaportals, sizeof( dareaportal_t ) );
visdatasize = CopyLump( LUMP_VISIBILITY, dvisdata, 1 );
lightdatasize = CopyLump( LUMP_LIGHTING, dlightdata, 1 );
entdatasize = CopyLump( LUMP_ENTITIES, dentdata, 1 );
CopyLump( LUMP_POP, dpop, 1 );
free( header ); // everything has been copied out
//
// swap everything
//
SwapBSPFile( false );
}
/*
=============
WriteBSPFile
Swaps the bsp file in place, so it should not be referenced again
=============
*/
void WriteBSPFile( const char *filename ) {
dheader_t outheader, *header;
FILE *bspfile;
header = &outheader;
memset( header, 0, sizeof(dheader_t) );
SwapBSPFile();
header->ident = LittleLong( BSP_IDENT );
header->version = LittleLong( BSP_VERSION );
bspfile = SafeOpenWrite( filename );
SafeWrite( bspfile, header, sizeof(dheader_t) ); // overwritten later
AddLump( bspfile, header, LUMP_SHADERS, dshaders, numShaders*sizeof(dshader_t) );
AddLump( bspfile, header, LUMP_PLANES, dplanes, numplanes*sizeof(dplane_t) );
AddLump( bspfile, header, LUMP_LEAFS, dleafs, numleafs*sizeof(dleaf_t) );
AddLump( bspfile, header, LUMP_NODES, dnodes, numnodes*sizeof(dnode_t) );
AddLump( bspfile, header, LUMP_BRUSHES, dbrushes, numbrushes*sizeof(dbrush_t) );
AddLump( bspfile, header, LUMP_BRUSHSIDES, dbrushsides, numbrushsides*sizeof(dbrushside_t) );
AddLump( bspfile, header, LUMP_LEAFSURFACES, dleafsurfaces, numleafsurfaces*sizeof(dleafsurfaces[0]) );
AddLump( bspfile, header, LUMP_LEAFBRUSHES, dleafbrushes, numleafbrushes*sizeof(dleafbrushes[0]) );
AddLump( bspfile, header, LUMP_MODELS, dmodels, nummodels*sizeof(dmodel_t) );
AddLump( bspfile, header, LUMP_DRAWVERTS, drawVerts, numDrawVerts*sizeof(drawVert_t) );
AddLump( bspfile, header, LUMP_SURFACES, drawSurfaces, numDrawSurfaces*sizeof(dsurface_t) );
AddLump( bspfile, header, LUMP_VISIBILITY, visBytes, numVisBytes );
AddLump( bspfile, header, LUMP_LIGHTMAPS, lightBytes, numLightBytes );
// AddLump( bspfile, header, LUMP_LIGHTGRID, gridData, 8 * numGridPoints );
AddLump( bspfile, header, LUMP_ENTITIES, dentdata, entdatasize );
// AddLump( bspfile, header, LUMP_FOGS, dfogs, numFogs * sizeof(dfog_t) );
AddLump( bspfile, header, LUMP_DRAWINDEXES, drawIndexes, numDrawIndexes * sizeof(drawIndexes[0]) );
// su44: MoHAA lumps
AddLump( bspfile, header, LUMP_STATICMODELDEF, staticModels, numStaticModels * sizeof(staticModels[0]) );
AddLump( bspfile, header, LUMP_STATICMODELINDEXES, staticModels, numLeafStaticModels * sizeof(dleafStaticModels[0]) );
AddLump( bspfile, header, LUMP_STATICMODELDATA, staticModelVertColors, numStaticModelVertColors * 3 );
AddLump( bspfile, header, LUMP_TERRAIN, terraPatches, numTerraPatches * sizeof(terraPatches[0]) );
AddLump( bspfile, header, LUMP_SIDEEQUATIONS, sideEquations, numSideEquations * sizeof(sideEquations[0]) );
AddLump( bspfile, header, LUMP_SPHERELIGHTS, sphereLights, numSphereLights * sizeof(sphereLights[0]) );
AddLump( bspfile, header, LUMP_LIGHTDEFS, lightDefs, numLightDefs * sizeof(lightDefs[0]) );
fseek (bspfile, 0, SEEK_SET);
SafeWrite (bspfile, header, sizeof(dheader_t));
fclose (bspfile);
}
/*
* =============
* LoadBSPFile
* =============
*/
int
LoadBSPFile(const char *filename)
{
int i, bsp_version;
/* load the file header */
LoadFile(filename, (void *)&header);
/* swap the header */
for (i = 0; i < sizeof(dheader_t) / 4; i++)
((int *)header)[i] = LittleLong(((int *)header)[i]);
bsp_version = (int)header->version;
logprint("BSP is version %i\n", bsp_version);
if (bsp_version != 29 && bsp_version != 30)
Error("Sorry, only bsp versions 29 & 30 supported.");
nummodels = CopyLump(LUMP_MODELS, dmodels, sizeof(dmodel_t));
numvertexes = CopyLump(LUMP_VERTEXES, dvertexes, sizeof(dvertex_t));
numplanes = CopyLump(LUMP_PLANES, dplanes, sizeof(dplane_t));
numleafs = CopyLump(LUMP_LEAFS, dleafs, sizeof(dleaf_t));
numnodes = CopyLump(LUMP_NODES, dnodes, sizeof(dnode_t));
numtexinfo = CopyLump(LUMP_TEXINFO, texinfo, sizeof(texinfo_t));
numclipnodes = CopyLump(LUMP_CLIPNODES, dclipnodes, sizeof(dclipnode_t));
numfaces = CopyLump(LUMP_FACES, dfaces, sizeof(dface_t));
nummarksurfaces = CopyLump(LUMP_MARKSURFACES, dmarksurfaces,
sizeof(dmarksurfaces[0]));
numsurfedges = CopyLump(LUMP_SURFEDGES, dsurfedges,
sizeof(dsurfedges[0]));
numedges = CopyLump(LUMP_EDGES, dedges, sizeof(dedge_t));
texdatasize = CopyLump(LUMP_TEXTURES, dtexdata, 1);
visdatasize = CopyLump(LUMP_VISIBILITY, dvisdata, 1);
lightdatasize = CopyLump(LUMP_LIGHTING, dlightdata, 1);
entdatasize = CopyLump(LUMP_ENTITIES, dentdata, 1);
free(header); /* everything has been copied out */
/* swap everything */
SwapBSPFile(false);
/* Return the version */
return bsp_version;
}
/*
=============
LoadBSPFile
=============
*/
bool LoadBSPFile( const char *filename ) {
dheader_t *header;
// load the file header
if(!LoadFile (filename, (byte **)&header))
return false;
// swap the header
SwapBlock( (int *)header, sizeof(*header) );
if ( header->ident != BSP_IDENT ) {
DoMessageBox( "Cant find a valid IBSP file", "Error", eMB_OK);
return false;
}
if ( (header->version != Q3_BSP_VERSION) &&
(header->version != WOLF_BSP_VERSION) ) {
DoMessageBox( "File is incorrect version", "Error", eMB_OK);
return false;
}
numbrushsides = CopyLump( header, LUMP_BRUSHES, (void**)&dbrushsides, sizeof(dbrushside_t) );
numbrushes = CopyLump( header, LUMP_BRUSHES, (void**)&dbrushes, sizeof(dbrush_t) );
numplanes = CopyLump( header, LUMP_PLANES, (void**)&dplanes, sizeof(dplane_t) );
numleafs = CopyLump( header, LUMP_LEAFS, (void**)&dleafs, sizeof(dleaf_t) );
numnodes = CopyLump( header, LUMP_NODES, (void**)&dnodes, sizeof(dnode_t) );
numDrawVerts = CopyLump( header, LUMP_DRAWVERTS, (void**)&drawVerts, sizeof(qdrawVert_t) );
numDrawSurfaces = CopyLump( header, LUMP_SURFACES, (void**)&drawSurfaces, sizeof(dsurface_t) );
numleafsurfaces = CopyLump( header, LUMP_LEAFSURFACES, (void**)&dleafsurfaces, sizeof(int) );
numVisBytes = CopyLump( header, LUMP_VISIBILITY, (void**)&visBytes, 1 );
numleafbrushes = CopyLump( header, LUMP_LEAFBRUSHES, (void**)&dleafbrushes, sizeof(int) );
delete header; // everything has been copied out
// swap everything
SwapBSPFile();
return true;
}
/*
=============
WriteBSPFile
Swaps the bsp file in place, so it should not be referenced again
=============
*/
void WriteBSPFile(char *filename)
{
header = &outheader;
memset(header, 0, sizeof(dheader_t));
SwapBSPFile(true);
header->ident = LittleLong(IDBSPHEADER);
header->version = LittleLong(BSPVERSION);
wadfile = SafeOpenWrite(filename);
SafeWrite(wadfile, header, sizeof(dheader_t)); // overwritten later
AddLump(LUMP_PLANES, dplanes, numplanes * sizeof(dplane_t));
AddLump(LUMP_LEAFS, dleafs, numleafs * sizeof(dleaf_t));
AddLump(LUMP_VERTEXES, dvertexes, numvertexes * sizeof(dvertex_t));
AddLump(LUMP_NODES, dnodes, numnodes * sizeof(dnode_t));
AddLump(LUMP_TEXINFO, texinfo, numtexinfo * sizeof(texinfo_t));
AddLump(LUMP_FACES, dfaces, numfaces * sizeof(dface_t));
AddLump(LUMP_BRUSHES, dbrushes, numbrushes * sizeof(dbrush_t));
AddLump(LUMP_BRUSHSIDES, dbrushsides, numbrushsides * sizeof(dbrushside_t));
AddLump(LUMP_LEAFFACES, dleaffaces, numleaffaces * sizeof(dleaffaces[0]));
AddLump(LUMP_LEAFBRUSHES, dleafbrushes, numleafbrushes * sizeof(dleafbrushes[0]));
AddLump(LUMP_SURFEDGES, dsurfedges, numsurfedges * sizeof(dsurfedges[0]));
AddLump(LUMP_EDGES, dedges, numedges * sizeof(dedge_t));
AddLump(LUMP_MODELS, dmodels, nummodels * sizeof(dmodel_t));
AddLump(LUMP_AREAS, dareas, numareas * sizeof(darea_t));
AddLump(LUMP_AREAPORTALS, dareaportals, numareaportals * sizeof(dareaportal_t));
AddLump(LUMP_LIGHTING, dlightdata, lightdatasize);
AddLump(LUMP_VISIBILITY, dvisdata, visdatasize);
AddLump(LUMP_ENTITIES, dentdata, entdatasize);
AddLump(LUMP_POP, dpop, sizeof(dpop));
fseek(wadfile, 0, SEEK_SET);
SafeWrite(wadfile, header, sizeof(dheader_t));
fclose(wadfile);
}
