tools/quake3/q3map2/bspfile_abstract.c

   1 /* -------------------------------------------------------------------------------
   2
   3 Copyright (C) 1999-2007 id Software, Inc. and contributors.
   4 For a list of contributors, see the accompanying CONTRIBUTORS file.
   5
   6 This file is part of GtkRadiant.
   7
   8 GtkRadiant is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2 of the License, or
  11 (at your option) any later version.
  12
  13 GtkRadiant is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GtkRadiant; if not, write to the Free Software
  20 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  21
  22 ----------------------------------------------------------------------------------
  23
  24 This code has been altered significantly from its original form, to support
  25 several games based on the Quake III Arena engine, in the form of "Q3Map2."
  26
  27 ------------------------------------------------------------------------------- */
  28
  29
  30
  31 /* marker */
  32 #define BSPFILE_ABSTRACT_C
  33
  34
  35
  36 /* dependencies */
  37 #include "q3map2.h"
  38
  39
  40
  41
  42 /* -------------------------------------------------------------------------------
  43
  44 this file was copied out of the common directory in order to not break
  45 compatibility with the q3map 1.x tree. it was moved out in order to support
  46 the raven bsp format (RBSP) used in soldier of fortune 2 and jedi knight 2.
  47
  48 since each game has its own set of particular features, the data structures
  49 below no longer directly correspond to the binary format of a particular game.
  50
  51 the translation will be done at bsp load/save time to keep any sort of
  52 special-case code messiness out of the rest of the program.
  53
  54 ------------------------------------------------------------------------------- */
  55
  56
  57
  58 /* FIXME: remove the functions below that handle memory management of bsp file chunks */
  59
  60 int numBSPDrawVertsBuffer = 0;
  61 void IncDrawVerts()
  62 {
  63         numBSPDrawVerts++;
  64
  65         if(bspDrawVerts == 0)
  66         {
  67                 numBSPDrawVertsBuffer = 1024;
  68
  69                 bspDrawVerts = safe_malloc_info(sizeof(bspDrawVert_t) * numBSPDrawVertsBuffer, "IncDrawVerts");
  70
  71         }
  72         else if(numBSPDrawVerts > numBSPDrawVertsBuffer)
  73         {
  74                 numBSPDrawVertsBuffer *= 3; // multiply by 1.5
  75                 numBSPDrawVertsBuffer /= 2;
  76
  77                 bspDrawVerts = realloc(bspDrawVerts, sizeof(bspDrawVert_t) * numBSPDrawVertsBuffer);
  78
  79                 if(!bspDrawVerts)
  80                         Error( "realloc() failed (IncDrawVerts)");
  81         }
  82
  83         memset(bspDrawVerts + (numBSPDrawVerts - 1), 0, sizeof(bspDrawVert_t));
  84 }
  85
  86 void SetDrawVerts(int n)
  87 {
  88         if(bspDrawVerts != 0)
  89                 free(bspDrawVerts);
  90
  91         numBSPDrawVerts = n;
  92         numBSPDrawVertsBuffer = numBSPDrawVerts;
  93
  94         bspDrawVerts = safe_malloc_info(sizeof(bspDrawVert_t) * numBSPDrawVertsBuffer, "IncDrawVerts");
  95
  96         memset(bspDrawVerts, 0, n * sizeof(bspDrawVert_t));
  97 }
  98
  99 int numBSPDrawSurfacesBuffer = 0;
 100 void SetDrawSurfacesBuffer()
 101 {
 102         if(bspDrawSurfaces != 0)
 103                 free(bspDrawSurfaces);
 104
 105         numBSPDrawSurfacesBuffer = MAX_MAP_DRAW_SURFS;
 106
 107         bspDrawSurfaces = safe_malloc_info(sizeof(bspDrawSurface_t) * numBSPDrawSurfacesBuffer, "IncDrawSurfaces");
 108
 109         memset(bspDrawSurfaces, 0, MAX_MAP_DRAW_SURFS * sizeof(bspDrawVert_t));
 110 }
 111
 112 void SetDrawSurfaces(int n)
 113 {
 114         if(bspDrawSurfaces != 0)
 115                 free(bspDrawSurfaces);
 116
 117         numBSPDrawSurfaces = n;
 118         numBSPDrawSurfacesBuffer = numBSPDrawSurfaces;
 119
 120         bspDrawSurfaces = safe_malloc_info(sizeof(bspDrawSurface_t) * numBSPDrawSurfacesBuffer, "IncDrawSurfaces");
 121
 122         memset(bspDrawSurfaces, 0, n * sizeof(bspDrawVert_t));
 123 }
 124
 125 void BSPFilesCleanup()
 126 {
 127         if(bspDrawVerts != 0)
 128                 free(bspDrawVerts);
 129         if(bspDrawSurfaces != 0)
 130                 free(bspDrawSurfaces);
 131         if(bspLightBytes != 0)
 132                 free(bspLightBytes);
 133         if(bspGridPoints != 0)
 134                 free(bspGridPoints);
 135 }
 136
 137
 138
 139
 140
 141
 142 /*
 143 SwapBlock()
 144 if all values are 32 bits, this can be used to swap everything
 145 */
 146
 147 void SwapBlock( int *block, int size )
 148 {
 149         int             i;
 150
 151
 152         /* dummy check */
 153         if( block == NULL )
 154                 return;
 155
 156         /* swap */
 157         size >>= 2;
 158         for( i = 0; i < size; i++ )
 159                 block[ i ] = LittleLong( block[ i ] );
 160 }
 161
 162
 163
 164 /*
 165 SwapBSPFile()
 166 byte swaps all data in the abstract bsp
 167 */
 168
 169 void SwapBSPFile( void )
 170 {
 171         int             i, j;
 172
 173
 174         /* models */
 175         SwapBlock( (int*) bspModels, numBSPModels * sizeof( bspModels[ 0 ] ) );
 176
 177         /* shaders (don't swap the name) */
 178         for( i = 0; i < numBSPShaders ; i++ )
 179         {
 180                 bspShaders[ i ].contentFlags = LittleLong( bspShaders[ i ].contentFlags );
 181                 bspShaders[ i ].surfaceFlags = LittleLong( bspShaders[ i ].surfaceFlags );
 182         }
 183
 184         /* planes */
 185         SwapBlock( (int*) bspPlanes, numBSPPlanes * sizeof( bspPlanes[ 0 ] ) );
 186
 187         /* nodes */
 188         SwapBlock( (int*) bspNodes, numBSPNodes * sizeof( bspNodes[ 0 ] ) );
 189
 190         /* leafs */
 191         SwapBlock( (int*) bspLeafs, numBSPLeafs * sizeof( bspLeafs[ 0 ] ) );
 192
 193         /* leaffaces */
 194         SwapBlock( (int*) bspLeafSurfaces, numBSPLeafSurfaces * sizeof( bspLeafSurfaces[ 0 ] ) );
 195
 196         /* leafbrushes */
 197         SwapBlock( (int*) bspLeafBrushes, numBSPLeafBrushes * sizeof( bspLeafBrushes[ 0 ] ) );
 198
 199         // brushes
 200         SwapBlock( (int*) bspBrushes, numBSPBrushes * sizeof( bspBrushes[ 0 ] ) );
 201
 202         // brushsides
 203         SwapBlock( (int*) bspBrushSides, numBSPBrushSides * sizeof( bspBrushSides[ 0 ] ) );
 204
 205         // vis
 206         ((int*) &bspVisBytes)[ 0 ] = LittleLong( ((int*) &bspVisBytes)[ 0 ] );
 207         ((int*) &bspVisBytes)[ 1 ] = LittleLong( ((int*) &bspVisBytes)[ 1 ] );
 208
 209         /* drawverts (don't swap colors) */
 210         for( i = 0; i < numBSPDrawVerts; i++ )
 211         {
 212                 bspDrawVerts[ i ].xyz[ 0 ] = LittleFloat( bspDrawVerts[ i ].xyz[ 0 ] );
 213                 bspDrawVerts[ i ].xyz[ 1 ] = LittleFloat( bspDrawVerts[ i ].xyz[ 1 ] );
 214                 bspDrawVerts[ i ].xyz[ 2 ] = LittleFloat( bspDrawVerts[ i ].xyz[ 2 ] );
 215                 bspDrawVerts[ i ].normal[ 0 ] = LittleFloat( bspDrawVerts[ i ].normal[ 0 ] );
 216                 bspDrawVerts[ i ].normal[ 1 ] = LittleFloat( bspDrawVerts[ i ].normal[ 1 ] );
 217                 bspDrawVerts[ i ].normal[ 2 ] = LittleFloat( bspDrawVerts[ i ].normal[ 2 ] );
 218                 bspDrawVerts[ i ].st[ 0 ] = LittleFloat( bspDrawVerts[ i ].st[ 0 ] );
 219                 bspDrawVerts[ i ].st[ 1 ] = LittleFloat( bspDrawVerts[ i ].st[ 1 ] );
 220                 for( j = 0; j < MAX_LIGHTMAPS; j++ )
 221                 {
 222                         bspDrawVerts[ i ].lightmap[ j ][ 0 ] = LittleFloat( bspDrawVerts[ i ].lightmap[ j ][ 0 ] );
 223                         bspDrawVerts[ i ].lightmap[ j ][ 1 ] = LittleFloat( bspDrawVerts[ i ].lightmap[ j ][ 1 ] );
 224                 }
 225         }
 226
 227         /* drawindexes */
 228         SwapBlock( (int*) bspDrawIndexes, numBSPDrawIndexes * sizeof( bspDrawIndexes[0] ) );
 229
 230         /* drawsurfs */
 231         /* note: rbsp files (and hence q3map2 abstract bsp) have byte lightstyles index arrays, this follows sof2map convention */
 232         SwapBlock( (int*) bspDrawSurfaces, numBSPDrawSurfaces * sizeof( bspDrawSurfaces[ 0 ] ) );
 233
 234         /* fogs */
 235         for( i = 0; i < numBSPFogs; i++ )
 236         {
 237                 bspFogs[ i ].brushNum = LittleLong( bspFogs[ i ].brushNum );
 238                 bspFogs[ i ].visibleSide = LittleLong( bspFogs[ i ].visibleSide );
 239         }
 240
 241         /* advertisements */
 242         for( i = 0; i < numBSPAds; i++ )
 243         {
 244                 bspAds[ i ].cellId = LittleLong( bspAds[ i ].cellId );
 245                 bspAds[ i ].normal[ 0 ] = LittleFloat( bspAds[ i ].normal[ 0 ] );
 246                 bspAds[ i ].normal[ 1 ] = LittleFloat( bspAds[ i ].normal[ 1 ] );
 247                 bspAds[ i ].normal[ 2 ] = LittleFloat( bspAds[ i ].normal[ 2 ] );
 248
 249                 for( j = 0; j < 4; j++ )
 250                 {
 251                         bspAds[ i ].rect[j][ 0 ] = LittleFloat( bspAds[ i ].rect[j][ 0 ] );
 252                         bspAds[ i ].rect[j][ 1 ] = LittleFloat( bspAds[ i ].rect[j][ 1 ] );
 253                         bspAds[ i ].rect[j][ 2 ] = LittleFloat( bspAds[ i ].rect[j][ 2 ] );
 254                 }
 255
 256                 //bspAds[ i ].model[ MAX_QPATH ];
 257         }
 258 }
 259
 260
 261
 262 /*
 263 GetLumpElements()
 264 gets the number of elements in a bsp lump
 265 */
 266
 267 int GetLumpElements( bspHeader_t *header, int lump, int size )
 268 {
 269         /* check for odd size */
 270         if( header->lumps[ lump ].length % size )
 271         {
 272                 if( force )
 273                 {
 274                         Sys_Printf( "WARNING: GetLumpElements: odd lump size (%d) in lump %d\n", header->lumps[ lump ].length, lump );
 275                         return 0;
 276                 }
 277                 else
 278                         Error( "GetLumpElements: odd lump size (%d) in lump %d", header->lumps[ lump ].length, lump );
 279         }
 280
 281         /* return element count */
 282         return header->lumps[ lump ].length / size;
 283 }
 284
 285
 286
 287 /*
 288 GetLump()
 289 returns a pointer to the specified lump
 290 */
 291
 292 void *GetLump( bspHeader_t *header, int lump )
 293 {
 294         return (void*)( (byte*) header + header->lumps[ lump ].offset);
 295 }
 296
 297
 298
 299 /*
 300 CopyLump()
 301 copies a bsp file lump into a destination buffer
 302 */
 303
 304 int CopyLump( bspHeader_t *header, int lump, void *dest, int size )
 305 {
 306         int             length, offset;
 307
 308
 309         /* get lump length and offset */
 310         length = header->lumps[ lump ].length;
 311         offset = header->lumps[ lump ].offset;
 312
 313         /* handle erroneous cases */
 314         if( length == 0 )
 315                 return 0;
 316         if( length % size )
 317         {
 318                 if( force )
 319                 {
 320                         Sys_Printf( "WARNING: CopyLump: odd lump size (%d) in lump %d\n", length, lump );
 321                         return 0;
 322                 }
 323                 else
 324                         Error( "CopyLump: odd lump size (%d) in lump %d", length, lump );
 325         }
 326
 327         /* copy block of memory and return */
 328         memcpy( dest, (byte*) header + offset, length );
 329         return length / size;
 330 }
 331
 332 int CopyLump_Allocate( bspHeader_t *header, int lump, void **dest, int size, int *allocationVariable )
 333 {
 334         /* get lump length and offset */
 335         *allocationVariable = header->lumps[ lump ].length / size;
 336         *dest = realloc(*dest, size * *allocationVariable);
 337         return CopyLump(header, lump, *dest, size);
 338 }
 339
 340
 341 /*
 342 AddLump()
 343 adds a lump to an outgoing bsp file
 344 */
 345
 346 void AddLump( FILE *file, bspHeader_t *header, int lumpNum, const void *data, int length )
 347 {
 348         bspLump_t       *lump;
 349
 350
 351         /* add lump to bsp file header */
 352         lump = &header->lumps[ lumpNum ];
 353         lump->offset = LittleLong( ftell( file ) );
 354         lump->length = LittleLong( length );
 355
 356         /* write lump to file */
 357         SafeWrite( file, data, (length + 3) & ~3 );
 358 }
 359
 360
 361
 362 /*
 363 LoadBSPFile()
 364 loads a bsp file into memory
 365 */
 366
 367 void LoadBSPFile( const char *filename )
 368 {
 369         /* dummy check */
 370         if( game == NULL || game->load == NULL )
 371                 Error( "LoadBSPFile: unsupported BSP file format" );
 372
 373         /* load it, then byte swap the in-memory version */
 374         game->load( filename );
 375         SwapBSPFile();
 376 }
 377
 378
 379
 380 /*
 381 WriteBSPFile()
 382 writes a bsp file
 383 */
 384
 385 void WriteBSPFile( const char *filename )
 386 {
 387         char    tempname[ 1024 ];
 388         time_t  tm;
 389
 390
 391         /* dummy check */
 392         if( game == NULL || game->write == NULL )
 393                 Error( "WriteBSPFile: unsupported BSP file format" );
 394
 395         /* make fake temp name so existing bsp file isn't damaged in case write process fails */
 396         time( &tm );
 397         sprintf( tempname, "%s.%08X", filename, (int) tm );
 398
 399         /* byteswap, write the bsp, then swap back so it can be manipulated further */
 400         SwapBSPFile();
 401         game->write( tempname );
 402         SwapBSPFile();
 403
 404         /* replace existing bsp file */
 405         remove( filename );
 406         rename( tempname, filename );
 407 }
 408
 409
 410
 411 /*
 412 PrintBSPFileSizes()
 413 dumps info about current file
 414 */
 415
 416 void PrintBSPFileSizes( void )
 417 {
 418         /* parse entities first */
 419         if( numEntities <= 0 )
 420                 ParseEntities();
 421
 422         /* note that this is abstracted */
 423         Sys_Printf( "Abstracted BSP file components (*actual sizes may differ)\n" );
 424
 425         /* print various and sundry bits */
 426         Sys_Printf( "%9d models        %9d\n",
 427                 numBSPModels, (int) (numBSPModels * sizeof( bspModel_t )) );
 428         Sys_Printf( "%9d shaders       %9d\n",
 429                 numBSPShaders, (int) (numBSPShaders * sizeof( bspShader_t )) );
 430         Sys_Printf( "%9d brushes       %9d\n",
 431                 numBSPBrushes, (int) (numBSPBrushes * sizeof( bspBrush_t )) );
 432         Sys_Printf( "%9d brushsides    %9d *\n",
 433                 numBSPBrushSides, (int) (numBSPBrushSides * sizeof( bspBrushSide_t )) );
 434         Sys_Printf( "%9d fogs          %9d\n",
 435                 numBSPFogs, (int) (numBSPFogs * sizeof( bspFog_t ) ) );
 436         Sys_Printf( "%9d planes        %9d\n",
 437                 numBSPPlanes, (int) (numBSPPlanes * sizeof( bspPlane_t )) );
 438         Sys_Printf( "%9d entdata       %9d\n",
 439                 numEntities, bspEntDataSize );
 440         Sys_Printf( "\n");
 441
 442         Sys_Printf( "%9d nodes         %9d\n",
 443                 numBSPNodes, (int) (numBSPNodes * sizeof( bspNode_t)) );
 444         Sys_Printf( "%9d leafs         %9d\n",
 445                 numBSPLeafs, (int) (numBSPLeafs * sizeof( bspLeaf_t )) );
 446         Sys_Printf( "%9d leafsurfaces  %9d\n",
 447                 numBSPLeafSurfaces, (int) (numBSPLeafSurfaces * sizeof( *bspLeafSurfaces )) );
 448         Sys_Printf( "%9d leafbrushes   %9d\n",
 449                 numBSPLeafBrushes, (int) (numBSPLeafBrushes * sizeof( *bspLeafBrushes )) );
 450         Sys_Printf( "\n");
 451
 452         Sys_Printf( "%9d drawsurfaces  %9d *\n",
 453                 numBSPDrawSurfaces, (int) (numBSPDrawSurfaces * sizeof( *bspDrawSurfaces )) );
 454         Sys_Printf( "%9d drawverts     %9d *\n",
 455                 numBSPDrawVerts, (int) (numBSPDrawVerts * sizeof( *bspDrawVerts )) );
 456         Sys_Printf( "%9d drawindexes   %9d\n",
 457                 numBSPDrawIndexes, (int) (numBSPDrawIndexes * sizeof( *bspDrawIndexes )) );
 458         Sys_Printf( "\n");
 459
 460         Sys_Printf( "%9d lightmaps     %9d\n",
 461                 numBSPLightBytes / (game->lightmapSize * game->lightmapSize * 3), numBSPLightBytes );
 462         Sys_Printf( "%9d lightgrid     %9d *\n",
 463                 numBSPGridPoints, (int) (numBSPGridPoints * sizeof( *bspGridPoints )) );
 464         Sys_Printf( "          visibility    %9d\n",
 465                 numBSPVisBytes );
 466 }
 467
 468
 469
 470 /* -------------------------------------------------------------------------------
 471
 472 entity data handling
 473
 474 ------------------------------------------------------------------------------- */
 475
 476
 477 /*
 478 StripTrailing()
 479 strips low byte chars off the end of a string
 480 */
 481
 482 void StripTrailing( char *e )
 483 {
 484         char    *s;
 485
 486
 487         s = e + strlen( e ) - 1;
 488         while( s >= e && *s <= 32 )
 489         {
 490                 *s = 0;
 491                 s--;
 492         }
 493 }
 494
 495
 496
 497 /*
 498 ParseEpair()
 499 parses a single quoted "key" "value" pair into an epair struct
 500 */
 501
 502 epair_t *ParseEPair( void )
 503 {
 504         epair_t         *e;
 505
 506
 507         /* allocate and clear new epair */
 508         e = safe_malloc( sizeof( epair_t ) );
 509         memset( e, 0, sizeof( epair_t ) );
 510
 511         /* handle key */
 512         if( strlen( token ) >= (MAX_KEY - 1) )
 513                 Error( "ParseEPair: token too long" );
 514
 515         e->key = copystring( token );
 516         GetToken( qfalse );
 517
 518         /* handle value */
 519         if( strlen( token ) >= MAX_VALUE - 1 )
 520                 Error( "ParseEpar: token too long" );
 521         e->value = copystring( token );
 522
 523         /* strip trailing spaces that sometimes get accidentally added in the editor */
 524         StripTrailing( e->key );
 525         StripTrailing( e->value );
 526
 527         /* return it */
 528         return e;
 529 }
 530
 531
 532
 533 /*
 534 ParseEntity()
 535 parses an entity's epairs
 536 */
 537
 538 qboolean ParseEntity( void )
 539 {
 540         epair_t         *e;
 541
 542
 543         /* dummy check */
 544         if( !GetToken( qtrue ) )
 545                 return qfalse;
 546         if( strcmp( token, "{" ) )
 547                 Error( "ParseEntity: { not found" );
 548         if( numEntities == MAX_MAP_ENTITIES )
 549                 Error( "numEntities == MAX_MAP_ENTITIES" );
 550
 551         /* create new entity */
 552         mapEnt = &entities[ numEntities ];
 553         numEntities++;
 554
 555         /* parse */
 556         while( 1 )
 557         {
 558                 if( !GetToken( qtrue ) )
 559                         Error( "ParseEntity: EOF without closing brace" );
 560                 if( !EPAIR_STRCMP( token, "}" ) )
 561                         break;
 562                 e = ParseEPair();
 563                 e->next = mapEnt->epairs;
 564                 mapEnt->epairs = e;
 565         }
 566
 567         /* return to sender */
 568         return qtrue;
 569 }
 570
 571
 572
 573 /*
 574 ParseEntities()
 575 parses the bsp entity data string into entities
 576 */
 577
 578 void ParseEntities( void )
 579 {
 580         numEntities = 0;
 581         ParseFromMemory( bspEntData, bspEntDataSize );
 582         while( ParseEntity() );
 583
 584         /* ydnar: set number of bsp entities in case a map is loaded on top */
 585         numBSPEntities = numEntities;
 586 }
 587
 588 /*
 589  * must be called before UnparseEntities
 590  */
 591 void InjectCommandLine(char **argv, int beginArgs, int endArgs)
 592 {
 593         const char *previousCommandLine;
 594         char newCommandLine[1024];
 595         const char *inpos;
 596         char *outpos = newCommandLine;
 597         char *sentinel = newCommandLine + sizeof(newCommandLine) - 1;
 598         int i;
 599
 600         previousCommandLine = ValueForKey(&entities[0], "_q3map2_cmdline");
 601         if(previousCommandLine && *previousCommandLine)
 602         {
 603                 inpos = previousCommandLine;
 604                 while(outpos != sentinel && *inpos)
 605                         *outpos++ = *inpos++;
 606                 if(outpos != sentinel)
 607                         *outpos++ = ';';
 608                 if(outpos != sentinel)
 609                         *outpos++ = ' ';
 610         }
 611
 612         for(i = beginArgs; i < endArgs; ++i)
 613         {
 614                 if(outpos != sentinel && i != beginArgs)
 615                         *outpos++ = ' ';
 616                 inpos = argv[i];
 617                 while(outpos != sentinel && *inpos)
 618                         if(*inpos != '\\' && *inpos != '"' && *inpos != ';' && (unsigned char) *inpos >= ' ')
 619                                 *outpos++ = *inpos++;
 620         }
 621
 622         *outpos = 0;
 623         SetKeyValue(&entities[0], "_q3map2_cmdline", newCommandLine);
 624         SetKeyValue(&entities[0], "_q3map2_version", Q3MAP_VERSION);
 625 }
 626
 627 /*
 628 UnparseEntities()
 629 generates the dentdata string from all the entities.
 630 this allows the utilities to add or remove key/value
 631 pairs to the data created by the map editor
 632 */
 633
 634 void UnparseEntities( void )
 635 {
 636         int                     i;
 637         char            *buf, *end;
 638         epair_t         *ep;
 639         char            line[ 2048 ];
 640         char            key[ 1024 ], value[ 1024 ];
 641         const char      *value2;
 642
 643
 644         /* setup */
 645         buf = bspEntData;
 646         end = buf;
 647         *end = 0;
 648
 649         /* run through entity list */
 650         for( i = 0; i < numBSPEntities && i < numEntities; i++ )
 651         {
 652                 {
 653                         int sz = end - buf;
 654                         AUTOEXPAND_BY_REALLOC(bspEntData, sz + 65536, allocatedBSPEntData, 1024);
 655                         buf = bspEntData;
 656                         end = buf + sz;
 657                 }
 658
 659                 /* get epair */
 660                 ep = entities[ i ].epairs;
 661                 if( ep == NULL )
 662                         continue;       /* ent got removed */
 663
 664                 /* ydnar: certain entities get stripped from bsp file */
 665                 value2 = ValueForKey( &entities[ i ], "classname" );
 666                 if( !Q_stricmp( value2, "misc_model" ) ||
 667                         !Q_stricmp( value2, "_decal" ) ||
 668                         !Q_stricmp( value2, "_skybox" ) )
 669                         continue;
 670
 671                 /* add beginning brace */
 672                 strcat( end, "{\n" );
 673                 end += 2;
 674
 675                 /* walk epair list */
 676                 for( ep = entities[ i ].epairs; ep != NULL; ep = ep->next )
 677                 {
 678                         /* copy and clean */
 679                         strcpy( key, ep->key );
 680                         StripTrailing( key );
 681                         strcpy( value, ep->value );
 682                         StripTrailing( value );
 683
 684                         /* add to buffer */
 685                         sprintf( line, "\"%s\" \"%s\"\n", key, value );
 686                         strcat( end, line );
 687                         end += strlen( line );
 688                 }
 689
 690                 /* add trailing brace */
 691                 strcat( end,"}\n" );
 692                 end += 2;
 693
 694                 /* check for overflow */
 695                 if( end > buf + allocatedBSPEntData )
 696                         Error( "Entity text too long" );
 697         }
 698
 699         /* set size */
 700         bspEntDataSize = end - buf + 1;
 701 }
 702
 703
 704
 705 /*
 706 PrintEntity()
 707 prints an entity's epairs to the console
 708 */
 709
 710 void PrintEntity( const entity_t *ent )
 711 {
 712         epair_t *ep;
 713
 714
 715         Sys_Printf( "------- entity %p -------\n", ent );
 716         for( ep = ent->epairs; ep != NULL; ep = ep->next )
 717                 Sys_Printf( "%s = %s\n", ep->key, ep->value );
 718
 719 }
 720
 721
 722
 723 /*
 724 SetKeyValue()
 725 sets an epair in an entity
 726 */
 727
 728 void SetKeyValue( entity_t *ent, const char *key, const char *value )
 729 {
 730         epair_t *ep;
 731
 732
 733         /* check for existing epair */
 734         for( ep = ent->epairs; ep != NULL; ep = ep->next )
 735         {
 736                 if( !EPAIR_STRCMP( ep->key, key ) )
 737                 {
 738                         free( ep->value );
 739                         ep->value = copystring( value );
 740                         return;
 741                 }
 742         }
 743
 744         /* create new epair */
 745         ep = safe_malloc( sizeof( *ep ) );
 746         ep->next = ent->epairs;
 747         ent->epairs = ep;
 748         ep->key = copystring( key );
 749         ep->value = copystring( value );
 750 }
 751
 752 /*
 753 KeyExists()
 754 returns true if entity has this key
 755 */
 756
 757 qboolean KeyExists( const entity_t *ent, const char *key )
 758 {
 759         epair_t *ep;
 760
 761         /* walk epair list */
 762         for( ep = ent->epairs; ep != NULL; ep = ep->next )
 763         {
 764                 if( !EPAIR_STRCMP( ep->key, key ) )
 765                         return qtrue;
 766         }
 767
 768         /* no match */
 769         return qfalse;
 770 }
 771
 772 /*
 773 ValueForKey()
 774 gets the value for an entity key
 775 */
 776
 777 const char *ValueForKey( const entity_t *ent, const char *key )
 778 {
 779         epair_t *ep;
 780
 781
 782         /* dummy check */
 783         if( ent == NULL )
 784                 return "";
 785
 786         /* walk epair list */
 787         for( ep = ent->epairs; ep != NULL; ep = ep->next )
 788         {
 789                 if( !EPAIR_STRCMP( ep->key, key ) )
 790                         return ep->value;
 791         }
 792
 793         /* if no match, return empty string */
 794         return "";
 795 }
 796
 797
 798
 799 /*
 800 IntForKey()
 801 gets the integer point value for an entity key
 802 */
 803
 804 int IntForKey( const entity_t *ent, const char *key )
 805 {
 806         const char      *k;
 807
 808
 809         k = ValueForKey( ent, key );
 810         return atoi( k );
 811 }
 812
 813
 814
 815 /*
 816 FloatForKey()
 817 gets the floating point value for an entity key
 818 */
 819
 820 vec_t FloatForKey( const entity_t *ent, const char *key )
 821 {
 822         const char      *k;
 823
 824
 825         k = ValueForKey( ent, key );
 826         return atof( k );
 827 }
 828
 829
 830
 831 /*
 832 GetVectorForKey()
 833 gets a 3-element vector value for an entity key
 834 */
 835
 836 void GetVectorForKey( const entity_t *ent, const char *key, vec3_t vec )
 837 {
 838         const char      *k;
 839         double          v1, v2, v3;
 840
 841
 842         /* get value */
 843         k = ValueForKey( ent, key );
 844
 845         /* scanf into doubles, then assign, so it is vec_t size independent */
 846         v1 = v2 = v3 = 0.0;
 847         sscanf( k, "%lf %lf %lf", &v1, &v2, &v3 );
 848         vec[ 0 ] = v1;
 849         vec[ 1 ] = v2;
 850         vec[ 2 ] = v3;
 851 }
 852
 853
 854
 855 /*
 856 FindTargetEntity()
 857 finds an entity target
 858 */
 859
 860 entity_t *FindTargetEntity( const char *target )
 861 {
 862         int                     i;
 863         const char      *n;
 864
 865
 866         /* walk entity list */
 867         for( i = 0; i < numEntities; i++ )
 868         {
 869                 n = ValueForKey( &entities[ i ], "targetname" );
 870                 if ( !strcmp( n, target ) )
 871                         return &entities[ i ];
 872         }
 873
 874         /* nada */
 875         return NULL;
 876 }
 877
 878
 879
 880 /*
 881 GetEntityShadowFlags() - ydnar
 882 gets an entity's shadow flags
 883 note: does not set them to defaults if the keys are not found!
 884 */
 885
 886 void GetEntityShadowFlags( const entity_t *ent, const entity_t *ent2, int *castShadows, int *recvShadows )
 887 {
 888         const char      *value;
 889
 890         /* get cast shadows */
 891         if( castShadows != NULL )
 892         {
 893                 value = ValueForKey( ent, "_castShadows" );
 894                 if( value[ 0 ] == '\0' )
 895                         value = ValueForKey( ent, "_cs" );
 896                 if( value[ 0 ] == '\0' )
 897                         value = ValueForKey( ent2, "_castShadows" );
 898                 if( value[ 0 ] == '\0' )
 899                         value = ValueForKey( ent2, "_cs" );
 900                 if( value[ 0 ] != '\0' )
 901                         *castShadows = atoi( value );
 902         }
 903
 904         /* receive */
 905         if( recvShadows != NULL )
 906         {
 907                 value = ValueForKey( ent, "_receiveShadows" );
 908                 if( value[ 0 ] == '\0' )
 909                         value = ValueForKey( ent, "_rs" );
 910                 if( value[ 0 ] == '\0' )
 911                         value = ValueForKey( ent2, "_receiveShadows" );
 912                 if( value[ 0 ] == '\0' )
 913                         value = ValueForKey( ent2, "_rs" );
 914                 if( value[ 0 ] != '\0' )
 915                         *recvShadows = atoi( value );
 916         }
 917
 918         /* vortex: game-specific default eneity keys */
 919         value = ValueForKey( ent, "classname" );
 920         if (!Q_stricmp( game->magic, "dq" ) || !Q_stricmp( game->magic, "prophecy" ) )
 921         {
 922                 /* vortex: deluxe quake default shadow flags */
 923                 if (!Q_stricmp( value, "func_wall" ) )
 924                 {
 925                         if( recvShadows != NULL )
 926                                 *recvShadows = 1;
 927                         if( castShadows != NULL )
 928                                 *castShadows = 1;
 929                 }
 930         }
 931 }
 932