2 Copyright (C) 1999-2007 id Software, Inc. and contributors.
3 For a list of contributors, see the accompanying CONTRIBUTORS file.
5 This file is part of GtkRadiant.
7 GtkRadiant is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 GtkRadiant is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GtkRadiant; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
29 void GetLeafNums( void );
31 //=============================================================================
33 int bsp_version = Q3_BSP_VERSION;
36 dmodel_t dmodels[MAX_MAP_MODELS];
39 dshader_t dshaders[MAX_MAP_SHADERS];
42 char dentdata[MAX_MAP_ENTSTRING];
45 dleaf_t dleafs[MAX_MAP_LEAFS];
48 dplane_t dplanes[MAX_MAP_PLANES];
51 dnode_t dnodes[MAX_MAP_NODES];
54 int dleafsurfaces[MAX_MAP_LEAFFACES];
57 int dleafbrushes[MAX_MAP_LEAFBRUSHES];
60 dbrush_t dbrushes[MAX_MAP_BRUSHES];
63 dbrushside_t dbrushsides[MAX_MAP_BRUSHSIDES];
72 byte visBytes[MAX_MAP_VISIBILITY];
75 int numDrawVertsBuffer = 0;
76 drawVert_t *drawVerts = NULL;
79 int drawIndexes[MAX_MAP_DRAW_INDEXES];
82 int numDrawSurfacesBuffer = 0;
83 dsurface_t *drawSurfaces = NULL;
86 dfog_t dfogs[MAX_MAP_FOGS];
88 void SetLightBytes( int n ){
89 if ( lightBytes != 0 ) {
99 lightBytes = safe_malloc0_info( numLightBytes, "SetLightBytes" );
102 void SetGridPoints( int n ){
103 if ( gridData != 0 ) {
113 gridData = safe_malloc0_info( numGridPoints * 8, "SetGridPoints" );
119 if ( drawVerts == 0 ) {
120 numDrawVertsBuffer = MAX_MAP_DRAW_VERTS / 37;
122 drawVerts = safe_malloc_info( sizeof( drawVert_t ) * numDrawVertsBuffer, "IncDrawVerts" );
125 else if ( numDrawVerts > numDrawVertsBuffer ) {
126 numDrawVertsBuffer *= 3; // multiply by 1.5
127 numDrawVertsBuffer /= 2;
129 if ( numDrawVertsBuffer > MAX_MAP_DRAW_VERTS ) {
130 numDrawVertsBuffer = MAX_MAP_DRAW_VERTS;
133 drawVerts = realloc( drawVerts, sizeof( drawVert_t ) * numDrawVertsBuffer );
136 Error( "realloc() failed (IncDrawVerts)" );
140 memset( drawVerts + ( numDrawVerts - 1 ), 0, sizeof( drawVert_t ) );
143 void SetDrawVerts( int n ){
144 if ( drawVerts != 0 ) {
149 numDrawVertsBuffer = numDrawVerts;
151 drawVerts = safe_malloc0_info( sizeof( drawVert_t ) * numDrawVertsBuffer, "IncDrawVerts" );
154 void SetDrawSurfacesBuffer(){
155 if ( drawSurfaces != 0 ) {
156 free( drawSurfaces );
159 numDrawSurfacesBuffer = MAX_MAP_DRAW_SURFS;
161 drawSurfaces = safe_malloc0_info( sizeof( dsurface_t ) * numDrawSurfacesBuffer, "IncDrawSurfaces" );
164 void SetDrawSurfaces( int n ){
165 if ( drawSurfaces != 0 ) {
166 free( drawSurfaces );
170 numDrawSurfacesBuffer = numDrawSurfaces;
172 drawSurfaces = safe_malloc0_info( sizeof( dsurface_t ) * numDrawSurfacesBuffer, "IncDrawSurfaces" );
175 void BspFilesCleanup(){
176 if ( drawVerts != 0 ) {
179 if ( drawSurfaces != 0 ) {
180 free( drawSurfaces );
182 if ( lightBytes != 0 ) {
185 if ( gridData != 0 ) {
190 //=============================================================================
196 If all values are 32 bits, this can be used to swap everything
199 void SwapBlock( int *block, int sizeOfBlock ) {
203 for ( i = 0 ; i < sizeOfBlock ; i++ ) {
204 block[i] = LittleLong( block[i] );
212 Byte swaps all data in a bsp file.
215 void SwapBSPFile( void ) {
219 SwapBlock( (int *)dmodels, nummodels * sizeof( dmodels[0] ) );
221 // shaders (don't swap the name)
222 for ( i = 0 ; i < numShaders ; i++ ) {
223 dshaders[i].contentFlags = LittleLong( dshaders[i].contentFlags );
224 dshaders[i].surfaceFlags = LittleLong( dshaders[i].surfaceFlags );
228 SwapBlock( (int *)dplanes, numplanes * sizeof( dplanes[0] ) );
231 SwapBlock( (int *)dnodes, numnodes * sizeof( dnodes[0] ) );
234 SwapBlock( (int *)dleafs, numleafs * sizeof( dleafs[0] ) );
237 SwapBlock( (int *)dleafsurfaces, numleafsurfaces * sizeof( dleafsurfaces[0] ) );
240 SwapBlock( (int *)dleafbrushes, numleafbrushes * sizeof( dleafbrushes[0] ) );
243 SwapBlock( (int *)dbrushes, numbrushes * sizeof( dbrushes[0] ) );
246 SwapBlock( (int *)dbrushsides, numbrushsides * sizeof( dbrushsides[0] ) );
249 ( (int *)&visBytes )[0] = LittleLong( ( (int *)&visBytes )[0] );
250 ( (int *)&visBytes )[1] = LittleLong( ( (int *)&visBytes )[1] );
252 // drawverts (don't swap colors )
253 for ( i = 0 ; i < numDrawVerts ; i++ ) {
254 drawVerts[i].lightmap[0] = LittleFloat( drawVerts[i].lightmap[0] );
255 drawVerts[i].lightmap[1] = LittleFloat( drawVerts[i].lightmap[1] );
256 drawVerts[i].st[0] = LittleFloat( drawVerts[i].st[0] );
257 drawVerts[i].st[1] = LittleFloat( drawVerts[i].st[1] );
258 drawVerts[i].xyz[0] = LittleFloat( drawVerts[i].xyz[0] );
259 drawVerts[i].xyz[1] = LittleFloat( drawVerts[i].xyz[1] );
260 drawVerts[i].xyz[2] = LittleFloat( drawVerts[i].xyz[2] );
261 drawVerts[i].normal[0] = LittleFloat( drawVerts[i].normal[0] );
262 drawVerts[i].normal[1] = LittleFloat( drawVerts[i].normal[1] );
263 drawVerts[i].normal[2] = LittleFloat( drawVerts[i].normal[2] );
267 SwapBlock( (int *)drawIndexes, numDrawIndexes * sizeof( drawIndexes[0] ) );
270 SwapBlock( (int *)drawSurfaces, numDrawSurfaces * sizeof( drawSurfaces[0] ) );
273 for ( i = 0 ; i < numFogs ; i++ ) {
274 dfogs[i].brushNum = LittleLong( dfogs[i].brushNum );
275 dfogs[i].visibleSide = LittleLong( dfogs[i].visibleSide );
286 int GetLumpElements( dheader_t *header, int lump, int size ) {
287 int length = header->lumps[lump].filelen;
289 if ( length % size ) {
290 Error( "LoadBSPFile: odd lump size" );
293 return length / size;
301 int CopyLump( dheader_t *header, int lump, void *dest, int size ) {
304 length = header->lumps[lump].filelen;
305 ofs = header->lumps[lump].fileofs;
311 if ( length % size ) {
312 Error( "LoadBSPFile: odd lump size" );
315 memcpy( dest, (byte *)header + ofs, length );
317 return length / size;
325 void LoadBSPFile( const char *filename ) {
328 // load the file header
329 LoadFile( filename, (void **)&header );
332 SwapBlock( (int *)header, sizeof( *header ) );
334 if ( header->ident != BSP_IDENT ) {
335 Error( "%s is not a IBSP file", filename );
337 if ( header->version != bsp_version ) {
338 Error( "%s is version %i, not %i", filename, header->version, bsp_version );
341 numShaders = CopyLump( header, LUMP_SHADERS, dshaders, sizeof( dshader_t ) );
342 nummodels = CopyLump( header, LUMP_MODELS, dmodels, sizeof( dmodel_t ) );
343 numplanes = CopyLump( header, LUMP_PLANES, dplanes, sizeof( dplane_t ) );
344 numleafs = CopyLump( header, LUMP_LEAFS, dleafs, sizeof( dleaf_t ) );
345 numnodes = CopyLump( header, LUMP_NODES, dnodes, sizeof( dnode_t ) );
346 numleafsurfaces = CopyLump( header, LUMP_LEAFSURFACES, dleafsurfaces, sizeof( dleafsurfaces[0] ) );
347 numleafbrushes = CopyLump( header, LUMP_LEAFBRUSHES, dleafbrushes, sizeof( dleafbrushes[0] ) );
348 numbrushes = CopyLump( header, LUMP_BRUSHES, dbrushes, sizeof( dbrush_t ) );
349 numbrushsides = CopyLump( header, LUMP_BRUSHSIDES, dbrushsides, sizeof( dbrushside_t ) );
350 numDrawVerts = GetLumpElements( header, LUMP_DRAWVERTS, sizeof( drawVert_t ) );
351 SetDrawVerts( numDrawVerts );
352 CopyLump( header, LUMP_DRAWVERTS, drawVerts, sizeof( drawVert_t ) );
353 numDrawSurfaces = GetLumpElements( header, LUMP_SURFACES, sizeof( dsurface_t ) );
354 SetDrawSurfaces( numDrawSurfaces );
355 numDrawSurfaces = CopyLump( header, LUMP_SURFACES, drawSurfaces, sizeof( dsurface_t ) );
356 numFogs = CopyLump( header, LUMP_FOGS, dfogs, sizeof( dfog_t ) );
357 numDrawIndexes = CopyLump( header, LUMP_DRAWINDEXES, drawIndexes, sizeof( drawIndexes[0] ) );
359 numVisBytes = CopyLump( header, LUMP_VISIBILITY, visBytes, 1 );
360 numLightBytes = GetLumpElements( header, LUMP_LIGHTMAPS, 1 );
361 SetLightBytes( numLightBytes );
362 CopyLump( header, LUMP_LIGHTMAPS, lightBytes, 1 );
363 entdatasize = CopyLump( header, LUMP_ENTITIES, dentdata, 1 );
365 numGridPoints = GetLumpElements( header, LUMP_LIGHTGRID, 8 );
366 SetGridPoints( numGridPoints );
367 CopyLump( header, LUMP_LIGHTGRID, gridData, 8 );
370 free( header ); // everything has been copied out
377 //============================================================================
384 void AddLump( FILE *bspfile, dheader_t *header, int lumpnum, const void *data, int len ) {
387 lump = &header->lumps[lumpnum];
389 lump->fileofs = LittleLong( ftell( bspfile ) );
390 lump->filelen = LittleLong( len );
391 SafeWrite( bspfile, data, ( len + 3 ) & ~3 );
398 Swaps the bsp file in place, so it should not be referenced again
401 void WriteBSPFile( const char *filename ) {
402 dheader_t outheader, *header;
406 memset( header, 0, sizeof( dheader_t ) );
410 header->ident = LittleLong( BSP_IDENT );
411 header->version = LittleLong( bsp_version );
413 bspfile = SafeOpenWrite( filename );
414 SafeWrite( bspfile, header, sizeof( dheader_t ) ); // overwritten later
416 AddLump( bspfile, header, LUMP_SHADERS, dshaders, numShaders * sizeof( dshader_t ) );
417 AddLump( bspfile, header, LUMP_PLANES, dplanes, numplanes * sizeof( dplane_t ) );
418 AddLump( bspfile, header, LUMP_LEAFS, dleafs, numleafs * sizeof( dleaf_t ) );
419 AddLump( bspfile, header, LUMP_NODES, dnodes, numnodes * sizeof( dnode_t ) );
420 AddLump( bspfile, header, LUMP_BRUSHES, dbrushes, numbrushes * sizeof( dbrush_t ) );
421 AddLump( bspfile, header, LUMP_BRUSHSIDES, dbrushsides, numbrushsides * sizeof( dbrushside_t ) );
422 AddLump( bspfile, header, LUMP_LEAFSURFACES, dleafsurfaces, numleafsurfaces * sizeof( dleafsurfaces[0] ) );
423 AddLump( bspfile, header, LUMP_LEAFBRUSHES, dleafbrushes, numleafbrushes * sizeof( dleafbrushes[0] ) );
424 AddLump( bspfile, header, LUMP_MODELS, dmodels, nummodels * sizeof( dmodel_t ) );
425 AddLump( bspfile, header, LUMP_DRAWVERTS, drawVerts, numDrawVerts * sizeof( drawVert_t ) );
426 AddLump( bspfile, header, LUMP_SURFACES, drawSurfaces, numDrawSurfaces * sizeof( dsurface_t ) );
427 AddLump( bspfile, header, LUMP_VISIBILITY, visBytes, numVisBytes );
428 AddLump( bspfile, header, LUMP_LIGHTMAPS, lightBytes, numLightBytes );
429 AddLump( bspfile, header, LUMP_LIGHTGRID, gridData, 8 * numGridPoints );
430 AddLump( bspfile, header, LUMP_ENTITIES, dentdata, entdatasize );
431 AddLump( bspfile, header, LUMP_FOGS, dfogs, numFogs * sizeof( dfog_t ) );
432 AddLump( bspfile, header, LUMP_DRAWINDEXES, drawIndexes, numDrawIndexes * sizeof( drawIndexes[0] ) );
434 fseek( bspfile, 0, SEEK_SET );
435 SafeWrite( bspfile, header, sizeof( dheader_t ) );
439 //============================================================================
445 Dumps info about current file
448 void PrintBSPFileSizes( void ) {
449 if ( !num_entities ) {
453 Sys_Printf( "%6i models %7i\n"
454 ,nummodels, (int)( nummodels * sizeof( dmodel_t ) ) );
455 Sys_Printf( "%6i shaders %7i\n"
456 ,numShaders, (int)( numShaders * sizeof( dshader_t ) ) );
457 Sys_Printf( "%6i brushes %7i\n"
458 ,numbrushes, (int)( numbrushes * sizeof( dbrush_t ) ) );
459 Sys_Printf( "%6i brushsides %7i\n"
460 ,numbrushsides, (int)( numbrushsides * sizeof( dbrushside_t ) ) );
461 Sys_Printf( "%6i fogs %7i\n"
462 ,numFogs, (int)( numFogs * sizeof( dfog_t ) ) );
463 Sys_Printf( "%6i planes %7i\n"
464 ,numplanes, (int)( numplanes * sizeof( dplane_t ) ) );
465 Sys_Printf( "%6i entdata %7i\n", num_entities, entdatasize );
469 Sys_Printf( "%6i nodes %7i\n"
470 ,numnodes, (int)( numnodes * sizeof( dnode_t ) ) );
471 Sys_Printf( "%6i leafs %7i\n"
472 ,numleafs, (int)( numleafs * sizeof( dleaf_t ) ) );
473 Sys_Printf( "%6i leafsurfaces %7i\n"
474 ,numleafsurfaces, (int)( numleafsurfaces * sizeof( dleafsurfaces[0] ) ) );
475 Sys_Printf( "%6i leafbrushes %7i\n"
476 ,numleafbrushes, (int)( numleafbrushes * sizeof( dleafbrushes[0] ) ) );
477 Sys_Printf( "%6i drawverts %7i\n"
478 ,numDrawVerts, (int)( numDrawVerts * sizeof( drawVerts[0] ) ) );
479 Sys_Printf( "%6i drawindexes %7i\n"
480 ,numDrawIndexes, (int)( numDrawIndexes * sizeof( drawIndexes[0] ) ) );
481 Sys_Printf( "%6i drawsurfaces %7i\n"
482 ,numDrawSurfaces, (int)( numDrawSurfaces * sizeof( drawSurfaces[0] ) ) );
484 Sys_Printf( "%6i lightmaps %7i\n"
485 ,numLightBytes / ( LIGHTMAP_WIDTH * LIGHTMAP_HEIGHT * 3 ), numLightBytes );
486 Sys_Printf( " visibility %7i\n"
491 //============================================
494 entity_t entities[MAX_MAP_ENTITIES];
496 void StripTrailing( char *e ) {
499 s = e + strlen( e ) - 1;
500 while ( s >= e && *s <= 32 )
512 epair_t *ParseEpair( void ) {
515 e = safe_malloc0( sizeof( epair_t ) );
517 if ( strlen( token ) >= MAX_KEY - 1 ) {
518 Error( "ParseEpar: token too long" );
520 e->key = copystring( token );
522 if ( strlen( token ) >= MAX_VALUE - 1 ) {
523 Error( "ParseEpar: token too long" );
525 e->value = copystring( token );
527 // strip trailing spaces that sometimes get accidentally
528 // added in the editor
529 StripTrailing( e->key );
530 StripTrailing( e->value );
541 qboolean ParseEntity( void ) {
545 if ( !GetToken( qtrue ) ) {
549 if ( strcmp( token, "{" ) ) {
550 Error( "ParseEntity: { not found" );
552 if ( num_entities == MAX_MAP_ENTITIES ) {
553 Error( "num_entities == MAX_MAP_ENTITIES" );
555 mapent = &entities[num_entities];
559 if ( !GetToken( qtrue ) ) {
560 Error( "ParseEntity: EOF without closing brace" );
562 if ( !strcmp( token, "}" ) ) {
566 e->next = mapent->epairs;
577 Parses the dentdata string into entities
580 void ParseEntities( void ) {
582 ParseFromMemory( dentdata, entdatasize );
584 while ( ParseEntity() ) {
593 Generates the dentdata string from all the entities
594 This allows the utilities to add or remove key/value pairs
595 to the data created by the map editor.
598 void UnparseEntities( void ) {
603 char key[1024], value[1024];
609 for ( i = 0 ; i < num_entities ; i++ ) {
610 ep = entities[i].epairs;
612 continue; // ent got removed
618 for ( ep = entities[i].epairs ; ep ; ep = ep->next ) {
619 strcpy( key, ep->key );
620 StripTrailing( key );
621 strcpy( value, ep->value );
622 StripTrailing( value );
624 sprintf( line, "\"%s\" \"%s\"\n", key, value );
626 end += strlen( line );
631 if ( end > buf + MAX_MAP_ENTSTRING ) {
632 Error( "Entity text too long" );
635 entdatasize = end - buf + 1;
638 void PrintEntity( const entity_t *ent ) {
641 Sys_Printf( "------- entity %p -------\n", ent );
642 for ( ep = ent->epairs ; ep ; ep = ep->next ) {
643 Sys_Printf( "%s = %s\n", ep->key, ep->value );
648 void SetKeyValue( entity_t *ent, const char *key, const char *value ) {
651 for ( ep = ent->epairs ; ep ; ep = ep->next ) {
652 if ( !strcmp( ep->key, key ) ) {
654 ep->value = copystring( value );
658 ep = safe_malloc( sizeof( *ep ) );
659 ep->next = ent->epairs;
661 ep->key = copystring( key );
662 ep->value = copystring( value );
665 const char *ValueForKey( const entity_t *ent, const char *key ) {
668 for ( ep = ent->epairs ; ep ; ep = ep->next ) {
669 if ( !strcmp( ep->key, key ) ) {
676 vec_t FloatForKey( const entity_t *ent, const char *key ) {
679 k = ValueForKey( ent, key );
683 void GetVectorForKey( const entity_t *ent, const char *key, vec3_t vec ) {
687 k = ValueForKey( ent, key );
689 // scanf into doubles, then assign, so it is vec_t size independent
691 sscanf( k, "%lf %lf %lf", &v1, &v2, &v3 );