tools/quake3/common/bspfile.c

   1 /*
   2    Copyright (C) 1999-2006 Id Software, Inc. and contributors.
   3    For a list of contributors, see the accompanying CONTRIBUTORS file.
   4
   5    This file is part of GtkRadiant.
   6
   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.
  11
  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.
  16
  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
  20  */
  21
  22
  23 #include "cmdlib.h"
  24 #include "mathlib.h"
  25 #include "inout.h"
  26 #include "bspfile.h"
  27 #include "scriplib.h"
  28
  29 void GetLeafNums( void );
  30
  31 //=============================================================================
  32
  33 int bsp_version = Q3_BSP_VERSION;
  34
  35 int nummodels;
  36 dmodel_t dmodels[MAX_MAP_MODELS];
  37
  38 int numShaders;
  39 dshader_t dshaders[MAX_MAP_SHADERS];
  40
  41 int entdatasize;
  42 char dentdata[MAX_MAP_ENTSTRING];
  43
  44 int numleafs;
  45 dleaf_t dleafs[MAX_MAP_LEAFS];
  46
  47 int numplanes;
  48 dplane_t dplanes[MAX_MAP_PLANES];
  49
  50 int numnodes;
  51 dnode_t dnodes[MAX_MAP_NODES];
  52
  53 int numleafsurfaces;
  54 int dleafsurfaces[MAX_MAP_LEAFFACES];
  55
  56 int numleafbrushes;
  57 int dleafbrushes[MAX_MAP_LEAFBRUSHES];
  58
  59 int numbrushes;
  60 dbrush_t dbrushes[MAX_MAP_BRUSHES];
  61
  62 int numbrushsides;
  63 dbrushside_t dbrushsides[MAX_MAP_BRUSHSIDES];
  64
  65 int numLightBytes;
  66 byte        *lightBytes;
  67
  68 int numGridPoints;
  69 byte        *gridData;
  70
  71 int numVisBytes;
  72 byte visBytes[MAX_MAP_VISIBILITY];
  73
  74 int numDrawVerts = 0;
  75 int numDrawVertsBuffer = 0;
  76 drawVert_t  *drawVerts = NULL;
  77
  78 int numDrawIndexes;
  79 int drawIndexes[MAX_MAP_DRAW_INDEXES];
  80
  81 int numDrawSurfaces;
  82 int numDrawSurfacesBuffer = 0;
  83 dsurface_t  *drawSurfaces = NULL;
  84
  85 int numFogs;
  86 dfog_t dfogs[MAX_MAP_FOGS];
  87
  88 void SetLightBytes( int n ){
  89         if ( lightBytes != 0 ) {
  90                 free( lightBytes );
  91         }
  92
  93         numLightBytes = n;
  94
  95         if ( n == 0 ) {
  96                 return;
  97         }
  98
  99         lightBytes = safe_malloc_info( numLightBytes, "SetLightBytes" );
 100
 101         memset( lightBytes, 0, numLightBytes );
 102 }
 103
 104 void SetGridPoints( int n ){
 105         if ( gridData != 0 ) {
 106                 free( gridData );
 107         }
 108
 109         numGridPoints = n;
 110
 111         if ( n == 0 ) {
 112                 return;
 113         }
 114
 115         gridData = safe_malloc_info( numGridPoints * 8, "SetGridPoints" );
 116
 117         memset( gridData, 0, numGridPoints * 8 );
 118 }
 119
 120 void IncDrawVerts(){
 121         numDrawVerts++;
 122
 123         if ( drawVerts == 0 ) {
 124                 numDrawVertsBuffer = MAX_MAP_DRAW_VERTS / 37;
 125
 126                 drawVerts = safe_malloc_info( sizeof( drawVert_t ) * numDrawVertsBuffer, "IncDrawVerts" );
 127
 128         }
 129         else if ( numDrawVerts > numDrawVertsBuffer ) {
 130                 numDrawVertsBuffer *= 3; // multiply by 1.5
 131                 numDrawVertsBuffer /= 2;
 132
 133                 if ( numDrawVertsBuffer > MAX_MAP_DRAW_VERTS ) {
 134                         numDrawVertsBuffer = MAX_MAP_DRAW_VERTS;
 135                 }
 136
 137                 drawVerts = realloc( drawVerts, sizeof( drawVert_t ) * numDrawVertsBuffer );
 138
 139                 if ( !drawVerts ) {
 140                         Error( "realloc() failed (IncDrawVerts)" );
 141                 }
 142         }
 143
 144         memset( drawVerts + ( numDrawVerts - 1 ), 0, sizeof( drawVert_t ) );
 145 }
 146
 147 void SetDrawVerts( int n ){
 148         if ( drawVerts != 0 ) {
 149                 free( drawVerts );
 150         }
 151
 152         numDrawVerts = n;
 153         numDrawVertsBuffer = numDrawVerts;
 154
 155         drawVerts = safe_malloc_info( sizeof( drawVert_t ) * numDrawVertsBuffer, "IncDrawVerts" );
 156
 157         memset( drawVerts, 0, n * sizeof( drawVert_t ) );
 158 }
 159
 160 void SetDrawSurfacesBuffer(){
 161         if ( drawSurfaces != 0 ) {
 162                 free( drawSurfaces );
 163         }
 164
 165         numDrawSurfacesBuffer = MAX_MAP_DRAW_SURFS;
 166
 167         drawSurfaces = safe_malloc_info( sizeof( dsurface_t ) * numDrawSurfacesBuffer, "IncDrawSurfaces" );
 168
 169         memset( drawSurfaces, 0, MAX_MAP_DRAW_SURFS * sizeof( drawVert_t ) );
 170 }
 171
 172 void SetDrawSurfaces( int n ){
 173         if ( drawSurfaces != 0 ) {
 174                 free( drawSurfaces );
 175         }
 176
 177         numDrawSurfaces = n;
 178         numDrawSurfacesBuffer = numDrawSurfaces;
 179
 180         drawSurfaces = safe_malloc_info( sizeof( dsurface_t ) * numDrawSurfacesBuffer, "IncDrawSurfaces" );
 181
 182         memset( drawSurfaces, 0, n * sizeof( drawVert_t ) );
 183 }
 184
 185 void BspFilesCleanup(){
 186         if ( drawVerts != 0 ) {
 187                 free( drawVerts );
 188         }
 189         if ( drawSurfaces != 0 ) {
 190                 free( drawSurfaces );
 191         }
 192         if ( lightBytes != 0 ) {
 193                 free( lightBytes );
 194         }
 195         if ( gridData != 0 ) {
 196                 free( gridData );
 197         }
 198 }
 199
 200 //=============================================================================
 201
 202 /*
 203    =============
 204    SwapBlock
 205
 206    If all values are 32 bits, this can be used to swap everything
 207    =============
 208  */
 209 void SwapBlock( int *block, int sizeOfBlock ) {
 210         int i;
 211
 212         sizeOfBlock >>= 2;
 213         for ( i = 0 ; i < sizeOfBlock ; i++ ) {
 214                 block[i] = LittleLong( block[i] );
 215         }
 216 }
 217
 218 /*
 219    =============
 220    SwapBSPFile
 221
 222    Byte swaps all data in a bsp file.
 223    =============
 224  */
 225 void SwapBSPFile( void ) {
 226         int i;
 227
 228         // models
 229         SwapBlock( (int *)dmodels, nummodels * sizeof( dmodels[0] ) );
 230
 231         // shaders (don't swap the name)
 232         for ( i = 0 ; i < numShaders ; i++ ) {
 233                 dshaders[i].contentFlags = LittleLong( dshaders[i].contentFlags );
 234                 dshaders[i].surfaceFlags = LittleLong( dshaders[i].surfaceFlags );
 235         }
 236
 237         // planes
 238         SwapBlock( (int *)dplanes, numplanes * sizeof( dplanes[0] ) );
 239
 240         // nodes
 241         SwapBlock( (int *)dnodes, numnodes * sizeof( dnodes[0] ) );
 242
 243         // leafs
 244         SwapBlock( (int *)dleafs, numleafs * sizeof( dleafs[0] ) );
 245
 246         // leaffaces
 247         SwapBlock( (int *)dleafsurfaces, numleafsurfaces * sizeof( dleafsurfaces[0] ) );
 248
 249         // leafbrushes
 250         SwapBlock( (int *)dleafbrushes, numleafbrushes * sizeof( dleafbrushes[0] ) );
 251
 252         // brushes
 253         SwapBlock( (int *)dbrushes, numbrushes * sizeof( dbrushes[0] ) );
 254
 255         // brushsides
 256         SwapBlock( (int *)dbrushsides, numbrushsides * sizeof( dbrushsides[0] ) );
 257
 258         // vis
 259         ( (int *)&visBytes )[0] = LittleLong( ( (int *)&visBytes )[0] );
 260         ( (int *)&visBytes )[1] = LittleLong( ( (int *)&visBytes )[1] );
 261
 262         // drawverts (don't swap colors )
 263         for ( i = 0 ; i < numDrawVerts ; i++ ) {
 264                 drawVerts[i].lightmap[0] = LittleFloat( drawVerts[i].lightmap[0] );
 265                 drawVerts[i].lightmap[1] = LittleFloat( drawVerts[i].lightmap[1] );
 266                 drawVerts[i].st[0] = LittleFloat( drawVerts[i].st[0] );
 267                 drawVerts[i].st[1] = LittleFloat( drawVerts[i].st[1] );
 268                 drawVerts[i].xyz[0] = LittleFloat( drawVerts[i].xyz[0] );
 269                 drawVerts[i].xyz[1] = LittleFloat( drawVerts[i].xyz[1] );
 270                 drawVerts[i].xyz[2] = LittleFloat( drawVerts[i].xyz[2] );
 271                 drawVerts[i].normal[0] = LittleFloat( drawVerts[i].normal[0] );
 272                 drawVerts[i].normal[1] = LittleFloat( drawVerts[i].normal[1] );
 273                 drawVerts[i].normal[2] = LittleFloat( drawVerts[i].normal[2] );
 274         }
 275
 276         // drawindexes
 277         SwapBlock( (int *)drawIndexes, numDrawIndexes * sizeof( drawIndexes[0] ) );
 278
 279         // drawsurfs
 280         SwapBlock( (int *)drawSurfaces, numDrawSurfaces * sizeof( drawSurfaces[0] ) );
 281
 282         // fogs
 283         for ( i = 0 ; i < numFogs ; i++ ) {
 284                 dfogs[i].brushNum = LittleLong( dfogs[i].brushNum );
 285                 dfogs[i].visibleSide = LittleLong( dfogs[i].visibleSide );
 286         }
 287 }
 288
 289
 290
 291 /*
 292    =============
 293    GetLumpElements
 294    =============
 295  */
 296 int GetLumpElements( dheader_t  *header, int lump, int size ) {
 297         int length = header->lumps[lump].filelen;
 298
 299         if ( length % size ) {
 300                 Error( "LoadBSPFile: odd lump size" );
 301         }
 302
 303         return length / size;
 304 }
 305
 306 /*
 307    =============
 308    CopyLump
 309    =============
 310  */
 311 int CopyLump( dheader_t *header, int lump, void *dest, int size ) {
 312         int length, ofs;
 313
 314         length = header->lumps[lump].filelen;
 315         ofs = header->lumps[lump].fileofs;
 316
 317         if ( length == 0 ) {
 318                 return 0;
 319         }
 320
 321         if ( length % size ) {
 322                 Error( "LoadBSPFile: odd lump size" );
 323         }
 324
 325         memcpy( dest, (byte *)header + ofs, length );
 326
 327         return length / size;
 328 }
 329
 330 /*
 331    =============
 332    LoadBSPFile
 333    =============
 334  */
 335 void    LoadBSPFile( const char *filename ) {
 336         dheader_t   *header;
 337
 338         // load the file header
 339         LoadFile( filename, (void **)&header );
 340
 341         // swap the header
 342         SwapBlock( (int *)header, sizeof( *header ) );
 343
 344         if ( header->ident != BSP_IDENT ) {
 345                 Error( "%s is not a IBSP file", filename );
 346         }
 347         if ( header->version != bsp_version ) {
 348                 Error( "%s is version %i, not %i", filename, header->version, bsp_version );
 349         }
 350
 351         numShaders = CopyLump( header, LUMP_SHADERS, dshaders, sizeof( dshader_t ) );
 352         nummodels = CopyLump( header, LUMP_MODELS, dmodels, sizeof( dmodel_t ) );
 353         numplanes = CopyLump( header, LUMP_PLANES, dplanes, sizeof( dplane_t ) );
 354         numleafs = CopyLump( header, LUMP_LEAFS, dleafs, sizeof( dleaf_t ) );
 355         numnodes = CopyLump( header, LUMP_NODES, dnodes, sizeof( dnode_t ) );
 356         numleafsurfaces = CopyLump( header, LUMP_LEAFSURFACES, dleafsurfaces, sizeof( dleafsurfaces[0] ) );
 357         numleafbrushes = CopyLump( header, LUMP_LEAFBRUSHES, dleafbrushes, sizeof( dleafbrushes[0] ) );
 358         numbrushes = CopyLump( header, LUMP_BRUSHES, dbrushes, sizeof( dbrush_t ) );
 359         numbrushsides = CopyLump( header, LUMP_BRUSHSIDES, dbrushsides, sizeof( dbrushside_t ) );
 360         numDrawVerts = GetLumpElements( header, LUMP_DRAWVERTS, sizeof( drawVert_t ) );
 361         SetDrawVerts( numDrawVerts );
 362         CopyLump( header, LUMP_DRAWVERTS, drawVerts, sizeof( drawVert_t ) );
 363         numDrawSurfaces = GetLumpElements( header, LUMP_SURFACES, sizeof( dsurface_t ) );
 364         SetDrawSurfaces( numDrawSurfaces );
 365         numDrawSurfaces = CopyLump( header, LUMP_SURFACES, drawSurfaces, sizeof( dsurface_t ) );
 366         numFogs = CopyLump( header, LUMP_FOGS, dfogs, sizeof( dfog_t ) );
 367         numDrawIndexes = CopyLump( header, LUMP_DRAWINDEXES, drawIndexes, sizeof( drawIndexes[0] ) );
 368
 369         numVisBytes = CopyLump( header, LUMP_VISIBILITY, visBytes, 1 );
 370         numLightBytes = GetLumpElements( header, LUMP_LIGHTMAPS, 1 );
 371         SetLightBytes( numLightBytes );
 372         CopyLump( header, LUMP_LIGHTMAPS, lightBytes, 1 );
 373         entdatasize = CopyLump( header, LUMP_ENTITIES, dentdata, 1 );
 374
 375         numGridPoints = GetLumpElements( header, LUMP_LIGHTGRID, 8 );
 376         SetGridPoints( numGridPoints );
 377         CopyLump( header, LUMP_LIGHTGRID, gridData, 8 );
 378
 379
 380         free( header );     // everything has been copied out
 381
 382         // swap everything
 383         SwapBSPFile();
 384 }
 385
 386
 387 //============================================================================
 388
 389 /*
 390    =============
 391    AddLump
 392    =============
 393  */
 394 void AddLump( FILE *bspfile, dheader_t *header, int lumpnum, const void *data, int len ) {
 395         lump_t *lump;
 396
 397         lump = &header->lumps[lumpnum];
 398
 399         lump->fileofs = LittleLong( ftell( bspfile ) );
 400         lump->filelen = LittleLong( len );
 401         SafeWrite( bspfile, data, ( len + 3 ) & ~3 );
 402 }
 403
 404 /*
 405    =============
 406    WriteBSPFile
 407
 408    Swaps the bsp file in place, so it should not be referenced again
 409    =============
 410  */
 411 void    WriteBSPFile( const char *filename ) {
 412         dheader_t outheader, *header;
 413         FILE        *bspfile;
 414
 415         header = &outheader;
 416         memset( header, 0, sizeof( dheader_t ) );
 417
 418         SwapBSPFile();
 419
 420         header->ident = LittleLong( BSP_IDENT );
 421         header->version = LittleLong( bsp_version );
 422
 423         bspfile = SafeOpenWrite( filename );
 424         SafeWrite( bspfile, header, sizeof( dheader_t ) );    // overwritten later
 425
 426         AddLump( bspfile, header, LUMP_SHADERS, dshaders, numShaders * sizeof( dshader_t ) );
 427         AddLump( bspfile, header, LUMP_PLANES, dplanes, numplanes * sizeof( dplane_t ) );
 428         AddLump( bspfile, header, LUMP_LEAFS, dleafs, numleafs * sizeof( dleaf_t ) );
 429         AddLump( bspfile, header, LUMP_NODES, dnodes, numnodes * sizeof( dnode_t ) );
 430         AddLump( bspfile, header, LUMP_BRUSHES, dbrushes, numbrushes * sizeof( dbrush_t ) );
 431         AddLump( bspfile, header, LUMP_BRUSHSIDES, dbrushsides, numbrushsides * sizeof( dbrushside_t ) );
 432         AddLump( bspfile, header, LUMP_LEAFSURFACES, dleafsurfaces, numleafsurfaces * sizeof( dleafsurfaces[0] ) );
 433         AddLump( bspfile, header, LUMP_LEAFBRUSHES, dleafbrushes, numleafbrushes * sizeof( dleafbrushes[0] ) );
 434         AddLump( bspfile, header, LUMP_MODELS, dmodels, nummodels * sizeof( dmodel_t ) );
 435         AddLump( bspfile, header, LUMP_DRAWVERTS, drawVerts, numDrawVerts * sizeof( drawVert_t ) );
 436         AddLump( bspfile, header, LUMP_SURFACES, drawSurfaces, numDrawSurfaces * sizeof( dsurface_t ) );
 437         AddLump( bspfile, header, LUMP_VISIBILITY, visBytes, numVisBytes );
 438         AddLump( bspfile, header, LUMP_LIGHTMAPS, lightBytes, numLightBytes );
 439         AddLump( bspfile, header, LUMP_LIGHTGRID, gridData, 8 * numGridPoints );
 440         AddLump( bspfile, header, LUMP_ENTITIES, dentdata, entdatasize );
 441         AddLump( bspfile, header, LUMP_FOGS, dfogs, numFogs * sizeof( dfog_t ) );
 442         AddLump( bspfile, header, LUMP_DRAWINDEXES, drawIndexes, numDrawIndexes * sizeof( drawIndexes[0] ) );
 443
 444         fseek( bspfile, 0, SEEK_SET );
 445         SafeWrite( bspfile, header, sizeof( dheader_t ) );
 446         fclose( bspfile );
 447 }
 448
 449 //============================================================================
 450
 451 /*
 452    =============
 453    PrintBSPFileSizes
 454
 455    Dumps info about current file
 456    =============
 457  */
 458 void PrintBSPFileSizes( void ) {
 459         if ( !num_entities ) {
 460                 ParseEntities();
 461         }
 462
 463         Sys_Printf( "%6i models       %7i\n"
 464                                 ,nummodels, (int)( nummodels * sizeof( dmodel_t ) ) );
 465         Sys_Printf( "%6i shaders      %7i\n"
 466                                 ,numShaders, (int)( numShaders * sizeof( dshader_t ) ) );
 467         Sys_Printf( "%6i brushes      %7i\n"
 468                                 ,numbrushes, (int)( numbrushes * sizeof( dbrush_t ) ) );
 469         Sys_Printf( "%6i brushsides   %7i\n"
 470                                 ,numbrushsides, (int)( numbrushsides * sizeof( dbrushside_t ) ) );
 471         Sys_Printf( "%6i fogs         %7i\n"
 472                                 ,numFogs, (int)( numFogs * sizeof( dfog_t ) ) );
 473         Sys_Printf( "%6i planes       %7i\n"
 474                                 ,numplanes, (int)( numplanes * sizeof( dplane_t ) ) );
 475         Sys_Printf( "%6i entdata      %7i\n", num_entities, entdatasize );
 476
 477         Sys_Printf( "\n" );
 478
 479         Sys_Printf( "%6i nodes        %7i\n"
 480                                 ,numnodes, (int)( numnodes * sizeof( dnode_t ) ) );
 481         Sys_Printf( "%6i leafs        %7i\n"
 482                                 ,numleafs, (int)( numleafs * sizeof( dleaf_t ) ) );
 483         Sys_Printf( "%6i leafsurfaces %7i\n"
 484                                 ,numleafsurfaces, (int)( numleafsurfaces * sizeof( dleafsurfaces[0] ) ) );
 485         Sys_Printf( "%6i leafbrushes  %7i\n"
 486                                 ,numleafbrushes, (int)( numleafbrushes * sizeof( dleafbrushes[0] ) ) );
 487         Sys_Printf( "%6i drawverts    %7i\n"
 488                                 ,numDrawVerts, (int)( numDrawVerts * sizeof( drawVerts[0] ) ) );
 489         Sys_Printf( "%6i drawindexes  %7i\n"
 490                                 ,numDrawIndexes, (int)( numDrawIndexes * sizeof( drawIndexes[0] ) ) );
 491         Sys_Printf( "%6i drawsurfaces %7i\n"
 492                                 ,numDrawSurfaces, (int)( numDrawSurfaces * sizeof( drawSurfaces[0] ) ) );
 493
 494         Sys_Printf( "%6i lightmaps    %7i\n"
 495                                 ,numLightBytes / ( LIGHTMAP_WIDTH * LIGHTMAP_HEIGHT * 3 ), numLightBytes );
 496         Sys_Printf( "       visibility   %7i\n"
 497                                 , numVisBytes );
 498 }
 499
 500
 501 //============================================
 502
 503 int num_entities;
 504 entity_t entities[MAX_MAP_ENTITIES];
 505
 506 void StripTrailing( char *e ) {
 507         char    *s;
 508
 509         s = e + strlen( e ) - 1;
 510         while ( s >= e && *s <= 32 )
 511         {
 512                 *s = 0;
 513                 s--;
 514         }
 515 }
 516
 517 /*
 518    =================
 519    ParseEpair
 520    =================
 521  */
 522 epair_t *ParseEpair( void ) {
 523         epair_t *e;
 524
 525         e = safe_malloc( sizeof( epair_t ) );
 526         memset( e, 0, sizeof( epair_t ) );
 527
 528         if ( strlen( token ) >= MAX_KEY - 1 ) {
 529                 Error( "ParseEpar: token too long" );
 530         }
 531         e->key = copystring( token );
 532         GetToken( qfalse );
 533         if ( strlen( token ) >= MAX_VALUE - 1 ) {
 534                 Error( "ParseEpar: token too long" );
 535         }
 536         e->value = copystring( token );
 537
 538         // strip trailing spaces that sometimes get accidentally
 539         // added in the editor
 540         StripTrailing( e->key );
 541         StripTrailing( e->value );
 542
 543         return e;
 544 }
 545
 546
 547 /*
 548    ================
 549    ParseEntity
 550    ================
 551  */
 552 qboolean    ParseEntity( void ) {
 553         epair_t     *e;
 554         entity_t    *mapent;
 555
 556         if ( !GetToken( qtrue ) ) {
 557                 return qfalse;
 558         }
 559
 560         if ( strcmp( token, "{" ) ) {
 561                 Error( "ParseEntity: { not found" );
 562         }
 563         if ( num_entities == MAX_MAP_ENTITIES ) {
 564                 Error( "num_entities == MAX_MAP_ENTITIES" );
 565         }
 566         mapent = &entities[num_entities];
 567         num_entities++;
 568
 569         do {
 570                 if ( !GetToken( qtrue ) ) {
 571                         Error( "ParseEntity: EOF without closing brace" );
 572                 }
 573                 if ( !strcmp( token, "}" ) ) {
 574                         break;
 575                 }
 576                 e = ParseEpair();
 577                 e->next = mapent->epairs;
 578                 mapent->epairs = e;
 579         } while ( 1 );
 580
 581         return qtrue;
 582 }
 583
 584 /*
 585    ================
 586    ParseEntities
 587
 588    Parses the dentdata string into entities
 589    ================
 590  */
 591 void ParseEntities( void ) {
 592         num_entities = 0;
 593         ParseFromMemory( dentdata, entdatasize );
 594
 595         while ( ParseEntity() ) {
 596         }
 597 }
 598
 599
 600 /*
 601    ================
 602    UnparseEntities
 603
 604    Generates the dentdata string from all the entities
 605    This allows the utilities to add or remove key/value pairs
 606    to the data created by the map editor.
 607    ================
 608  */
 609 void UnparseEntities( void ) {
 610         char    *buf, *end;
 611         epair_t *ep;
 612         char line[2048];
 613         int i;
 614         char key[1024], value[1024];
 615
 616         buf = dentdata;
 617         end = buf;
 618         *end = 0;
 619
 620         for ( i = 0 ; i < num_entities ; i++ ) {
 621                 ep = entities[i].epairs;
 622                 if ( !ep ) {
 623                         continue;   // ent got removed
 624                 }
 625
 626                 strcat( end,"{\n" );
 627                 end += 2;
 628
 629                 for ( ep = entities[i].epairs ; ep ; ep = ep->next ) {
 630                         strcpy( key, ep->key );
 631                         StripTrailing( key );
 632                         strcpy( value, ep->value );
 633                         StripTrailing( value );
 634
 635                         sprintf( line, "\"%s\" \"%s\"\n", key, value );
 636                         strcat( end, line );
 637                         end += strlen( line );
 638                 }
 639                 strcat( end,"}\n" );
 640                 end += 2;
 641
 642                 if ( end > buf + MAX_MAP_ENTSTRING ) {
 643                         Error( "Entity text too long" );
 644                 }
 645         }
 646         entdatasize = end - buf + 1;
 647 }
 648
 649 void PrintEntity( const entity_t *ent ) {
 650         epair_t *ep;
 651
 652         Sys_Printf( "------- entity %p -------\n", ent );
 653         for ( ep = ent->epairs ; ep ; ep = ep->next ) {
 654                 Sys_Printf( "%s = %s\n", ep->key, ep->value );
 655         }
 656
 657 }
 658
 659 void    SetKeyValue( entity_t *ent, const char *key, const char *value ) {
 660         epair_t *ep;
 661
 662         for ( ep = ent->epairs ; ep ; ep = ep->next ) {
 663                 if ( !strcmp( ep->key, key ) ) {
 664                         free( ep->value );
 665                         ep->value = copystring( value );
 666                         return;
 667                 }
 668         }
 669         ep = safe_malloc( sizeof( *ep ) );
 670         ep->next = ent->epairs;
 671         ent->epairs = ep;
 672         ep->key = copystring( key );
 673         ep->value = copystring( value );
 674 }
 675
 676 const char  *ValueForKey( const entity_t *ent, const char *key ) {
 677         epair_t *ep;
 678
 679         for ( ep = ent->epairs ; ep ; ep = ep->next ) {
 680                 if ( !strcmp( ep->key, key ) ) {
 681                         return ep->value;
 682                 }
 683         }
 684         return "";
 685 }
 686
 687 vec_t   FloatForKey( const entity_t *ent, const char *key ) {
 688         const char  *k;
 689
 690         k = ValueForKey( ent, key );
 691         return atof( k );
 692 }
 693
 694 void    GetVectorForKey( const entity_t *ent, const char *key, vec3_t vec ) {
 695         const char  *k;
 696         double v1, v2, v3;
 697
 698         k = ValueForKey( ent, key );
 699
 700         // scanf into doubles, then assign, so it is vec_t size independent
 701         v1 = v2 = v3 = 0;
 702         sscanf( k, "%lf %lf %lf", &v1, &v2, &v3 );
 703         vec[0] = v1;
 704         vec[1] = v2;
 705         vec[2] = v3;
 706 }