static void AddLightGridLumps(FILE * file, xbspHeader_t * header)
{
int i;
bspGridPoint_t *in;
xbspGridPoint_t *buffer, *out;
/* dummy check */
if(bspGridPoints == NULL)
return;
/* allocate temporary buffer */
buffer = safe_malloc(numBSPGridPoints * sizeof(*out));
/* convert */
in = bspGridPoints;
out = buffer;
for(i = 0; i < numBSPGridPoints; i++)
{
VectorCopy(in->ambient[0], out->ambient);
VectorCopy(in->directed[0], out->directed);
out->latLong[0] = in->latLong[0];
out->latLong[1] = in->latLong[1];
in++;
out++;
}
/* write lumps */
AddLump(file, (bspHeader_t *) header, LUMP_LIGHTGRID, buffer, (numBSPGridPoints * sizeof(*out)));
/* free buffer (ydnar 2002-10-22: [bug 641] thanks Rap70r! */
free(buffer);
}
static void AddBrushSidesLump(FILE * file, xbspHeader_t * header)
{
int i, size;
bspBrushSide_t *in;
xbspBrushSide_t *buffer, *out;
/* allocate output buffer */
size = numBSPBrushSides * sizeof(*buffer);
buffer = safe_malloc(size);
memset(buffer, 0, size);
/* convert */
in = bspBrushSides;
out = buffer;
for(i = 0; i < numBSPBrushSides; i++)
{
out->planeNum = in->planeNum;
out->shaderNum = in->shaderNum;
in++;
out++;
}
/* write lump */
AddLump(file, (bspHeader_t *) header, LUMP_BRUSHSIDES, buffer, size);
/* free buffer */
free(buffer);
}
static void AddDrawVertsLump(FILE * file, xbspHeader_t * header)
{
int i, size;
bspDrawVert_t *in;
xbspDrawVert_t *buffer, *out;
/* allocate output buffer */
size = numBSPDrawVerts * sizeof(*buffer);
buffer = safe_malloc(size);
memset(buffer, 0, size);
/* convert */
in = bspDrawVerts;
out = buffer;
for(i = 0; i < numBSPDrawVerts; i++)
{
VectorCopy(in->xyz, out->xyz);
out->st[0] = in->st[0];
out->st[1] = in->st[1];
out->lightmap[0] = in->lightmap[0][0];
out->lightmap[1] = in->lightmap[0][1];
VectorCopy(in->normal, out->normal);
out->paintColor[0] = in->paintColor[0];
out->paintColor[1] = in->paintColor[1];
out->paintColor[2] = in->paintColor[2];
out->paintColor[3] = in->paintColor[3];
out->lightColor[0] = in->lightColor[0][0];
out->lightColor[1] = in->lightColor[0][1];
out->lightColor[2] = in->lightColor[0][2];
out->lightColor[3] = in->lightColor[0][3];
out->lightDirection[0] = in->lightDirection[0][0];
out->lightDirection[1] = in->lightDirection[0][1];
out->lightDirection[2] = in->lightDirection[0][2];
in++;
out++;
}
/* write lump */
AddLump(file, (bspHeader_t *) header, LUMP_DRAWVERTS, buffer, size);
/* free buffer */
free(buffer);
}
static void AddDrawSurfacesLump(FILE * file, xbspHeader_t * header)
{
int i, size;
bspDrawSurface_t *in;
xbspDrawSurface_t *buffer, *out;
/* allocate output buffer */
size = numBSPDrawSurfaces * sizeof(*buffer);
buffer = safe_malloc(size);
memset(buffer, 0, size);
/* convert */
in = bspDrawSurfaces;
out = buffer;
for(i = 0; i < numBSPDrawSurfaces; i++)
{
out->shaderNum = in->shaderNum;
out->fogNum = in->fogNum;
out->surfaceType = in->surfaceType;
out->firstVert = in->firstVert;
out->numVerts = in->numVerts;
out->firstIndex = in->firstIndex;
out->numIndexes = in->numIndexes;
out->lightmapNum = in->lightmapNum[0];
out->lightmapX = in->lightmapX[0];
out->lightmapY = in->lightmapY[0];
out->lightmapWidth = in->lightmapWidth;
out->lightmapHeight = in->lightmapHeight;
VectorCopy(in->lightmapOrigin, out->lightmapOrigin);
VectorCopy(in->lightmapVecs[0], out->lightmapVecs[0]);
VectorCopy(in->lightmapVecs[1], out->lightmapVecs[1]);
VectorCopy(in->lightmapVecs[2], out->lightmapVecs[2]);
out->patchWidth = in->patchWidth;
out->patchHeight = in->patchHeight;
in++;
out++;
}
/* write lump */
AddLump(file, (bspHeader_t *) header, LUMP_SURFACES, buffer, size);
/* free buffer */
free(buffer);
}
/*
===============
WriteLump
===============
*/
void WriteLump (int type, int compression)
{
int size;
if (!outputcreated)
CreateOutput ();
//
// dword align the size
//
while ((int)lump_p&3)
*lump_p++ = 0;
size = lump_p - lumpbuffer;
if (size > MAXLUMP)
Error ("Lump size exceeded %d, memory corrupted!",MAXLUMP);
//
// write the grabbed lump to the wadfile
//
AddLump (lumpname,lumpbuffer,size,type, compression);
}
/*
=============
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);
}
/*
=============
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);
}
void WriteXBSPFile(const char *filename)
{
xbspHeader_t outheader, *header;
FILE *file;
time_t t;
char marker[1024];
int size;
/* set header */
header = &outheader;
memset(header, 0, sizeof(*header));
//% Swapfile();
/* set up header */
*((int *)(bspHeader_t *) header->ident) = *((int *)game->bspIdent);
header->version = LittleLong(game->bspVersion);
/* write initial header */
file = SafeOpenWrite(filename);
SafeWrite(file, (bspHeader_t *) header, sizeof(*header)); /* overwritten later */
/* add marker lump */
time(&t);
sprintf(marker, "I LOVE MY OWMAP %s on %s)", Q3MAP_VERSION, asctime(localtime(&t)));
AddLump(file, (bspHeader_t *) header, 0, marker, strlen(marker) + 1);
/* add lumps */
AddLump(file, (bspHeader_t *) header, LUMP_SHADERS, bspShaders, numBSPShaders * sizeof(bspShader_t));
AddLump(file, (bspHeader_t *) header, LUMP_PLANES, bspPlanes, numBSPPlanes * sizeof(bspPlane_t));
AddLump(file, (bspHeader_t *) header, LUMP_LEAFS, bspLeafs, numBSPLeafs * sizeof(bspLeaf_t));
AddLump(file, (bspHeader_t *) header, LUMP_NODES, bspNodes, numBSPNodes * sizeof(bspNode_t));
AddLump(file, (bspHeader_t *) header, LUMP_BRUSHES, bspBrushes, numBSPBrushes * sizeof(bspBrush_t));
AddBrushSidesLump(file, header);
AddLump(file, (bspHeader_t *) header, LUMP_LEAFSURFACES, bspLeafSurfaces, numBSPLeafSurfaces * sizeof(bspLeafSurfaces[0]));
AddLump(file, (bspHeader_t *) header, LUMP_LEAFBRUSHES, bspLeafBrushes, numBSPLeafBrushes * sizeof(bspLeafBrushes[0]));
AddLump(file, (bspHeader_t *) header, LUMP_MODELS, bspModels, numBSPModels * sizeof(bspModel_t));
AddDrawVertsLump(file, header);
AddDrawSurfacesLump(file, header);
AddLump(file, (bspHeader_t *) header, LUMP_VISIBILITY, bspVisBytes, numBSPVisBytes);
AddLump(file, (bspHeader_t *) header, LUMP_LIGHTMAPS, bspLightBytes, numBSPLightBytes);
AddLightGridLumps(file, header);
AddLump(file, (bspHeader_t *) header, LUMP_ENTITIES, bspEntData, bspEntDataSize);
AddLump(file, (bspHeader_t *) header, LUMP_FOGS, bspFogs, numBSPFogs * sizeof(bspFog_t));
AddLump(file, (bspHeader_t *) header, LUMP_DRAWINDEXES, bspDrawIndexes, numBSPDrawIndexes * sizeof(bspDrawIndexes[0]));
/* emit bsp size */
size = ftell(file);
Sys_Printf("Wrote %.1f MB (%d bytes)\n", (float)size / (1024 * 1024), size);
/* write the completed header */
fseek(file, 0, SEEK_SET);
SafeWrite(file, header, sizeof(*header));
/* close the file */
fclose(file);
}
/*
=============
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 );
}
/**
* @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;
}
/*
=============
WriteBSPFile
=============
*/
void
WriteBSPFile(void)
{
FILE *f;
size_t ret;
header = AllocMem(OTHER, sizeof(dheader_t), true);
header->version = options.BSPVersion;
StripExtension(options.szBSPName);
strcat(options.szBSPName, ".bsp");
f = fopen(options.szBSPName, "wb");
if (!f)
Error("Failed to open %s: %s", options.szBSPName, strerror(errno));
/* write placeholder, header is overwritten later */
ret = fwrite(header, sizeof(dheader_t), 1, f);
if (ret != 1)
Error("Failure writing to file");
AddLump(f, LUMP_PLANES);
AddLump(f, LUMP_LEAFS);
AddLump(f, LUMP_VERTEXES);
AddLump(f, LUMP_NODES);
AddLump(f, LUMP_TEXINFO);
AddLump(f, LUMP_FACES);
AddLump(f, LUMP_CLIPNODES);
AddLump(f, LUMP_MARKSURFACES);
AddLump(f, LUMP_SURFEDGES);
AddLump(f, LUMP_EDGES);
AddLump(f, LUMP_MODELS);
AddLump(f, LUMP_LIGHTING);
AddLump(f, LUMP_VISIBILITY);
AddLump(f, LUMP_ENTITIES);
AddLump(f, LUMP_TEXTURES);
fseek(f, 0, SEEK_SET);
ret = fwrite(header, sizeof(dheader_t), 1, f);
if (ret != 1)
Error("Failure writing to file");
fclose(f);
FreeMem(header, OTHER, sizeof(dheader_t));
}
static void AddLightGridLumps( FILE *file, rbspHeader_t *header )
{
int i, j, k, c, d;
int numGridPoints, maxGridPoints;
bspGridPoint_t *gridPoints, *in, *out;
int numGridArray;
unsigned short *gridArray;
qboolean bad;
/* allocate temporary buffers */
maxGridPoints = (numBSPGridPoints < MAX_MAP_GRID) ? numBSPGridPoints : MAX_MAP_GRID;
gridPoints = safe_malloc( maxGridPoints * sizeof( *gridPoints ) );
gridArray = safe_malloc( numBSPGridPoints * sizeof( *gridArray ) );
/* zero out */
numGridPoints = 0;
numGridArray = numBSPGridPoints;
/* for each bsp grid point, find an approximate twin */
Sys_Printf( "Storing lightgrid: %d points\n", numBSPGridPoints );
for( i = 0; i < numGridArray; i++ )
{
/* get points */
in = &bspGridPoints[ i ];
/* walk existing list */
for( j = 0; j < numGridPoints; j++ )
{
/* get point */
out = &gridPoints[ j ];
/* compare styles */
if( *((unsigned int*) in->styles) != *((unsigned int*) out->styles) )
continue;
/* compare direction */
d = abs( in->latLong[ 0 ] - out->latLong[ 0 ] );
if( d < (255 - LG_EPSILON) && d > LG_EPSILON )
continue;
d = abs( in->latLong[ 1 ] - out->latLong[ 1 ] );
if( d < 255 - LG_EPSILON && d > LG_EPSILON )
continue;
/* compare light */
bad = qfalse;
for( k = 0; (k < MAX_LIGHTMAPS && bad == qfalse); k++ )
{
for( c = 0; c < 3; c++ )
{
if( abs( (int) in->ambient[ k ][ c ] - (int) out->ambient[ k ][ c ]) > LG_EPSILON ||
abs( (int) in->directed[ k ][ c ] - (int) out->directed[ k ][ c ]) > LG_EPSILON )
{
bad = qtrue;
break;
}
}
}
/* failure */
if( bad )
continue;
/* this sample is ok */
break;
}
/* set sample index */
gridArray[ i ] = (unsigned short) j;
/* if no sample found, add a new one */
if( j >= numGridPoints && numGridPoints < maxGridPoints )
{
out = &gridPoints[ numGridPoints++ ];
memcpy( out, in, sizeof( *in ) );
}
}
/* swap array */
for( i = 0; i < numGridArray; i++ )
gridArray[ i ] = LittleShort( gridArray[ i ] );
/* write lumps */
AddLump( file, (bspHeader_t*) header, LUMP_LIGHTGRID, gridPoints, (numGridPoints * sizeof( *gridPoints )) );
AddLump( file, (bspHeader_t*) header, LUMP_LIGHTARRAY, gridArray, (numGridArray * sizeof( *gridArray )) );
/* free buffers */
free( gridPoints );
free( gridArray );
}
