trivial patch: remove MAX_MAP_DRAW_VERTS limit completely (the code could already...
[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 = 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
333
334 /*
335 AddLump()
336 adds a lump to an outgoing bsp file
337 */
338
339 void AddLump( FILE *file, bspHeader_t *header, int lumpNum, const void *data, int length )
340 {
341         bspLump_t       *lump;
342         
343         
344         /* add lump to bsp file header */
345         lump = &header->lumps[ lumpNum ];
346         lump->offset = LittleLong( ftell( file ) );
347         lump->length = LittleLong( length );
348         
349         /* write lump to file */
350         SafeWrite( file, data, (length + 3) & ~3 );
351 }
352
353
354
355 /*
356 LoadBSPFile()
357 loads a bsp file into memory
358 */
359
360 void LoadBSPFile( const char *filename )
361 {
362         /* dummy check */
363         if( game == NULL || game->load == NULL )
364                 Error( "LoadBSPFile: unsupported BSP file format" );
365         
366         /* load it, then byte swap the in-memory version */
367         game->load( filename );
368         SwapBSPFile();
369 }
370
371
372
373 /*
374 WriteBSPFile()
375 writes a bsp file
376 */
377
378 void WriteBSPFile( const char *filename )
379 {
380         char    tempname[ 1024 ];
381         time_t  tm;
382         
383         
384         /* dummy check */
385         if( game == NULL || game->write == NULL )
386                 Error( "WriteBSPFile: unsupported BSP file format" );
387         
388         /* make fake temp name so existing bsp file isn't damaged in case write process fails */
389         time( &tm );
390         sprintf( tempname, "%s.%08X", filename, (int) tm );
391         
392         /* byteswap, write the bsp, then swap back so it can be manipulated further */
393         SwapBSPFile();
394         game->write( tempname );
395         SwapBSPFile();
396         
397         /* replace existing bsp file */
398         remove( filename );
399         rename( tempname, filename );
400 }
401
402
403
404 /*
405 PrintBSPFileSizes()
406 dumps info about current file
407 */
408
409 void PrintBSPFileSizes( void )
410 {
411         /* parse entities first */
412         if( numEntities <= 0 )
413                 ParseEntities();
414         
415         /* note that this is abstracted */
416         Sys_Printf( "Abstracted BSP file components (*actual sizes may differ)\n" );
417         
418         /* print various and sundry bits */
419         Sys_Printf( "%9d models        %9d\n",
420                 numBSPModels, (int) (numBSPModels * sizeof( bspModel_t )) );
421         Sys_Printf( "%9d shaders       %9d\n",
422                 numBSPShaders, (int) (numBSPShaders * sizeof( bspShader_t )) );
423         Sys_Printf( "%9d brushes       %9d\n",
424                 numBSPBrushes, (int) (numBSPBrushes * sizeof( bspBrush_t )) );
425         Sys_Printf( "%9d brushsides    %9d *\n",
426                 numBSPBrushSides, (int) (numBSPBrushSides * sizeof( bspBrushSide_t )) );
427         Sys_Printf( "%9d fogs          %9d\n",
428                 numBSPFogs, (int) (numBSPFogs * sizeof( bspFog_t ) ) );
429         Sys_Printf( "%9d planes        %9d\n",
430                 numBSPPlanes, (int) (numBSPPlanes * sizeof( bspPlane_t )) );
431         Sys_Printf( "%9d entdata       %9d\n",
432                 numEntities, bspEntDataSize );
433         Sys_Printf( "\n");
434         
435         Sys_Printf( "%9d nodes         %9d\n",
436                 numBSPNodes, (int) (numBSPNodes * sizeof( bspNode_t)) );
437         Sys_Printf( "%9d leafs         %9d\n",
438                 numBSPLeafs, (int) (numBSPLeafs * sizeof( bspLeaf_t )) );
439         Sys_Printf( "%9d leafsurfaces  %9d\n",
440                 numBSPLeafSurfaces, (int) (numBSPLeafSurfaces * sizeof( *bspLeafSurfaces )) );
441         Sys_Printf( "%9d leafbrushes   %9d\n",
442                 numBSPLeafBrushes, (int) (numBSPLeafBrushes * sizeof( *bspLeafBrushes )) );
443         Sys_Printf( "\n");
444         
445         Sys_Printf( "%9d drawsurfaces  %9d *\n",
446                 numBSPDrawSurfaces, (int) (numBSPDrawSurfaces * sizeof( *bspDrawSurfaces )) );
447         Sys_Printf( "%9d drawverts     %9d *\n",
448                 numBSPDrawVerts, (int) (numBSPDrawVerts * sizeof( *bspDrawVerts )) );
449         Sys_Printf( "%9d drawindexes   %9d\n",
450                 numBSPDrawIndexes, (int) (numBSPDrawIndexes * sizeof( *bspDrawIndexes )) );
451         Sys_Printf( "\n");
452         
453         Sys_Printf( "%9d lightmaps     %9d\n",
454                 numBSPLightBytes / (game->lightmapSize * game->lightmapSize * 3), numBSPLightBytes );
455         Sys_Printf( "%9d lightgrid     %9d *\n",
456                 numBSPGridPoints, (int) (numBSPGridPoints * sizeof( *bspGridPoints )) );
457         Sys_Printf( "          visibility    %9d\n",
458                 numBSPVisBytes );
459 }
460
461
462
463 /* -------------------------------------------------------------------------------
464
465 entity data handling
466
467 ------------------------------------------------------------------------------- */
468
469
470 /*
471 StripTrailing()
472 strips low byte chars off the end of a string
473 */
474
475 void StripTrailing( char *e )
476 {
477         char    *s;
478         
479         
480         s = e + strlen( e ) - 1;
481         while( s >= e && *s <= 32 )
482         {
483                 *s = 0;
484                 s--;
485         }
486 }
487
488
489
490 /*
491 ParseEpair()
492 parses a single quoted "key" "value" pair into an epair struct
493 */
494
495 epair_t *ParseEPair( void )
496 {
497         epair_t         *e;
498         
499         
500         /* allocate and clear new epair */
501         e = safe_malloc( sizeof( epair_t ) );
502         memset( e, 0, sizeof( epair_t ) );
503         
504         /* handle key */
505         if( strlen( token ) >= (MAX_KEY - 1) )
506                 Error( "ParseEPair: token too long" );
507         
508         e->key = copystring( token );
509         GetToken( qfalse );
510         
511         /* handle value */
512         if( strlen( token ) >= MAX_VALUE - 1 )
513                 Error( "ParseEpar: token too long" );
514         e->value = copystring( token );
515         
516         /* strip trailing spaces that sometimes get accidentally added in the editor */
517         StripTrailing( e->key );
518         StripTrailing( e->value );
519         
520         /* return it */
521         return e;
522 }
523
524
525
526 /*
527 ParseEntity()
528 parses an entity's epairs
529 */
530
531 qboolean ParseEntity( void )
532 {
533         epair_t         *e;
534         
535         
536         /* dummy check */
537         if( !GetToken( qtrue ) )
538                 return qfalse;
539         if( strcmp( token, "{" ) )
540                 Error( "ParseEntity: { not found" );
541         if( numEntities == MAX_MAP_ENTITIES )
542                 Error( "numEntities == MAX_MAP_ENTITIES" );
543         
544         /* create new entity */
545         mapEnt = &entities[ numEntities ];
546         numEntities++;
547         
548         /* parse */
549         while( 1 )
550         {
551                 if( !GetToken( qtrue ) )
552                         Error( "ParseEntity: EOF without closing brace" );
553                 if( !EPAIR_STRCMP( token, "}" ) )
554                         break;
555                 e = ParseEPair();
556                 e->next = mapEnt->epairs;
557                 mapEnt->epairs = e;
558         }
559         
560         /* return to sender */
561         return qtrue;
562 }
563
564
565
566 /*
567 ParseEntities()
568 parses the bsp entity data string into entities
569 */
570
571 void ParseEntities( void )
572 {
573         numEntities = 0;
574         ParseFromMemory( bspEntData, bspEntDataSize );
575         while( ParseEntity() );
576         
577         /* ydnar: set number of bsp entities in case a map is loaded on top */
578         numBSPEntities = numEntities;
579 }
580
581
582
583 /*
584 UnparseEntities()
585 generates the dentdata string from all the entities.
586 this allows the utilities to add or remove key/value
587 pairs to the data created by the map editor
588 */
589
590 void UnparseEntities( void )
591 {
592         int                     i;
593         char            *buf, *end;
594         epair_t         *ep;
595         char            line[ 2048 ];
596         char            key[ 1024 ], value[ 1024 ];
597         const char      *value2;
598         
599         
600         /* setup */
601         buf = bspEntData;
602         end = buf;
603         *end = 0;
604         
605         /* run through entity list */
606         for( i = 0; i < numBSPEntities && i < numEntities; i++ )
607         {
608                 /* get epair */
609                 ep = entities[ i ].epairs;
610                 if( ep == NULL )
611                         continue;       /* ent got removed */
612                 
613                 /* ydnar: certain entities get stripped from bsp file */
614                 value2 = ValueForKey( &entities[ i ], "classname" );
615                 if( !Q_stricmp( value2, "misc_model" ) ||
616                         !Q_stricmp( value2, "_decal" ) ||
617                         !Q_stricmp( value2, "_skybox" ) )
618                         continue;
619                 
620                 /* add beginning brace */
621                 strcat( end, "{\n" );
622                 end += 2;
623                 
624                 /* walk epair list */
625                 for( ep = entities[ i ].epairs; ep != NULL; ep = ep->next )
626                 {
627                         /* copy and clean */
628                         strcpy( key, ep->key );
629                         StripTrailing( key );
630                         strcpy( value, ep->value );
631                         StripTrailing( value );
632                         
633                         /* add to buffer */
634                         sprintf( line, "\"%s\" \"%s\"\n", key, value );
635                         strcat( end, line );
636                         end += strlen( line );
637                 }
638                 
639                 /* add trailing brace */
640                 strcat( end,"}\n" );
641                 end += 2;
642                 
643                 /* check for overflow */
644                 if( end > buf + MAX_MAP_ENTSTRING )
645                         Error( "Entity text too long" );
646         }
647         
648         /* set size */
649         bspEntDataSize = end - buf + 1;
650 }
651
652
653
654 /*
655 PrintEntity()
656 prints an entity's epairs to the console
657 */
658
659 void PrintEntity( const entity_t *ent )
660 {
661         epair_t *ep;
662         
663
664         Sys_Printf( "------- entity %p -------\n", ent );
665         for( ep = ent->epairs; ep != NULL; ep = ep->next )
666                 Sys_Printf( "%s = %s\n", ep->key, ep->value );
667
668 }
669
670
671
672 /*
673 SetKeyValue()
674 sets an epair in an entity
675 */
676
677 void SetKeyValue( entity_t *ent, const char *key, const char *value )
678 {
679         epair_t *ep;
680         
681         
682         /* check for existing epair */
683         for( ep = ent->epairs; ep != NULL; ep = ep->next )
684         {
685                 if( !EPAIR_STRCMP( ep->key, key ) )
686                 {
687                         free( ep->value );
688                         ep->value = copystring( value );
689                         return;
690                 }
691         }
692         
693         /* create new epair */
694         ep = safe_malloc( sizeof( *ep ) );
695         ep->next = ent->epairs;
696         ent->epairs = ep;
697         ep->key = copystring( key );
698         ep->value = copystring( value );
699 }
700
701
702
703 /*
704 ValueForKey()
705 gets the value for an entity key
706 */
707
708 const char *ValueForKey( const entity_t *ent, const char *key )
709 {
710         epair_t *ep;
711         
712         
713         /* dummy check */
714         if( ent == NULL )
715                 return "";
716         
717         /* walk epair list */
718         for( ep = ent->epairs; ep != NULL; ep = ep->next )
719         {
720                 if( !EPAIR_STRCMP( ep->key, key ) )
721                         return ep->value;
722         }
723         
724         /* if no match, return empty string */
725         return "";
726 }
727
728
729
730 /*
731 IntForKey()
732 gets the integer point value for an entity key
733 */
734
735 int IntForKey( const entity_t *ent, const char *key )
736 {
737         const char      *k;
738         
739         
740         k = ValueForKey( ent, key );
741         return atoi( k );
742 }
743
744
745
746 /*
747 FloatForKey()
748 gets the floating point value for an entity key
749 */
750
751 vec_t FloatForKey( const entity_t *ent, const char *key )
752 {
753         const char      *k;
754         
755         
756         k = ValueForKey( ent, key );
757         return atof( k );
758 }
759
760
761
762 /*
763 GetVectorForKey()
764 gets a 3-element vector value for an entity key
765 */
766
767 void GetVectorForKey( const entity_t *ent, const char *key, vec3_t vec )
768 {
769         const char      *k;
770         double          v1, v2, v3;
771         
772
773         /* get value */
774         k = ValueForKey( ent, key );
775         
776         /* scanf into doubles, then assign, so it is vec_t size independent */
777         v1 = v2 = v3 = 0.0;
778         sscanf( k, "%lf %lf %lf", &v1, &v2, &v3 );
779         vec[ 0 ] = v1;
780         vec[ 1 ] = v2;
781         vec[ 2 ] = v3;
782 }
783
784
785
786 /*
787 FindTargetEntity()
788 finds an entity target
789 */
790
791 entity_t *FindTargetEntity( const char *target )
792 {
793         int                     i;
794         const char      *n;
795
796         
797         /* walk entity list */
798         for( i = 0; i < numEntities; i++ )
799         {
800                 n = ValueForKey( &entities[ i ], "targetname" );
801                 if ( !strcmp( n, target ) )
802                         return &entities[ i ];
803         }
804         
805         /* nada */
806         return NULL;
807 }
808
809
810
811 /*
812 GetEntityShadowFlags() - ydnar
813 gets an entity's shadow flags
814 note: does not set them to defaults if the keys are not found!
815 */
816
817 void GetEntityShadowFlags( const entity_t *ent, const entity_t *ent2, int *castShadows, int *recvShadows )
818 {
819         const char      *value;
820         
821         
822         /* get cast shadows */
823         if( castShadows != NULL )
824         {
825                 value = ValueForKey( ent, "_castShadows" );
826                 if( value[ 0 ] == '\0' )
827                         value = ValueForKey( ent, "_cs" );
828                 if( value[ 0 ] == '\0' )
829                         value = ValueForKey( ent2, "_castShadows" );
830                 if( value[ 0 ] == '\0' )
831                         value = ValueForKey( ent2, "_cs" );
832                 if( value[ 0 ] != '\0' )
833                         *castShadows = atoi( value );
834         }
835         
836         /* receive */
837         if( recvShadows != NULL )
838         {
839                 value = ValueForKey( ent, "_receiveShadows" );
840                 if( value[ 0 ] == '\0' )
841                         value = ValueForKey( ent, "_rs" );
842                 if( value[ 0 ] == '\0' )
843                         value = ValueForKey( ent2, "_receiveShadows" );
844                 if( value[ 0 ] == '\0' )
845                         value = ValueForKey( ent2, "_rs" );
846                 if( value[ 0 ] != '\0' )
847                         *recvShadows = atoi( value );
848         }
849 }
850