initial
[divverent/netradiant.git] / 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 = MAX_MAP_DRAW_VERTS / 37;
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                 if(numBSPDrawVertsBuffer > MAX_MAP_DRAW_VERTS)
78                         numBSPDrawVertsBuffer = MAX_MAP_DRAW_VERTS;
79
80                 bspDrawVerts = realloc(bspDrawVerts, sizeof(bspDrawVert_t) * numBSPDrawVertsBuffer);
81
82                 if(!bspDrawVerts)
83                         Error( "realloc() failed (IncDrawVerts)");
84         }
85
86         memset(bspDrawVerts + (numBSPDrawVerts - 1), 0, sizeof(bspDrawVert_t));
87 }
88
89 void SetDrawVerts(int n)
90 {
91         if(bspDrawVerts != 0)
92                 free(bspDrawVerts);
93
94         numBSPDrawVerts = n;
95         numBSPDrawVertsBuffer = numBSPDrawVerts;
96
97         bspDrawVerts = safe_malloc_info(sizeof(bspDrawVert_t) * numBSPDrawVertsBuffer, "IncDrawVerts");
98
99         memset(bspDrawVerts, 0, n * sizeof(bspDrawVert_t));
100 }
101
102 int numBSPDrawSurfacesBuffer = 0;
103 void SetDrawSurfacesBuffer()
104 {
105         if(bspDrawSurfaces != 0)
106                 free(bspDrawSurfaces);
107
108         numBSPDrawSurfacesBuffer = MAX_MAP_DRAW_SURFS;
109
110         bspDrawSurfaces = safe_malloc_info(sizeof(bspDrawSurface_t) * numBSPDrawSurfacesBuffer, "IncDrawSurfaces");
111
112         memset(bspDrawSurfaces, 0, MAX_MAP_DRAW_SURFS * sizeof(bspDrawVert_t));
113 }
114
115 void SetDrawSurfaces(int n)
116 {
117         if(bspDrawSurfaces != 0)
118                 free(bspDrawSurfaces);
119
120         numBSPDrawSurfaces = n;
121         numBSPDrawSurfacesBuffer = numBSPDrawSurfaces;
122
123         bspDrawSurfaces = safe_malloc_info(sizeof(bspDrawSurface_t) * numBSPDrawSurfacesBuffer, "IncDrawSurfaces");
124
125         memset(bspDrawSurfaces, 0, n * sizeof(bspDrawVert_t));
126 }
127
128 void BSPFilesCleanup()
129 {
130         if(bspDrawVerts != 0)
131                 free(bspDrawVerts);
132         if(bspDrawSurfaces != 0)
133                 free(bspDrawSurfaces);
134         if(bspLightBytes != 0)
135                 free(bspLightBytes);
136         if(bspGridPoints != 0)
137                 free(bspGridPoints);
138 }
139
140
141
142
143
144
145 /*
146 SwapBlock()
147 if all values are 32 bits, this can be used to swap everything
148 */
149
150 void SwapBlock( int *block, int size )
151 {
152         int             i;
153         
154         
155         /* dummy check */
156         if( block == NULL )
157                 return;
158         
159         /* swap */
160         size >>= 2;
161         for( i = 0; i < size; i++ )
162                 block[ i ] = LittleLong( block[ i ] );
163 }
164
165
166
167 /*
168 SwapBSPFile()
169 byte swaps all data in the abstract bsp
170 */
171
172 void SwapBSPFile( void )
173 {
174         int             i, j;
175         
176         
177         /* models */
178         SwapBlock( (int*) bspModels, numBSPModels * sizeof( bspModels[ 0 ] ) );
179
180         /* shaders (don't swap the name) */
181         for( i = 0; i < numBSPShaders ; i++ )
182         {
183                 bspShaders[ i ].contentFlags = LittleLong( bspShaders[ i ].contentFlags );
184                 bspShaders[ i ].surfaceFlags = LittleLong( bspShaders[ i ].surfaceFlags );
185         }
186
187         /* planes */
188         SwapBlock( (int*) bspPlanes, numBSPPlanes * sizeof( bspPlanes[ 0 ] ) );
189         
190         /* nodes */
191         SwapBlock( (int*) bspNodes, numBSPNodes * sizeof( bspNodes[ 0 ] ) );
192
193         /* leafs */
194         SwapBlock( (int*) bspLeafs, numBSPLeafs * sizeof( bspLeafs[ 0 ] ) );
195
196         /* leaffaces */
197         SwapBlock( (int*) bspLeafSurfaces, numBSPLeafSurfaces * sizeof( bspLeafSurfaces[ 0 ] ) );
198
199         /* leafbrushes */
200         SwapBlock( (int*) bspLeafBrushes, numBSPLeafBrushes * sizeof( bspLeafBrushes[ 0 ] ) );
201
202         // brushes
203         SwapBlock( (int*) bspBrushes, numBSPBrushes * sizeof( bspBrushes[ 0 ] ) );
204
205         // brushsides
206         SwapBlock( (int*) bspBrushSides, numBSPBrushSides * sizeof( bspBrushSides[ 0 ] ) );
207
208         // vis
209         ((int*) &bspVisBytes)[ 0 ] = LittleLong( ((int*) &bspVisBytes)[ 0 ] );
210         ((int*) &bspVisBytes)[ 1 ] = LittleLong( ((int*) &bspVisBytes)[ 1 ] );
211
212         /* drawverts (don't swap colors) */
213         for( i = 0; i < numBSPDrawVerts; i++ )
214         {
215                 bspDrawVerts[ i ].xyz[ 0 ] = LittleFloat( bspDrawVerts[ i ].xyz[ 0 ] );
216                 bspDrawVerts[ i ].xyz[ 1 ] = LittleFloat( bspDrawVerts[ i ].xyz[ 1 ] );
217                 bspDrawVerts[ i ].xyz[ 2 ] = LittleFloat( bspDrawVerts[ i ].xyz[ 2 ] );
218                 bspDrawVerts[ i ].normal[ 0 ] = LittleFloat( bspDrawVerts[ i ].normal[ 0 ] );
219                 bspDrawVerts[ i ].normal[ 1 ] = LittleFloat( bspDrawVerts[ i ].normal[ 1 ] );
220                 bspDrawVerts[ i ].normal[ 2 ] = LittleFloat( bspDrawVerts[ i ].normal[ 2 ] );
221                 bspDrawVerts[ i ].st[ 0 ] = LittleFloat( bspDrawVerts[ i ].st[ 0 ] );
222                 bspDrawVerts[ i ].st[ 1 ] = LittleFloat( bspDrawVerts[ i ].st[ 1 ] );
223                 for( j = 0; j < MAX_LIGHTMAPS; j++ )
224                 {
225                         bspDrawVerts[ i ].lightmap[ j ][ 0 ] = LittleFloat( bspDrawVerts[ i ].lightmap[ j ][ 0 ] );
226                         bspDrawVerts[ i ].lightmap[ j ][ 1 ] = LittleFloat( bspDrawVerts[ i ].lightmap[ j ][ 1 ] );
227                 }
228         }
229         
230         /* drawindexes */
231         SwapBlock( (int*) bspDrawIndexes, numBSPDrawIndexes * sizeof( bspDrawIndexes[0] ) );
232
233         /* drawsurfs */
234         /* note: rbsp files (and hence q3map2 abstract bsp) have byte lightstyles index arrays, this follows sof2map convention */
235         SwapBlock( (int*) bspDrawSurfaces, numBSPDrawSurfaces * sizeof( bspDrawSurfaces[ 0 ] ) );
236
237         /* fogs */
238         for( i = 0; i < numBSPFogs; i++ )
239         {
240                 bspFogs[ i ].brushNum = LittleLong( bspFogs[ i ].brushNum );
241                 bspFogs[ i ].visibleSide = LittleLong( bspFogs[ i ].visibleSide );
242         }
243
244         /* advertisements */
245         for( i = 0; i < numBSPAds; i++ )
246         {
247                 bspAds[ i ].cellId = LittleLong( bspAds[ i ].cellId );
248                 bspAds[ i ].normal[ 0 ] = LittleFloat( bspAds[ i ].normal[ 0 ] );
249                 bspAds[ i ].normal[ 1 ] = LittleFloat( bspAds[ i ].normal[ 1 ] );
250                 bspAds[ i ].normal[ 2 ] = LittleFloat( bspAds[ i ].normal[ 2 ] );
251
252                 for( j = 0; j < 4; j++ ) 
253                 {
254                         bspAds[ i ].rect[j][ 0 ] = LittleFloat( bspAds[ i ].rect[j][ 0 ] );
255                         bspAds[ i ].rect[j][ 1 ] = LittleFloat( bspAds[ i ].rect[j][ 1 ] );
256                         bspAds[ i ].rect[j][ 2 ] = LittleFloat( bspAds[ i ].rect[j][ 2 ] );
257                 }
258
259                 //bspAds[ i ].model[ MAX_QPATH ];
260         }
261 }
262
263
264
265 /*
266 GetLumpElements()
267 gets the number of elements in a bsp lump
268 */
269
270 int GetLumpElements( bspHeader_t *header, int lump, int size )
271 {
272         /* check for odd size */
273         if( header->lumps[ lump ].length % size )
274         {
275                 if( force )
276                 {
277                         Sys_Printf( "WARNING: GetLumpElements: odd lump size (%d) in lump %d\n", header->lumps[ lump ].length, lump );
278                         return 0;
279                 }
280                 else
281                         Error( "GetLumpElements: odd lump size (%d) in lump %d", header->lumps[ lump ].length, lump );
282         }
283         
284         /* return element count */
285         return header->lumps[ lump ].length / size;
286 }
287
288
289
290 /*
291 GetLump()
292 returns a pointer to the specified lump
293 */
294
295 void *GetLump( bspHeader_t *header, int lump )
296 {
297         return (void*)( (byte*) header + header->lumps[ lump ].offset);
298 }
299
300
301
302 /*
303 CopyLump()
304 copies a bsp file lump into a destination buffer
305 */
306
307 int CopyLump( bspHeader_t *header, int lump, void *dest, int size )
308 {
309         int             length, offset;
310         
311         
312         /* get lump length and offset */
313         length = header->lumps[ lump ].length;
314         offset = header->lumps[ lump ].offset;
315         
316         /* handle erroneous cases */
317         if( length == 0 )
318                 return 0;
319         if( length % size )
320         {
321                 if( force )
322                 {
323                         Sys_Printf( "WARNING: CopyLump: odd lump size (%d) in lump %d\n", length, lump );
324                         return 0;
325                 }
326                 else
327                         Error( "CopyLump: odd lump size (%d) in lump %d", length, lump );
328         }
329         
330         /* copy block of memory and return */
331         memcpy( dest, (byte*) header + offset, length );
332         return length / size;
333 }
334
335
336
337 /*
338 AddLump()
339 adds a lump to an outgoing bsp file
340 */
341
342 void AddLump( FILE *file, bspHeader_t *header, int lumpNum, const void *data, int length )
343 {
344         bspLump_t       *lump;
345         
346         
347         /* add lump to bsp file header */
348         lump = &header->lumps[ lumpNum ];
349         lump->offset = LittleLong( ftell( file ) );
350         lump->length = LittleLong( length );
351         
352         /* write lump to file */
353         SafeWrite( file, data, (length + 3) & ~3 );
354 }
355
356
357
358 /*
359 LoadBSPFile()
360 loads a bsp file into memory
361 */
362
363 void LoadBSPFile( const char *filename )
364 {
365         /* dummy check */
366         if( game == NULL || game->load == NULL )
367                 Error( "LoadBSPFile: unsupported BSP file format" );
368         
369         /* load it, then byte swap the in-memory version */
370         game->load( filename );
371         SwapBSPFile();
372 }
373
374
375
376 /*
377 WriteBSPFile()
378 writes a bsp file
379 */
380
381 void WriteBSPFile( const char *filename )
382 {
383         char    tempname[ 1024 ];
384         time_t  tm;
385         
386         
387         /* dummy check */
388         if( game == NULL || game->write == NULL )
389                 Error( "WriteBSPFile: unsupported BSP file format" );
390         
391         /* make fake temp name so existing bsp file isn't damaged in case write process fails */
392         time( &tm );
393         sprintf( tempname, "%s.%08X", filename, (int) tm );
394         
395         /* byteswap, write the bsp, then swap back so it can be manipulated further */
396         SwapBSPFile();
397         game->write( tempname );
398         SwapBSPFile();
399         
400         /* replace existing bsp file */
401         remove( filename );
402         rename( tempname, filename );
403 }
404
405
406
407 /*
408 PrintBSPFileSizes()
409 dumps info about current file
410 */
411
412 void PrintBSPFileSizes( void )
413 {
414         /* parse entities first */
415         if( numEntities <= 0 )
416                 ParseEntities();
417         
418         /* note that this is abstracted */
419         Sys_Printf( "Abstracted BSP file components (*actual sizes may differ)\n" );
420         
421         /* print various and sundry bits */
422         Sys_Printf( "%9d models        %9d\n",
423                 numBSPModels, (int) (numBSPModels * sizeof( bspModel_t )) );
424         Sys_Printf( "%9d shaders       %9d\n",
425                 numBSPShaders, (int) (numBSPShaders * sizeof( bspShader_t )) );
426         Sys_Printf( "%9d brushes       %9d\n",
427                 numBSPBrushes, (int) (numBSPBrushes * sizeof( bspBrush_t )) );
428         Sys_Printf( "%9d brushsides    %9d *\n",
429                 numBSPBrushSides, (int) (numBSPBrushSides * sizeof( bspBrushSide_t )) );
430         Sys_Printf( "%9d fogs          %9d\n",
431                 numBSPFogs, (int) (numBSPFogs * sizeof( bspFog_t ) ) );
432         Sys_Printf( "%9d planes        %9d\n",
433                 numBSPPlanes, (int) (numBSPPlanes * sizeof( bspPlane_t )) );
434         Sys_Printf( "%9d entdata       %9d\n",
435                 numEntities, bspEntDataSize );
436         Sys_Printf( "\n");
437         
438         Sys_Printf( "%9d nodes         %9d\n",
439                 numBSPNodes, (int) (numBSPNodes * sizeof( bspNode_t)) );
440         Sys_Printf( "%9d leafs         %9d\n",
441                 numBSPLeafs, (int) (numBSPLeafs * sizeof( bspLeaf_t )) );
442         Sys_Printf( "%9d leafsurfaces  %9d\n",
443                 numBSPLeafSurfaces, (int) (numBSPLeafSurfaces * sizeof( *bspLeafSurfaces )) );
444         Sys_Printf( "%9d leafbrushes   %9d\n",
445                 numBSPLeafBrushes, (int) (numBSPLeafBrushes * sizeof( *bspLeafBrushes )) );
446         Sys_Printf( "\n");
447         
448         Sys_Printf( "%9d drawsurfaces  %9d *\n",
449                 numBSPDrawSurfaces, (int) (numBSPDrawSurfaces * sizeof( *bspDrawSurfaces )) );
450         Sys_Printf( "%9d drawverts     %9d *\n",
451                 numBSPDrawVerts, (int) (numBSPDrawVerts * sizeof( *bspDrawVerts )) );
452         Sys_Printf( "%9d drawindexes   %9d\n",
453                 numBSPDrawIndexes, (int) (numBSPDrawIndexes * sizeof( *bspDrawIndexes )) );
454         Sys_Printf( "\n");
455         
456         Sys_Printf( "%9d lightmaps     %9d\n",
457                 numBSPLightBytes / (game->lightmapSize * game->lightmapSize * 3), numBSPLightBytes );
458         Sys_Printf( "%9d lightgrid     %9d *\n",
459                 numBSPGridPoints, (int) (numBSPGridPoints * sizeof( *bspGridPoints )) );
460         Sys_Printf( "          visibility    %9d\n",
461                 numBSPVisBytes );
462 }
463
464
465
466 /* -------------------------------------------------------------------------------
467
468 entity data handling
469
470 ------------------------------------------------------------------------------- */
471
472
473 /*
474 StripTrailing()
475 strips low byte chars off the end of a string
476 */
477
478 void StripTrailing( char *e )
479 {
480         char    *s;
481         
482         
483         s = e + strlen( e ) - 1;
484         while( s >= e && *s <= 32 )
485         {
486                 *s = 0;
487                 s--;
488         }
489 }
490
491
492
493 /*
494 ParseEpair()
495 parses a single quoted "key" "value" pair into an epair struct
496 */
497
498 epair_t *ParseEPair( void )
499 {
500         epair_t         *e;
501         
502         
503         /* allocate and clear new epair */
504         e = safe_malloc( sizeof( epair_t ) );
505         memset( e, 0, sizeof( epair_t ) );
506         
507         /* handle key */
508         if( strlen( token ) >= (MAX_KEY - 1) )
509                 Error( "ParseEPair: token too long" );
510         
511         e->key = copystring( token );
512         GetToken( qfalse );
513         
514         /* handle value */
515         if( strlen( token ) >= MAX_VALUE - 1 )
516                 Error( "ParseEpar: token too long" );
517         e->value = copystring( token );
518         
519         /* strip trailing spaces that sometimes get accidentally added in the editor */
520         StripTrailing( e->key );
521         StripTrailing( e->value );
522         
523         /* return it */
524         return e;
525 }
526
527
528
529 /*
530 ParseEntity()
531 parses an entity's epairs
532 */
533
534 qboolean ParseEntity( void )
535 {
536         epair_t         *e;
537         
538         
539         /* dummy check */
540         if( !GetToken( qtrue ) )
541                 return qfalse;
542         if( strcmp( token, "{" ) )
543                 Error( "ParseEntity: { not found" );
544         if( numEntities == MAX_MAP_ENTITIES )
545                 Error( "numEntities == MAX_MAP_ENTITIES" );
546         
547         /* create new entity */
548         mapEnt = &entities[ numEntities ];
549         numEntities++;
550         
551         /* parse */
552         while( 1 )
553         {
554                 if( !GetToken( qtrue ) )
555                         Error( "ParseEntity: EOF without closing brace" );
556                 if( !EPAIR_STRCMP( token, "}" ) )
557                         break;
558                 e = ParseEPair();
559                 e->next = mapEnt->epairs;
560                 mapEnt->epairs = e;
561         }
562         
563         /* return to sender */
564         return qtrue;
565 }
566
567
568
569 /*
570 ParseEntities()
571 parses the bsp entity data string into entities
572 */
573
574 void ParseEntities( void )
575 {
576         numEntities = 0;
577         ParseFromMemory( bspEntData, bspEntDataSize );
578         while( ParseEntity() );
579         
580         /* ydnar: set number of bsp entities in case a map is loaded on top */
581         numBSPEntities = numEntities;
582 }
583
584
585
586 /*
587 UnparseEntities()
588 generates the dentdata string from all the entities.
589 this allows the utilities to add or remove key/value
590 pairs to the data created by the map editor
591 */
592
593 void UnparseEntities( void )
594 {
595         int                     i;
596         char            *buf, *end;
597         epair_t         *ep;
598         char            line[ 2048 ];
599         char            key[ 1024 ], value[ 1024 ];
600         const char      *value2;
601         
602         
603         /* setup */
604         buf = bspEntData;
605         end = buf;
606         *end = 0;
607         
608         /* run through entity list */
609         for( i = 0; i < numBSPEntities && i < numEntities; i++ )
610         {
611                 /* get epair */
612                 ep = entities[ i ].epairs;
613                 if( ep == NULL )
614                         continue;       /* ent got removed */
615                 
616                 /* ydnar: certain entities get stripped from bsp file */
617                 value2 = ValueForKey( &entities[ i ], "classname" );
618                 if( !Q_stricmp( value2, "misc_model" ) ||
619                         !Q_stricmp( value2, "_decal" ) ||
620                         !Q_stricmp( value2, "_skybox" ) )
621                         continue;
622                 
623                 /* add beginning brace */
624                 strcat( end, "{\n" );
625                 end += 2;
626                 
627                 /* walk epair list */
628                 for( ep = entities[ i ].epairs; ep != NULL; ep = ep->next )
629                 {
630                         /* copy and clean */
631                         strcpy( key, ep->key );
632                         StripTrailing( key );
633                         strcpy( value, ep->value );
634                         StripTrailing( value );
635                         
636                         /* add to buffer */
637                         sprintf( line, "\"%s\" \"%s\"\n", key, value );
638                         strcat( end, line );
639                         end += strlen( line );
640                 }
641                 
642                 /* add trailing brace */
643                 strcat( end,"}\n" );
644                 end += 2;
645                 
646                 /* check for overflow */
647                 if( end > buf + MAX_MAP_ENTSTRING )
648                         Error( "Entity text too long" );
649         }
650         
651         /* set size */
652         bspEntDataSize = end - buf + 1;
653 }
654
655
656
657 /*
658 PrintEntity()
659 prints an entity's epairs to the console
660 */
661
662 void PrintEntity( const entity_t *ent )
663 {
664         epair_t *ep;
665         
666
667         Sys_Printf( "------- entity %p -------\n", ent );
668         for( ep = ent->epairs; ep != NULL; ep = ep->next )
669                 Sys_Printf( "%s = %s\n", ep->key, ep->value );
670
671 }
672
673
674
675 /*
676 SetKeyValue()
677 sets an epair in an entity
678 */
679
680 void SetKeyValue( entity_t *ent, const char *key, const char *value )
681 {
682         epair_t *ep;
683         
684         
685         /* check for existing epair */
686         for( ep = ent->epairs; ep != NULL; ep = ep->next )
687         {
688                 if( !EPAIR_STRCMP( ep->key, key ) )
689                 {
690                         free( ep->value );
691                         ep->value = copystring( value );
692                         return;
693                 }
694         }
695         
696         /* create new epair */
697         ep = safe_malloc( sizeof( *ep ) );
698         ep->next = ent->epairs;
699         ent->epairs = ep;
700         ep->key = copystring( key );
701         ep->value = copystring( value );
702 }
703
704
705
706 /*
707 ValueForKey()
708 gets the value for an entity key
709 */
710
711 const char *ValueForKey( const entity_t *ent, const char *key )
712 {
713         epair_t *ep;
714         
715         
716         /* dummy check */
717         if( ent == NULL )
718                 return "";
719         
720         /* walk epair list */
721         for( ep = ent->epairs; ep != NULL; ep = ep->next )
722         {
723                 if( !EPAIR_STRCMP( ep->key, key ) )
724                         return ep->value;
725         }
726         
727         /* if no match, return empty string */
728         return "";
729 }
730
731
732
733 /*
734 IntForKey()
735 gets the integer point value for an entity key
736 */
737
738 int IntForKey( const entity_t *ent, const char *key )
739 {
740         const char      *k;
741         
742         
743         k = ValueForKey( ent, key );
744         return atoi( k );
745 }
746
747
748
749 /*
750 FloatForKey()
751 gets the floating point value for an entity key
752 */
753
754 vec_t FloatForKey( const entity_t *ent, const char *key )
755 {
756         const char      *k;
757         
758         
759         k = ValueForKey( ent, key );
760         return atof( k );
761 }
762
763
764
765 /*
766 GetVectorForKey()
767 gets a 3-element vector value for an entity key
768 */
769
770 void GetVectorForKey( const entity_t *ent, const char *key, vec3_t vec )
771 {
772         const char      *k;
773         double          v1, v2, v3;
774         
775
776         /* get value */
777         k = ValueForKey( ent, key );
778         
779         /* scanf into doubles, then assign, so it is vec_t size independent */
780         v1 = v2 = v3 = 0.0;
781         sscanf( k, "%lf %lf %lf", &v1, &v2, &v3 );
782         vec[ 0 ] = v1;
783         vec[ 1 ] = v2;
784         vec[ 2 ] = v3;
785 }
786
787
788
789 /*
790 FindTargetEntity()
791 finds an entity target
792 */
793
794 entity_t *FindTargetEntity( const char *target )
795 {
796         int                     i;
797         const char      *n;
798
799         
800         /* walk entity list */
801         for( i = 0; i < numEntities; i++ )
802         {
803                 n = ValueForKey( &entities[ i ], "targetname" );
804                 if ( !strcmp( n, target ) )
805                         return &entities[ i ];
806         }
807         
808         /* nada */
809         return NULL;
810 }
811
812
813
814 /*
815 GetEntityShadowFlags() - ydnar
816 gets an entity's shadow flags
817 note: does not set them to defaults if the keys are not found!
818 */
819
820 void GetEntityShadowFlags( const entity_t *ent, const entity_t *ent2, int *castShadows, int *recvShadows )
821 {
822         const char      *value;
823         
824         
825         /* get cast shadows */
826         if( castShadows != NULL )
827         {
828                 value = ValueForKey( ent, "_castShadows" );
829                 if( value[ 0 ] == '\0' )
830                         value = ValueForKey( ent, "_cs" );
831                 if( value[ 0 ] == '\0' )
832                         value = ValueForKey( ent2, "_castShadows" );
833                 if( value[ 0 ] == '\0' )
834                         value = ValueForKey( ent2, "_cs" );
835                 if( value[ 0 ] != '\0' )
836                         *castShadows = atoi( value );
837         }
838         
839         /* receive */
840         if( recvShadows != NULL )
841         {
842                 value = ValueForKey( ent, "_receiveShadows" );
843                 if( value[ 0 ] == '\0' )
844                         value = ValueForKey( ent, "_rs" );
845                 if( value[ 0 ] == '\0' )
846                         value = ValueForKey( ent2, "_receiveShadows" );
847                 if( value[ 0 ] == '\0' )
848                         value = ValueForKey( ent2, "_rs" );
849                 if( value[ 0 ] != '\0' )
850                         *recvShadows = atoi( value );
851         }
852 }
853