quick/netradiant-custom
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

remove unused stuff

Browse Source
This commit is contained in:
Garux 2021-09-27 15:12:53 +03:00
parent ecf9a46e78
commit efa324ebe6
11 changed files with 84 additions and 263 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
tools/quake3/common/bspfile.cpp
View File

@ -95,7 +95,7 @@ void SetLightBytes( int n ){
return; return;
} }
lightBytes = safe_calloc_info( numLightBytes, "SetLightBytes" ); lightBytes = safe_calloc( numLightBytes );
} }
void SetGridPoints( int n ){ void SetGridPoints( int n ){
@ -107,7 +107,7 @@ void SetGridPoints( int n ){
return; return;
} }
gridData = safe_calloc_info( numGridPoints * 8, "SetGridPoints" ); gridData = safe_calloc( numGridPoints * 8 );
} }
void IncDrawVerts(){ void IncDrawVerts(){
@ -116,7 +116,7 @@ void IncDrawVerts(){
if ( drawVerts == 0 ) { if ( drawVerts == 0 ) {
numDrawVertsBuffer = MAX_MAP_DRAW_VERTS / 37; numDrawVertsBuffer = MAX_MAP_DRAW_VERTS / 37;
drawVerts = safe_malloc_info( sizeof( drawVert_t ) * numDrawVertsBuffer, "IncDrawVerts" ); drawVerts = safe_malloc( sizeof( drawVert_t ) * numDrawVertsBuffer );
} }
else if ( numDrawVerts > numDrawVertsBuffer ) { else if ( numDrawVerts > numDrawVertsBuffer ) {
@ -143,7 +143,7 @@ void SetDrawVerts( int n ){
numDrawVerts = numDrawVerts =
numDrawVertsBuffer = n; numDrawVertsBuffer = n;
drawVerts = safe_calloc_info( sizeof( drawVert_t ) * numDrawVertsBuffer, "IncDrawVerts" ); drawVerts = safe_calloc( sizeof( drawVert_t ) * numDrawVertsBuffer );
} }
void SetDrawSurfacesBuffer(){ void SetDrawSurfacesBuffer(){
@ -151,7 +151,7 @@ void SetDrawSurfacesBuffer(){
numDrawSurfacesBuffer = MAX_MAP_DRAW_SURFS; numDrawSurfacesBuffer = MAX_MAP_DRAW_SURFS;
drawSurfaces = safe_calloc_info( sizeof( dsurface_t ) * numDrawSurfacesBuffer, "IncDrawSurfaces" ); drawSurfaces = safe_calloc( sizeof( dsurface_t ) * numDrawSurfacesBuffer );
} }
void SetDrawSurfaces( int n ){ void SetDrawSurfaces( int n ){
@ -160,7 +160,7 @@ void SetDrawSurfaces( int n ){
numDrawSurfaces = numDrawSurfaces =
numDrawSurfacesBuffer = n; numDrawSurfacesBuffer = n;
drawSurfaces = safe_calloc_info( sizeof( dsurface_t ) * numDrawSurfacesBuffer, "IncDrawSurfaces" ); drawSurfaces = safe_calloc( sizeof( dsurface_t ) * numDrawSurfacesBuffer );
} }
void BspFilesCleanup(){ void BspFilesCleanup(){

18
tools/quake3/common/cmdlib.cpp
View File

@ -47,7 +47,6 @@
#define BASEDIRNAME "quake" // assumed to have a 2 or 3 following #define BASEDIRNAME "quake" // assumed to have a 2 or 3 following
#ifdef SAFE_MALLOC
void_ptr safe_malloc( size_t size ){ void_ptr safe_malloc( size_t size ){
void *p = malloc( size ); void *p = malloc( size );
if ( !p ) { if ( !p ) {
@ -56,14 +55,6 @@ void_ptr safe_malloc( size_t size ){
return p; return p;
} }
void_ptr safe_malloc_info( size_t size, const char* info ){
void *p = malloc( size );
if ( !p ) {
Error( "%s: safe_malloc failed on allocation of %zu bytes", info, size );
}
return p;
}
void_ptr safe_calloc( size_t size ){ void_ptr safe_calloc( size_t size ){
void *p = calloc( 1, size ); void *p = calloc( 1, size );
if ( !p ) { if ( !p ) {
@ -72,15 +63,6 @@ void_ptr safe_calloc( size_t size ){
return p; return p;
} }
void_ptr safe_calloc_info( size_t size, const char* info ){
void *p = calloc( 1, size );
if ( !p ) {
Error( "%s: safe_calloc failed on allocation of %zu bytes", info, size );
}
return p;
}
#endif
/* /*
=================== ===================

11
tools/quake3/common/cmdlib.h
View File

@ -29,9 +29,6 @@
#include <stdlib.h> #include <stdlib.h>
#define SAFE_MALLOC
#ifdef SAFE_MALLOC
class void_ptr class void_ptr
{ {
private: private:
@ -46,15 +43,7 @@ public:
}; };
void_ptr safe_malloc( size_t size ); void_ptr safe_malloc( size_t size );
void_ptr safe_malloc_info( size_t size, const char* info );
void_ptr safe_calloc( size_t size ); void_ptr safe_calloc( size_t size );
void_ptr safe_calloc_info( size_t size, const char* info );
#else
#define safe_malloc( size ) malloc( size )
#define safe_malloc_info( size, info ) malloc( size )
#define safe_calloc( size ) calloc( 1, size )
#define safe_calloc_info( size, info ) calloc( 1, size )
#endif /* SAFE_MALLOC */
#define offsetof_array( TYPE, ARRAY_MEMBER, ARRAY_SIZE ) ( offsetof( TYPE, ARRAY_MEMBER[0] ) + sizeof( TYPE::ARRAY_MEMBER[0] ) * ARRAY_SIZE ) #define offsetof_array( TYPE, ARRAY_MEMBER, ARRAY_SIZE ) ( offsetof( TYPE, ARRAY_MEMBER[0] ) + sizeof( TYPE::ARRAY_MEMBER[0] ) * ARRAY_SIZE )

4
tools/quake3/common/imagelib.cpp
View File

@ -519,7 +519,7 @@ void LoadPCX( const char *filename, byte **pic, byte **palette, int *width, int
return; return;
} }
out = safe_malloc_info( ( pcx->ymax + 1 ) * ( pcx->xmax + 1 ), "LoadPCX" ); out = safe_malloc( ( pcx->ymax + 1 ) * ( pcx->xmax + 1 ) );
*pic = out; *pic = out;
pix = out; pix = out;
@ -1003,7 +1003,7 @@ void LoadTGABuffer( const byte *f, const byte *enddata, byte **pic, int *width,
return; return;
} }
image_rgba = safe_malloc_info( image_width * image_height * 4, "LoadTGABuffer" ); image_rgba = safe_malloc( image_width * image_height * 4 );
// If bit 5 of attributes isn't set, the image has been stored from bottom to top // If bit 5 of attributes isn't set, the image has been stored from bottom to top
if ( ( targa_header.attributes & 0x20 ) == 0 ) { if ( ( targa_header.attributes & 0x20 ) == 0 ) {

95
tools/quake3/q3map2/bspfile_abstract.cpp
View File

@ -184,101 +184,6 @@ void SwapBSPFile( void ){
} }
} }
/*
GetLumpElements()
gets the number of elements in a bsp lump
*/
int GetLumpElements( bspHeader_t *header, int lump, int size ){
/* check for odd size */
if ( header->lumps[ lump ].length % size ) {
if ( force ) {
Sys_Warning( "GetLumpElements: odd lump size (%d) in lump %d\n", header->lumps[ lump ].length, lump );
return 0;
}
else{
Error( "GetLumpElements: odd lump size (%d) in lump %d", header->lumps[ lump ].length, lump );
}
}
/* return element count */
return header->lumps[ lump ].length / size;
}
/*
GetLump()
returns a pointer to the specified lump
*/
void_ptr GetLump( bspHeader_t *header, int lump ){
return (void*)( (byte*) header + header->lumps[ lump ].offset );
}
/*
CopyLump()
copies a bsp file lump into a destination buffer
*/
int CopyLump( bspHeader_t *header, int lump, void *dest, int size ){
int length, offset;
/* get lump length and offset */
length = header->lumps[ lump ].length;
offset = header->lumps[ lump ].offset;
/* handle erroneous cases */
if ( length == 0 ) {
return 0;
}
if ( length % size ) {
if ( force ) {
Sys_Warning( "CopyLump: odd lump size (%d) in lump %d\n", length, lump );
return 0;
}
else{
Error( "CopyLump: odd lump size (%d) in lump %d", length, lump );
}
}
/* copy block of memory and return */
memcpy( dest, (byte*) header + offset, length );
return length / size;
}
int CopyLump_Allocate( bspHeader_t *header, int lump, void **dest, int size, int *allocationVariable ){
/* get lump length and offset */
*allocationVariable = header->lumps[ lump ].length / size;
*dest = realloc( *dest, size * *allocationVariable );
return CopyLump( header, lump, *dest, size );
}
/*
AddLump()
adds a lump to an outgoing bsp file
*/
void AddLump( FILE *file, bspHeader_t *header, int lumpNum, const void *data, int length ){
bspLump_t *lump;
/* add lump to bsp file header */
lump = &header->lumps[ lumpNum ];
lump->offset = LittleLong( ftell( file ) );
lump->length = LittleLong( length );
/* write lump to file */
SafeWrite( file, data, length );
/* write padding zeros */
SafeWrite( file, std::array<byte, 3>{}.data(), ( ( length + 3 ) & ~3 ) - length );
}
/* /*
LoadBSPFile() LoadBSPFile()

4
tools/quake3/q3map2/bspfile_abstract.h
View File

@ -62,12 +62,14 @@ void CopyLump( bspHeader_t *header, int lump, std::vector<DstT>& data ){
const int offset = header->lumps[ lump ].offset; const int offset = header->lumps[ lump ].offset;
/* handle erroneous cases */ /* handle erroneous cases */
if ( length == 0 ) { if ( length <= 0 ) {
data.clear();
return; return;
} }
if ( length % sizeof( SrcT ) ) { if ( length % sizeof( SrcT ) ) {
if ( force ) { if ( force ) {
Sys_Warning( "CopyLump: odd lump size (%d) in lump %d\n", length, lump ); Sys_Warning( "CopyLump: odd lump size (%d) in lump %d\n", length, lump );
data.clear();
return; return;
} }
else{ else{

98
tools/quake3/q3map2/bspfile_ibsp.cpp
View File

@ -220,10 +220,10 @@ void LoadIBSPFile( const char *filename ){
LoadFile( filename, (void**) &header ); LoadFile( filename, (void**) &header );
/* swap the header (except the first 4 bytes) */ /* swap the header (except the first 4 bytes) */
SwapBlock( (int*) ( (byte*) header + sizeof( int ) ), sizeof( *header ) - sizeof( int ) ); SwapBlock( (int*) ( (byte*) header + 4 ), sizeof( *header ) - 4 );
/* make sure it matches the format we're trying to load */ /* make sure it matches the format we're trying to load */
if ( !force && *( (int*) header->ident ) != *( (const int*) g_game->bspIdent ) ) { if ( !force && (const int&) header->ident != (const int&) g_game->bspIdent ) {
Error( "%s is not a %s file", filename, g_game->bspIdent ); Error( "%s is not a %s file", filename, g_game->bspIdent );
} }
if ( !force && header->version != g_game->bspVersion ) { if ( !force && header->version != g_game->bspVersion ) {
@ -232,37 +232,21 @@ void LoadIBSPFile( const char *filename ){
/* load/convert lumps */ /* load/convert lumps */
CopyLump( (bspHeader_t*) header, LUMP_SHADERS, bspShaders ); CopyLump( (bspHeader_t*) header, LUMP_SHADERS, bspShaders );
CopyLump( (bspHeader_t*) header, LUMP_MODELS, bspModels ); CopyLump( (bspHeader_t*) header, LUMP_MODELS, bspModels );
CopyLump( (bspHeader_t*) header, LUMP_PLANES, bspPlanes ); CopyLump( (bspHeader_t*) header, LUMP_PLANES, bspPlanes );
CopyLump( (bspHeader_t*) header, LUMP_LEAFS, bspLeafs ); CopyLump( (bspHeader_t*) header, LUMP_LEAFS, bspLeafs );
CopyLump( (bspHeader_t*) header, LUMP_NODES, bspNodes ); CopyLump( (bspHeader_t*) header, LUMP_NODES, bspNodes );
CopyLump( (bspHeader_t*) header, LUMP_LEAFSURFACES, bspLeafSurfaces ); CopyLump( (bspHeader_t*) header, LUMP_LEAFSURFACES, bspLeafSurfaces );
CopyLump( (bspHeader_t*) header, LUMP_LEAFBRUSHES, bspLeafBrushes ); CopyLump( (bspHeader_t*) header, LUMP_LEAFBRUSHES, bspLeafBrushes );
CopyLump( (bspHeader_t*) header, LUMP_BRUSHES, bspBrushes ); CopyLump( (bspHeader_t*) header, LUMP_BRUSHES, bspBrushes );
CopyLump<bspBrushSide_t, ibspBrushSide_t>( (bspHeader_t*) header, LUMP_BRUSHSIDES, bspBrushSides ); CopyLump<bspBrushSide_t, ibspBrushSide_t>( (bspHeader_t*) header, LUMP_BRUSHSIDES, bspBrushSides );
CopyLump<bspDrawVert_t, ibspDrawVert_t>( (bspHeader_t*) header, LUMP_DRAWVERTS, bspDrawVerts ); CopyLump<bspDrawVert_t, ibspDrawVert_t>( (bspHeader_t*) header, LUMP_DRAWVERTS, bspDrawVerts );
CopyLump<bspDrawSurface_t, ibspDrawSurface_t>( (bspHeader_t*) header, LUMP_SURFACES, bspDrawSurfaces ); CopyLump<bspDrawSurface_t, ibspDrawSurface_t>( (bspHeader_t*) header, LUMP_SURFACES, bspDrawSurfaces );
CopyLump( (bspHeader_t*) header, LUMP_FOGS, bspFogs ); CopyLump( (bspHeader_t*) header, LUMP_FOGS, bspFogs );
CopyLump( (bspHeader_t*) header, LUMP_DRAWINDEXES, bspDrawIndexes ); CopyLump( (bspHeader_t*) header, LUMP_DRAWINDEXES, bspDrawIndexes );
CopyLump( (bspHeader_t*) header, LUMP_VISIBILITY, bspVisBytes ); CopyLump( (bspHeader_t*) header, LUMP_VISIBILITY, bspVisBytes );
CopyLump( (bspHeader_t*) header, LUMP_LIGHTMAPS, bspLightBytes ); CopyLump( (bspHeader_t*) header, LUMP_LIGHTMAPS, bspLightBytes );
CopyLump( (bspHeader_t*) header, LUMP_ENTITIES, bspEntData ); CopyLump( (bspHeader_t*) header, LUMP_ENTITIES, bspEntData );
CopyLump<bspGridPoint_t, ibspGridPoint_t>( (bspHeader_t*) header, LUMP_LIGHTGRID, bspGridPoints ); CopyLump<bspGridPoint_t, ibspGridPoint_t>( (bspHeader_t*) header, LUMP_LIGHTGRID, bspGridPoints );
/* advertisements */ /* advertisements */
@ -290,10 +274,10 @@ void PartialLoadIBSPFile( const char *filename ){
LoadFile( filename, (void**) &header ); LoadFile( filename, (void**) &header );
/* swap the header (except the first 4 bytes) */ /* swap the header (except the first 4 bytes) */
SwapBlock( (int*) ( (byte*) header + sizeof( int ) ), sizeof( *header ) - sizeof( int ) ); SwapBlock( (int*) ( (byte*) header + 4 ), sizeof( *header ) - 4 );
/* make sure it matches the format we're trying to load */ /* make sure it matches the format we're trying to load */
if ( !force && *( (int*) header->ident ) != *( (const int*) g_game->bspIdent ) ) { if ( !force && (const int&) header->ident != (const int&) g_game->bspIdent ) {
Error( "%s is not a %s file", filename, g_game->bspIdent ); Error( "%s is not a %s file", filename, g_game->bspIdent );
} }
if ( !force && header->version != g_game->bspVersion ) { if ( !force && header->version != g_game->bspVersion ) {
@ -302,11 +286,8 @@ void PartialLoadIBSPFile( const char *filename ){
/* load/convert lumps */ /* load/convert lumps */
CopyLump( (bspHeader_t*) header, LUMP_SHADERS, bspShaders ); CopyLump( (bspHeader_t*) header, LUMP_SHADERS, bspShaders );
CopyLump<bspDrawSurface_t, ibspDrawSurface_t>( (bspHeader_t*) header, LUMP_SURFACES, bspDrawSurfaces ); CopyLump<bspDrawSurface_t, ibspDrawSurface_t>( (bspHeader_t*) header, LUMP_SURFACES, bspDrawSurfaces );
CopyLump( (bspHeader_t*) header, LUMP_FOGS, bspFogs ); CopyLump( (bspHeader_t*) header, LUMP_FOGS, bspFogs );
CopyLump( (bspHeader_t*) header, LUMP_ENTITIES, bspEntData ); CopyLump( (bspHeader_t*) header, LUMP_ENTITIES, bspEntData );
/* free the file buffer */ /* free the file buffer */
@ -319,62 +300,55 @@ void PartialLoadIBSPFile( const char *filename ){
*/ */
void WriteIBSPFile( const char *filename ){ void WriteIBSPFile( const char *filename ){
ibspHeader_t outheader, *header; ibspHeader_t header{};
FILE *file;
time_t t;
char marker[ 1024 ];
int size;
/* set header */
header = &outheader;
memset( header, 0, sizeof( *header ) );
//% Swapfile(); //% Swapfile();
/* set up header */ /* set up header */
*( (int*) (bspHeader_t*) header->ident ) = *( (const int*) g_game->bspIdent ); (int&) header.ident = (const int&) g_game->bspIdent;
header->version = LittleLong( g_game->bspVersion ); header.version = LittleLong( g_game->bspVersion );
/* write initial header */ /* write initial header */
file = SafeOpenWrite( filename ); FILE *file = SafeOpenWrite( filename );
SafeWrite( file, (bspHeader_t*) header, sizeof( *header ) ); /* overwritten later */ SafeWrite( file, &header, sizeof( header ) ); /* overwritten later */
/* add marker lump */ { /* add marker lump */
time( &t ); time_t t;
/* asctime adds an implicit trailing \n */ time( &t );
sprintf( marker, "I LOVE MY Q3MAP2 %s on %s", Q3MAP_VERSION, asctime( localtime( &t ) ) ); /* asctime adds an implicit trailing \n */
AddLump( file, (bspHeader_t*) header, 0, marker, strlen( marker ) + 1 ); const auto marker = StringOutputStream( 256 )( "I LOVE MY Q3MAP2 ", Q3MAP_VERSION, " on ", asctime( localtime( &t ) ) );
AddLump( file, header.lumps[0], std::vector<char>( marker.begin(), marker.end() + 1 ) );
}
/* add lumps */ /* add lumps */
AddLump( file, header->lumps[LUMP_SHADERS], bspShaders ); AddLump( file, header.lumps[LUMP_SHADERS], bspShaders );
AddLump( file, header->lumps[LUMP_PLANES], bspPlanes ); AddLump( file, header.lumps[LUMP_PLANES], bspPlanes );
AddLump( file, header->lumps[LUMP_LEAFS], bspLeafs ); AddLump( file, header.lumps[LUMP_LEAFS], bspLeafs );
AddLump( file, header->lumps[LUMP_NODES], bspNodes ); AddLump( file, header.lumps[LUMP_NODES], bspNodes );
AddLump( file, header->lumps[LUMP_BRUSHES], bspBrushes ); AddLump( file, header.lumps[LUMP_BRUSHES], bspBrushes );
AddLump( file, header->lumps[LUMP_BRUSHSIDES], std::vector<ibspBrushSide_t>( bspBrushSides.begin(), bspBrushSides.end() ) ); AddLump( file, header.lumps[LUMP_BRUSHSIDES], std::vector<ibspBrushSide_t>( bspBrushSides.begin(), bspBrushSides.end() ) );
AddLump( file, header->lumps[LUMP_LEAFSURFACES], bspLeafSurfaces ); AddLump( file, header.lumps[LUMP_LEAFSURFACES], bspLeafSurfaces );
AddLump( file, header->lumps[LUMP_LEAFBRUSHES], bspLeafBrushes ); AddLump( file, header.lumps[LUMP_LEAFBRUSHES], bspLeafBrushes );
AddLump( file, header->lumps[LUMP_MODELS], bspModels ); AddLump( file, header.lumps[LUMP_MODELS], bspModels );
AddLump( file, header->lumps[LUMP_DRAWVERTS], std::vector<ibspDrawVert_t>( bspDrawVerts.begin(), bspDrawVerts.end() ) ); AddLump( file, header.lumps[LUMP_DRAWVERTS], std::vector<ibspDrawVert_t>( bspDrawVerts.begin(), bspDrawVerts.end() ) );
AddLump( file, header->lumps[LUMP_SURFACES], std::vector<ibspDrawSurface_t>( bspDrawSurfaces.begin(), bspDrawSurfaces.end() ) ); AddLump( file, header.lumps[LUMP_SURFACES], std::vector<ibspDrawSurface_t>( bspDrawSurfaces.begin(), bspDrawSurfaces.end() ) );
AddLump( file, header->lumps[LUMP_VISIBILITY], bspVisBytes ); AddLump( file, header.lumps[LUMP_VISIBILITY], bspVisBytes );
AddLump( file, header->lumps[LUMP_LIGHTMAPS], bspLightBytes ); AddLump( file, header.lumps[LUMP_LIGHTMAPS], bspLightBytes );
AddLump( file, header->lumps[LUMP_LIGHTGRID], std::vector<ibspGridPoint_t>( bspGridPoints.begin(), bspGridPoints.end() ) ); AddLump( file, header.lumps[LUMP_LIGHTGRID], std::vector<ibspGridPoint_t>( bspGridPoints.begin(), bspGridPoints.end() ) );
AddLump( file, header->lumps[LUMP_ENTITIES], bspEntData ); AddLump( file, header.lumps[LUMP_ENTITIES], bspEntData );
AddLump( file, header->lumps[LUMP_FOGS], bspFogs ); AddLump( file, header.lumps[LUMP_FOGS], bspFogs );
AddLump( file, header->lumps[LUMP_DRAWINDEXES], bspDrawIndexes ); AddLump( file, header.lumps[LUMP_DRAWINDEXES], bspDrawIndexes );
/* advertisements */ /* advertisements */
AddLump( file, header->lumps[LUMP_ADVERTISEMENTS], bspAds ); AddLump( file, header.lumps[LUMP_ADVERTISEMENTS], bspAds );
/* emit bsp size */ /* emit bsp size */
size = ftell( file ); const int size = ftell( file );
Sys_Printf( "Wrote %.1f MB (%d bytes)\n", (float) size / ( 1024 * 1024 ), size ); Sys_Printf( "Wrote %.1f MB (%d bytes)\n", (float) size / ( 1024 * 1024 ), size );
/* write the completed header */ /* write the completed header */
fseek( file, 0, SEEK_SET ); fseek( file, 0, SEEK_SET );
SafeWrite( file, header, sizeof( *header ) ); SafeWrite( file, &header, sizeof( header ) );
/* close the file */ /* close the file */
fclose( file ); fclose( file );

93
tools/quake3/q3map2/bspfile_rbsp.cpp
View File

@ -95,7 +95,7 @@ static void CopyLightGridLumps( rbspHeader_t *header ){
} }
static void AddLightGridLumps( FILE *file, rbspHeader_t *header ){ static void AddLightGridLumps( FILE *file, rbspHeader_t& header ){
/* allocate temporary buffers */ /* allocate temporary buffers */
const size_t maxGridPoints = std::min( bspGridPoints.size(), size_t( MAX_MAP_GRID ) ); const size_t maxGridPoints = std::min( bspGridPoints.size(), size_t( MAX_MAP_GRID ) );
std::vector<bspGridPoint_t> gridPoints; std::vector<bspGridPoint_t> gridPoints;
@ -167,8 +167,8 @@ static void AddLightGridLumps( FILE *file, rbspHeader_t *header ){
a = LittleShort( a ); a = LittleShort( a );
/* write lumps */ /* write lumps */
AddLump( file, header->lumps[LUMP_LIGHTGRID], gridPoints ); AddLump( file, header.lumps[LUMP_LIGHTGRID], gridPoints );
AddLump( file, header->lumps[LUMP_LIGHTARRAY], gridArray ); AddLump( file, header.lumps[LUMP_LIGHTARRAY], gridArray );
} }
@ -186,10 +186,10 @@ void LoadRBSPFile( const char *filename ){
LoadFile( filename, (void**) &header ); LoadFile( filename, (void**) &header );
/* swap the header (except the first 4 bytes) */ /* swap the header (except the first 4 bytes) */
SwapBlock( (int*) ( (byte*) header + sizeof( int ) ), sizeof( *header ) - sizeof( int ) ); SwapBlock( (int*) ( (byte*) header + 4 ), sizeof( *header ) - 4 );
/* make sure it matches the format we're trying to load */ /* make sure it matches the format we're trying to load */
if ( !force && *( (int*) header->ident ) != *( (const int*) g_game->bspIdent ) ) { if ( !force && (const int&) header->ident != (const int&) g_game->bspIdent ) {
Error( "%s is not a %s file", filename, g_game->bspIdent ); Error( "%s is not a %s file", filename, g_game->bspIdent );
} }
if ( !force && header->version != g_game->bspVersion ) { if ( !force && header->version != g_game->bspVersion ) {
@ -198,37 +198,21 @@ void LoadRBSPFile( const char *filename ){
/* load/convert lumps */ /* load/convert lumps */
CopyLump( (bspHeader_t*) header, LUMP_SHADERS, bspShaders ); CopyLump( (bspHeader_t*) header, LUMP_SHADERS, bspShaders );
CopyLump( (bspHeader_t*) header, LUMP_MODELS, bspModels ); CopyLump( (bspHeader_t*) header, LUMP_MODELS, bspModels );
CopyLump( (bspHeader_t*) header, LUMP_PLANES, bspPlanes ); CopyLump( (bspHeader_t*) header, LUMP_PLANES, bspPlanes );
CopyLump( (bspHeader_t*) header, LUMP_LEAFS, bspLeafs ); CopyLump( (bspHeader_t*) header, LUMP_LEAFS, bspLeafs );
CopyLump( (bspHeader_t*) header, LUMP_NODES, bspNodes ); CopyLump( (bspHeader_t*) header, LUMP_NODES, bspNodes );
CopyLump( (bspHeader_t*) header, LUMP_LEAFSURFACES, bspLeafSurfaces ); CopyLump( (bspHeader_t*) header, LUMP_LEAFSURFACES, bspLeafSurfaces );
CopyLump( (bspHeader_t*) header, LUMP_LEAFBRUSHES, bspLeafBrushes ); CopyLump( (bspHeader_t*) header, LUMP_LEAFBRUSHES, bspLeafBrushes );
CopyLump( (bspHeader_t*) header, LUMP_BRUSHES, bspBrushes ); CopyLump( (bspHeader_t*) header, LUMP_BRUSHES, bspBrushes );
CopyLump( (bspHeader_t*) header, LUMP_BRUSHSIDES, bspBrushSides ); CopyLump( (bspHeader_t*) header, LUMP_BRUSHSIDES, bspBrushSides );
CopyLump( (bspHeader_t*) header, LUMP_DRAWVERTS, bspDrawVerts ); CopyLump( (bspHeader_t*) header, LUMP_DRAWVERTS, bspDrawVerts );
CopyLump( (bspHeader_t*) header, LUMP_SURFACES, bspDrawSurfaces ); CopyLump( (bspHeader_t*) header, LUMP_SURFACES, bspDrawSurfaces );
CopyLump( (bspHeader_t*) header, LUMP_FOGS, bspFogs ); CopyLump( (bspHeader_t*) header, LUMP_FOGS, bspFogs );
CopyLump( (bspHeader_t*) header, LUMP_DRAWINDEXES, bspDrawIndexes ); CopyLump( (bspHeader_t*) header, LUMP_DRAWINDEXES, bspDrawIndexes );
CopyLump( (bspHeader_t*) header, LUMP_VISIBILITY, bspVisBytes ); CopyLump( (bspHeader_t*) header, LUMP_VISIBILITY, bspVisBytes );
CopyLump( (bspHeader_t*) header, LUMP_LIGHTMAPS, bspLightBytes ); CopyLump( (bspHeader_t*) header, LUMP_LIGHTMAPS, bspLightBytes );
CopyLump( (bspHeader_t*) header, LUMP_ENTITIES, bspEntData ); CopyLump( (bspHeader_t*) header, LUMP_ENTITIES, bspEntData );
CopyLightGridLumps( header ); CopyLightGridLumps( header );
/* free the file buffer */ /* free the file buffer */
@ -243,59 +227,52 @@ void LoadRBSPFile( const char *filename ){
*/ */
void WriteRBSPFile( const char *filename ){ void WriteRBSPFile( const char *filename ){
rbspHeader_t outheader, *header; rbspHeader_t header{};
FILE *file;
time_t t;
char marker[ 1024 ];
int size;
/* set header */
header = &outheader;
memset( header, 0, sizeof( *header ) );
//% Swapfile(); //% Swapfile();
/* set up header */ /* set up header */
*( (int*) (bspHeader_t*) header->ident ) = *( (const int*) g_game->bspIdent ); (int&) header.ident = (const int&) g_game->bspIdent;
header->version = LittleLong( g_game->bspVersion ); header.version = LittleLong( g_game->bspVersion );
/* write initial header */ /* write initial header */
file = SafeOpenWrite( filename ); FILE *file = SafeOpenWrite( filename );
SafeWrite( file, (bspHeader_t*) header, sizeof( *header ) ); /* overwritten later */ SafeWrite( file, &header, sizeof( header ) ); /* overwritten later */
/* add marker lump */ { /* add marker lump */
time( &t ); time_t t;
/* asctime adds an implicit trailing \n */ time( &t );
sprintf( marker, "I LOVE MY Q3MAP2 %s on %s", Q3MAP_VERSION, asctime( localtime( &t ) ) ); /* asctime adds an implicit trailing \n */
AddLump( file, (bspHeader_t*) header, 0, marker, strlen( marker ) + 1 ); const auto marker = StringOutputStream( 256 )( "I LOVE MY Q3MAP2 ", Q3MAP_VERSION, " on ", asctime( localtime( &t ) ) );
AddLump( file, header.lumps[0], std::vector<char>( marker.begin(), marker.end() + 1 ) );
}
/* add lumps */ /* add lumps */
AddLump( file, header->lumps[LUMP_SHADERS], bspShaders ); AddLump( file, header.lumps[LUMP_SHADERS], bspShaders );
AddLump( file, header->lumps[LUMP_PLANES], bspPlanes ); AddLump( file, header.lumps[LUMP_PLANES], bspPlanes );
AddLump( file, header->lumps[LUMP_LEAFS], bspLeafs ); AddLump( file, header.lumps[LUMP_LEAFS], bspLeafs );
AddLump( file, header->lumps[LUMP_NODES], bspNodes ); AddLump( file, header.lumps[LUMP_NODES], bspNodes );
AddLump( file, header->lumps[LUMP_BRUSHES], bspBrushes ); AddLump( file, header.lumps[LUMP_BRUSHES], bspBrushes );
AddLump( file, header->lumps[LUMP_BRUSHSIDES], bspBrushSides ); AddLump( file, header.lumps[LUMP_BRUSHSIDES], bspBrushSides );
AddLump( file, header->lumps[LUMP_LEAFSURFACES], bspLeafSurfaces ); AddLump( file, header.lumps[LUMP_LEAFSURFACES], bspLeafSurfaces );
AddLump( file, header->lumps[LUMP_LEAFBRUSHES], bspLeafBrushes ); AddLump( file, header.lumps[LUMP_LEAFBRUSHES], bspLeafBrushes );
AddLump( file, header->lumps[LUMP_MODELS], bspModels ); AddLump( file, header.lumps[LUMP_MODELS], bspModels );
AddLump( file, header->lumps[LUMP_DRAWVERTS], bspDrawVerts ); AddLump( file, header.lumps[LUMP_DRAWVERTS], bspDrawVerts );
AddLump( file, header->lumps[LUMP_SURFACES], bspDrawSurfaces ); AddLump( file, header.lumps[LUMP_SURFACES], bspDrawSurfaces );
AddLump( file, header->lumps[LUMP_VISIBILITY], bspVisBytes ); AddLump( file, header.lumps[LUMP_VISIBILITY], bspVisBytes );
AddLump( file, header->lumps[LUMP_LIGHTMAPS], bspLightBytes ); AddLump( file, header.lumps[LUMP_LIGHTMAPS], bspLightBytes );
AddLightGridLumps( file, header ); AddLightGridLumps( file, header );
AddLump( file, header->lumps[LUMP_ENTITIES], bspEntData ); AddLump( file, header.lumps[LUMP_ENTITIES], bspEntData );
AddLump( file, header->lumps[LUMP_FOGS], bspFogs ); AddLump( file, header.lumps[LUMP_FOGS], bspFogs );
AddLump( file, header->lumps[LUMP_DRAWINDEXES], bspDrawIndexes ); AddLump( file, header.lumps[LUMP_DRAWINDEXES], bspDrawIndexes );
/* emit bsp size */ /* emit bsp size */
size = ftell( file ); const int size = ftell( file );
Sys_Printf( "Wrote %.1f MB (%d bytes)\n", (float) size / ( 1024 * 1024 ), size ); Sys_Printf( "Wrote %.1f MB (%d bytes)\n", (float) size / ( 1024 * 1024 ), size );
/* write the completed header */ /* write the completed header */
fseek( file, 0, SEEK_SET ); fseek( file, 0, SEEK_SET );
SafeWrite( file, header, sizeof( *header ) ); SafeWrite( file, &header, sizeof( header ) );
/* close the file */ /* close the file */
fclose( file ); fclose( file );

2
tools/quake3/q3map2/lightmaps_ydnar.cpp
View File

@ -2039,7 +2039,7 @@ static void FindOutLightmaps( rawLightmap_t *lm, bool fastAllocate ){
if ( !ok ) { if ( !ok ) {
/* allocate LIGHTMAP_RESERVE_COUNT new output lightmaps */ /* allocate LIGHTMAP_RESERVE_COUNT new output lightmaps */
numOutLightmaps += LIGHTMAP_RESERVE_COUNT; numOutLightmaps += LIGHTMAP_RESERVE_COUNT;
olm = safe_malloc_info( numOutLightmaps * sizeof( outLightmap_t ), "FindOutLightmaps" ); olm = safe_malloc( numOutLightmaps * sizeof( outLightmap_t ) );
if ( outLightmaps != NULL && numOutLightmaps > LIGHTMAP_RESERVE_COUNT ) { if ( outLightmaps != NULL && numOutLightmaps > LIGHTMAP_RESERVE_COUNT ) {
memcpy( olm, outLightmaps, ( numOutLightmaps - LIGHTMAP_RESERVE_COUNT ) * sizeof( outLightmap_t ) ); memcpy( olm, outLightmaps, ( numOutLightmaps - LIGHTMAP_RESERVE_COUNT ) * sizeof( outLightmap_t ) );

8
tools/quake3/q3map2/q3map2.h
View File

@ -1844,12 +1844,6 @@ shaderInfo_t *ShaderInfoForShaderNull( const char *shader );
/* bspfile_abstract.c */ /* bspfile_abstract.c */
void SwapBlock( int *block, int size ); void SwapBlock( int *block, int size );
int GetLumpElements( bspHeader_t *header, int lump, int size );
void_ptr GetLump( bspHeader_t *header, int lump );
int CopyLump( bspHeader_t *header, int lump, void *dest, int size );
int CopyLump_Allocate( bspHeader_t *header, int lump, void **dest, int size, int *allocationVariable );
void AddLump( FILE *file, bspHeader_t *header, int lumpNum, const void *data, int length );
void LoadBSPFile( const char *filename ); void LoadBSPFile( const char *filename );
void PartialLoadBSPFile( const char *filename ); void PartialLoadBSPFile( const char *filename );
void WriteBSPFile( const char *filename ); void WriteBSPFile( const char *filename );
@ -2381,8 +2375,6 @@ Q_EXTERN std::vector<bspAdvertisement_t> bspAds;
} \ } \
while ( 0 ) while ( 0 )
#define AUTOEXPAND_BY_REALLOC_BSP( suffix, def ) AUTOEXPAND_BY_REALLOC( bsp ## suffix, numBSP ## suffix, allocatedBSP ## suffix, def )
#define AUTOEXPAND_BY_REALLOC_ADD( ptr, used, allocated, add ) \ #define AUTOEXPAND_BY_REALLOC_ADD( ptr, used, allocated, add ) \
do \ do \
{ \ { \

2
tools/quake3/q3map2/surface.cpp
View File

@ -3310,7 +3310,7 @@ void FilterDrawsurfsIntoTree( entity_t *e, tree_t& tree ){
Sys_FPrintf( SYS_VRB, "%9d maxarea'd face surfaces\n", numMaxAreaSurfaces ); Sys_FPrintf( SYS_VRB, "%9d maxarea'd face surfaces\n", numMaxAreaSurfaces );
Sys_FPrintf( SYS_VRB, "%9d surface models generated\n", numSurfaceModels ); Sys_FPrintf( SYS_VRB, "%9d surface models generated\n", numSurfaceModels );
Sys_FPrintf( SYS_VRB, "%9d skybox surfaces generated\n", numSkyboxSurfaces ); Sys_FPrintf( SYS_VRB, "%9d skybox surfaces generated\n", numSkyboxSurfaces );
for ( std::size_t i = 0; i < ARRAY_SIZE( numSurfacesByType ); i++ ) for ( std::size_t i = 0; i < std::size( numSurfacesByType ); ++i )
Sys_FPrintf( SYS_VRB, "%9d %s surfaces\n", numSurfacesByType[ i ], surfaceTypeName( static_cast<ESurfaceType>( i ) ) ); Sys_FPrintf( SYS_VRB, "%9d %s surfaces\n", numSurfacesByType[ i ], surfaceTypeName( static_cast<ESurfaceType>( i ) ) );
Sys_FPrintf( SYS_VRB, "%9d redundant indexes suppressed, saving %d Kbytes\n", numRedundantIndexes, ( numRedundantIndexes * 4 / 1024 ) ); Sys_FPrintf( SYS_VRB, "%9d redundant indexes suppressed, saving %d Kbytes\n", numRedundantIndexes, ( numRedundantIndexes * 4 / 1024 ) );