Merge commit '515673c08f8718a237e90c2130a1f5294f966d6a'
[xonotic/netradiant.git] / tools / quake2 / 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 #include "cmdlib.h"
23 #include "mathlib.h"
24 #include "bspfile.h"
25 #include "scriplib.h"
26 #include "inout.h"
27
28 void GetLeafNums (void);
29
30 //=============================================================================
31
32 int                     nummodels;
33 dmodel_t        dmodels[MAX_MAP_MODELS];
34
35 int                     visdatasize;
36 byte            dvisdata[MAX_MAP_VISIBILITY];
37 dvis_t          *dvis = (dvis_t *)dvisdata;
38
39 int                     lightdatasize;
40 byte            dlightdata[MAX_MAP_LIGHTING];
41
42 int                     entdatasize;
43 char            dentdata[MAX_MAP_ENTSTRING];
44
45 int                     numleafs;
46 dleaf_t         dleafs[MAX_MAP_LEAFS];
47
48 int                     numplanes;
49 dplane_t        dplanes[MAX_MAP_PLANES];
50
51 int                     numvertexes;
52 dvertex_t       dvertexes[MAX_MAP_VERTS];
53
54 int                     numnodes;
55 dnode_t         dnodes[MAX_MAP_NODES];
56
57 int                     numtexinfo;
58 texinfo_t       texinfo[MAX_MAP_TEXINFO];
59
60 int                     numfaces;
61 dface_t         dfaces[MAX_MAP_FACES];
62
63 int                     numedges;
64 dedge_t         dedges[MAX_MAP_EDGES];
65
66 int                     numleaffaces;
67 unsigned short          dleaffaces[MAX_MAP_LEAFFACES];
68
69 int                     numleafbrushes;
70 unsigned short          dleafbrushes[MAX_MAP_LEAFBRUSHES];
71
72 int                     numsurfedges;
73 int                     dsurfedges[MAX_MAP_SURFEDGES];
74
75 int                     numbrushes;
76 dbrush_t        dbrushes[MAX_MAP_BRUSHES];
77
78 int                     numbrushsides;
79 dbrushside_t    dbrushsides[MAX_MAP_BRUSHSIDES];
80
81 int                     numareas;
82 darea_t         dareas[MAX_MAP_AREAS];
83
84 int                     numareaportals;
85 dareaportal_t   dareaportals[MAX_MAP_AREAPORTALS];
86
87 byte            dpop[256];
88
89 /*
90 ===============
91 CompressVis
92
93 ===============
94 */
95 int CompressVis (byte *vis, byte *dest)
96 {
97         int             j;
98         int             rep;
99         int             visrow;
100         byte    *dest_p;
101         
102         dest_p = dest;
103 //      visrow = (r_numvisleafs + 7)>>3;
104         visrow = (dvis->numclusters + 7)>>3;
105         
106         for (j=0 ; j<visrow ; j++)
107         {
108                 *dest_p++ = vis[j];
109                 if (vis[j])
110                         continue;
111
112                 rep = 1;
113                 for ( j++; j<visrow ; j++)
114                         if (vis[j] || rep == 255)
115                                 break;
116                         else
117                                 rep++;
118                 *dest_p++ = rep;
119                 j--;
120         }
121         
122         return dest_p - dest;
123 }
124
125
126 /*
127 ===================
128 DecompressVis
129 ===================
130 */
131 void DecompressVis (byte *in, byte *decompressed)
132 {
133         int             c;
134         byte    *out;
135         int             row;
136
137 //      row = (r_numvisleafs+7)>>3;     
138         row = (dvis->numclusters+7)>>3; 
139         out = decompressed;
140
141         do
142         {
143                 if (*in)
144                 {
145                         *out++ = *in++;
146                         continue;
147                 }
148         
149                 c = in[1];
150                 if (!c)
151                         Error ("DecompressVis: 0 repeat");
152                 in += 2;
153                 while (c)
154                 {
155                         *out++ = 0;
156                         c--;
157                 }
158         } while (out - decompressed < row);
159 }
160
161 //=============================================================================
162
163 /*
164 =============
165 SwapBSPFile
166
167 Byte swaps all data in a bsp file.
168 =============
169 */
170 void SwapBSPFile (qboolean todisk)
171 {
172         int                             i, j;
173         dmodel_t                *d;
174
175         
176 // models       
177         for (i=0 ; i<nummodels ; i++)
178         {
179                 d = &dmodels[i];
180
181                 d->firstface = LittleLong (d->firstface);
182                 d->numfaces = LittleLong (d->numfaces);
183                 d->headnode = LittleLong (d->headnode);
184                 
185                 for (j=0 ; j<3 ; j++)
186                 {
187                         d->mins[j] = LittleFloat(d->mins[j]);
188                         d->maxs[j] = LittleFloat(d->maxs[j]);
189                         d->origin[j] = LittleFloat(d->origin[j]);
190                 }
191         }
192
193 //
194 // vertexes
195 //
196         for (i=0 ; i<numvertexes ; i++)
197         {
198                 for (j=0 ; j<3 ; j++)
199                         dvertexes[i].point[j] = LittleFloat (dvertexes[i].point[j]);
200         }
201                 
202 //
203 // planes
204 //      
205         for (i=0 ; i<numplanes ; i++)
206         {
207                 for (j=0 ; j<3 ; j++)
208                         dplanes[i].normal[j] = LittleFloat (dplanes[i].normal[j]);
209                 dplanes[i].dist = LittleFloat (dplanes[i].dist);
210                 dplanes[i].type = LittleLong (dplanes[i].type);
211         }
212         
213 //
214 // texinfos
215 //      
216         for (i=0 ; i<numtexinfo ; i++)
217         {
218                 for (j=0 ; j<8 ; j++)
219                         texinfo[i].vecs[0][j] = LittleFloat (texinfo[i].vecs[0][j]);
220                 texinfo[i].flags = LittleLong (texinfo[i].flags);
221                 texinfo[i].value = LittleLong (texinfo[i].value);
222                 texinfo[i].nexttexinfo = LittleLong (texinfo[i].nexttexinfo);
223         }
224         
225 //
226 // faces
227 //
228         for (i=0 ; i<numfaces ; i++)
229         {
230                 dfaces[i].texinfo = LittleShort (dfaces[i].texinfo);
231                 dfaces[i].planenum = LittleShort (dfaces[i].planenum);
232                 dfaces[i].side = LittleShort (dfaces[i].side);
233                 dfaces[i].lightofs = LittleLong (dfaces[i].lightofs);
234                 dfaces[i].firstedge = LittleLong (dfaces[i].firstedge);
235                 dfaces[i].numedges = LittleShort (dfaces[i].numedges);
236         }
237
238 //
239 // nodes
240 //
241         for (i=0 ; i<numnodes ; i++)
242         {
243                 dnodes[i].planenum = LittleLong (dnodes[i].planenum);
244                 for (j=0 ; j<3 ; j++)
245                 {
246                         dnodes[i].mins[j] = LittleShort (dnodes[i].mins[j]);
247                         dnodes[i].maxs[j] = LittleShort (dnodes[i].maxs[j]);
248                 }
249                 dnodes[i].children[0] = LittleLong (dnodes[i].children[0]);
250                 dnodes[i].children[1] = LittleLong (dnodes[i].children[1]);
251                 dnodes[i].firstface = LittleShort (dnodes[i].firstface);
252                 dnodes[i].numfaces = LittleShort (dnodes[i].numfaces);
253         }
254
255 //
256 // leafs
257 //
258         for (i=0 ; i<numleafs ; i++)
259         {
260                 dleafs[i].contents = LittleLong (dleafs[i].contents);
261                 dleafs[i].cluster = LittleShort (dleafs[i].cluster);
262                 dleafs[i].area = LittleShort (dleafs[i].area);
263                 for (j=0 ; j<3 ; j++)
264                 {
265                         dleafs[i].mins[j] = LittleShort (dleafs[i].mins[j]);
266                         dleafs[i].maxs[j] = LittleShort (dleafs[i].maxs[j]);
267                 }
268
269                 dleafs[i].firstleafface = LittleShort (dleafs[i].firstleafface);
270                 dleafs[i].numleaffaces = LittleShort (dleafs[i].numleaffaces);
271                 dleafs[i].firstleafbrush = LittleShort (dleafs[i].firstleafbrush);
272                 dleafs[i].numleafbrushes = LittleShort (dleafs[i].numleafbrushes);
273         }
274
275 //
276 // leaffaces
277 //
278         for (i=0 ; i<numleaffaces ; i++)
279                 dleaffaces[i] = LittleShort (dleaffaces[i]);
280
281 //
282 // leafbrushes
283 //
284         for (i=0 ; i<numleafbrushes ; i++)
285                 dleafbrushes[i] = LittleShort (dleafbrushes[i]);
286
287 //
288 // surfedges
289 //
290         for (i=0 ; i<numsurfedges ; i++)
291                 dsurfedges[i] = LittleLong (dsurfedges[i]);
292
293 //
294 // edges
295 //
296         for (i=0 ; i<numedges ; i++)
297         {
298                 dedges[i].v[0] = LittleShort (dedges[i].v[0]);
299                 dedges[i].v[1] = LittleShort (dedges[i].v[1]);
300         }
301
302 //
303 // brushes
304 //
305         for (i=0 ; i<numbrushes ; i++)
306         {
307                 dbrushes[i].firstside = LittleLong (dbrushes[i].firstside);
308                 dbrushes[i].numsides = LittleLong (dbrushes[i].numsides);
309                 dbrushes[i].contents = LittleLong (dbrushes[i].contents);
310         }
311
312 //
313 // areas
314 //
315         for (i=0 ; i<numareas ; i++)
316         {
317                 dareas[i].numareaportals = LittleLong (dareas[i].numareaportals);
318                 dareas[i].firstareaportal = LittleLong (dareas[i].firstareaportal);
319         }
320
321 //
322 // areasportals
323 //
324         for (i=0 ; i<numareaportals ; i++)
325         {
326                 dareaportals[i].portalnum = LittleLong (dareaportals[i].portalnum);
327                 dareaportals[i].otherarea = LittleLong (dareaportals[i].otherarea);
328         }
329
330 //
331 // brushsides
332 //
333         for (i=0 ; i<numbrushsides ; i++)
334         {
335                 dbrushsides[i].planenum = LittleShort (dbrushsides[i].planenum);
336                 dbrushsides[i].texinfo = LittleShort (dbrushsides[i].texinfo);
337         }
338
339 //
340 // visibility
341 //
342         if (todisk)
343                 j = dvis->numclusters;
344         else
345                 j = LittleLong(dvis->numclusters);
346         dvis->numclusters = LittleLong (dvis->numclusters);
347         for (i=0 ; i<j ; i++)
348         {
349                 dvis->bitofs[i][0] = LittleLong (dvis->bitofs[i][0]);
350                 dvis->bitofs[i][1] = LittleLong (dvis->bitofs[i][1]);
351         }
352 }
353
354
355 dheader_t       *header;
356
357 int CopyLump (int lump, void *dest, int size)
358 {
359         int             length, ofs;
360
361         length = header->lumps[lump].filelen;
362         ofs = header->lumps[lump].fileofs;
363         
364         if (length % size)
365                 Error ("LoadBSPFile: odd lump size");
366         
367         memcpy (dest, (byte *)header + ofs, length);
368
369         return length / size;
370 }
371
372 /*
373 =============
374 LoadBSPFile
375 =============
376 */
377 void    LoadBSPFile (char *filename)
378 {
379         int                     i;
380         
381 //
382 // load the file header
383 //
384         LoadFile (filename, (void **)&header);
385
386 // swap the header
387         for (i=0 ; i< sizeof(dheader_t)/4 ; i++)
388                 ((int *)header)[i] = LittleLong ( ((int *)header)[i]);
389
390         if (header->ident != IDBSPHEADER)
391                 Error ("%s is not a IBSP file", filename);
392         if (header->version != BSPVERSION)
393                 Error ("%s is version %i, not %i", filename, header->version, BSPVERSION);
394
395         nummodels = CopyLump (LUMP_MODELS, dmodels, sizeof(dmodel_t));
396         numvertexes = CopyLump (LUMP_VERTEXES, dvertexes, sizeof(dvertex_t));
397         numplanes = CopyLump (LUMP_PLANES, dplanes, sizeof(dplane_t));
398         numleafs = CopyLump (LUMP_LEAFS, dleafs, sizeof(dleaf_t));
399         numnodes = CopyLump (LUMP_NODES, dnodes, sizeof(dnode_t));
400         numtexinfo = CopyLump (LUMP_TEXINFO, texinfo, sizeof(texinfo_t));
401         numfaces = CopyLump (LUMP_FACES, dfaces, sizeof(dface_t));
402         numleaffaces = CopyLump (LUMP_LEAFFACES, dleaffaces, sizeof(dleaffaces[0]));
403         numleafbrushes = CopyLump (LUMP_LEAFBRUSHES, dleafbrushes, sizeof(dleafbrushes[0]));
404         numsurfedges = CopyLump (LUMP_SURFEDGES, dsurfedges, sizeof(dsurfedges[0]));
405         numedges = CopyLump (LUMP_EDGES, dedges, sizeof(dedge_t));
406         numbrushes = CopyLump (LUMP_BRUSHES, dbrushes, sizeof(dbrush_t));
407         numbrushsides = CopyLump (LUMP_BRUSHSIDES, dbrushsides, sizeof(dbrushside_t));
408         numareas = CopyLump (LUMP_AREAS, dareas, sizeof(darea_t));
409         numareaportals = CopyLump (LUMP_AREAPORTALS, dareaportals, sizeof(dareaportal_t));
410
411         visdatasize = CopyLump (LUMP_VISIBILITY, dvisdata, 1);
412         lightdatasize = CopyLump (LUMP_LIGHTING, dlightdata, 1);
413         entdatasize = CopyLump (LUMP_ENTITIES, dentdata, 1);
414
415         CopyLump (LUMP_POP, dpop, 1);
416
417         free (header);          // everything has been copied out
418                 
419 //
420 // swap everything
421 //      
422         SwapBSPFile (false);
423 }
424
425
426 /*
427 =============
428 LoadBSPFileTexinfo
429
430 Only loads the texinfo lump, so qdata can scan for textures
431 =============
432 */
433 void    LoadBSPFileTexinfo (char *filename)
434 {
435         int                     i;
436         FILE            *f;
437         int             length, ofs;
438
439         header = malloc(sizeof(dheader_t));
440
441         f = fopen (filename, "rb");
442         fread (header, sizeof(dheader_t), 1, f);
443
444 // swap the header
445         for (i=0 ; i< sizeof(dheader_t)/4 ; i++)
446                 ((int *)header)[i] = LittleLong ( ((int *)header)[i]);
447
448         if (header->ident != IDBSPHEADER)
449                 Error ("%s is not a IBSP file", filename);
450         if (header->version != BSPVERSION)
451                 Error ("%s is version %i, not %i", filename, header->version, BSPVERSION);
452
453
454         length = header->lumps[LUMP_TEXINFO].filelen;
455         ofs = header->lumps[LUMP_TEXINFO].fileofs;
456
457         fseek (f, ofs, SEEK_SET);
458         fread (texinfo, length, 1, f);
459         fclose (f);
460
461         numtexinfo = length / sizeof(texinfo_t);
462
463         free (header);          // everything has been copied out
464                 
465         SwapBSPFile (false);
466 }
467
468
469 //============================================================================
470
471 FILE            *wadfile;
472 dheader_t       outheader;
473
474 void AddLump (int lumpnum, void *data, int len)
475 {
476         lump_t *lump;
477
478         lump = &header->lumps[lumpnum];
479         
480         lump->fileofs = LittleLong( ftell(wadfile) );
481         lump->filelen = LittleLong(len);
482         SafeWrite (wadfile, data, (len+3)&~3);
483 }
484
485 /*
486 =============
487 WriteBSPFile
488
489 Swaps the bsp file in place, so it should not be referenced again
490 =============
491 */
492 void    WriteBSPFile (char *filename)
493 {               
494         header = &outheader;
495         memset (header, 0, sizeof(dheader_t));
496         
497         SwapBSPFile (true);
498
499         header->ident = LittleLong (IDBSPHEADER);
500         header->version = LittleLong (BSPVERSION);
501         
502         wadfile = SafeOpenWrite (filename);
503         SafeWrite (wadfile, header, sizeof(dheader_t)); // overwritten later
504
505         AddLump (LUMP_PLANES, dplanes, numplanes*sizeof(dplane_t));
506         AddLump (LUMP_LEAFS, dleafs, numleafs*sizeof(dleaf_t));
507         AddLump (LUMP_VERTEXES, dvertexes, numvertexes*sizeof(dvertex_t));
508         AddLump (LUMP_NODES, dnodes, numnodes*sizeof(dnode_t));
509         AddLump (LUMP_TEXINFO, texinfo, numtexinfo*sizeof(texinfo_t));
510         AddLump (LUMP_FACES, dfaces, numfaces*sizeof(dface_t));
511         AddLump (LUMP_BRUSHES, dbrushes, numbrushes*sizeof(dbrush_t));
512         AddLump (LUMP_BRUSHSIDES, dbrushsides, numbrushsides*sizeof(dbrushside_t));
513         AddLump (LUMP_LEAFFACES, dleaffaces, numleaffaces*sizeof(dleaffaces[0]));
514         AddLump (LUMP_LEAFBRUSHES, dleafbrushes, numleafbrushes*sizeof(dleafbrushes[0]));
515         AddLump (LUMP_SURFEDGES, dsurfedges, numsurfedges*sizeof(dsurfedges[0]));
516         AddLump (LUMP_EDGES, dedges, numedges*sizeof(dedge_t));
517         AddLump (LUMP_MODELS, dmodels, nummodels*sizeof(dmodel_t));
518         AddLump (LUMP_AREAS, dareas, numareas*sizeof(darea_t));
519         AddLump (LUMP_AREAPORTALS, dareaportals, numareaportals*sizeof(dareaportal_t));
520
521         AddLump (LUMP_LIGHTING, dlightdata, lightdatasize);
522         AddLump (LUMP_VISIBILITY, dvisdata, visdatasize);
523         AddLump (LUMP_ENTITIES, dentdata, entdatasize);
524         AddLump (LUMP_POP, dpop, sizeof(dpop));
525         
526         fseek (wadfile, 0, SEEK_SET);
527         SafeWrite (wadfile, header, sizeof(dheader_t));
528         fclose (wadfile);       
529 }
530
531 //============================================================================
532
533 /*
534 =============
535 PrintBSPFileSizes
536
537 Dumps info about current file
538 =============
539 */
540 void PrintBSPFileSizes (void)
541 {
542         if (!num_entities)
543                 ParseEntities ();
544
545         printf ("%5i models       %7i\n"
546                 ,nummodels, (int)(nummodels*sizeof(dmodel_t)));
547         printf ("%5i brushes      %7i\n"
548                 ,numbrushes, (int)(numbrushes*sizeof(dbrush_t)));
549         printf ("%5i brushsides   %7i\n"
550                 ,numbrushsides, (int)(numbrushsides*sizeof(dbrushside_t)));
551         printf ("%5i planes       %7i\n"
552                 ,numplanes, (int)(numplanes*sizeof(dplane_t)));
553         printf ("%5i texinfo      %7i\n"
554                 ,numtexinfo, (int)(numtexinfo*sizeof(texinfo_t)));
555         printf ("%5i entdata      %7i\n", num_entities, entdatasize);
556
557         printf ("\n");
558
559         printf ("%5i vertexes     %7i\n"
560                 ,numvertexes, (int)(numvertexes*sizeof(dvertex_t)));
561         printf ("%5i nodes        %7i\n"
562                 ,numnodes, (int)(numnodes*sizeof(dnode_t)));
563         printf ("%5i faces        %7i\n"
564                 ,numfaces, (int)(numfaces*sizeof(dface_t)));
565         printf ("%5i leafs        %7i\n"
566                 ,numleafs, (int)(numleafs*sizeof(dleaf_t)));
567         printf ("%5i leaffaces    %7i\n"
568                 ,numleaffaces, (int)(numleaffaces*sizeof(dleaffaces[0])));
569         printf ("%5i leafbrushes  %7i\n"
570                 ,numleafbrushes, (int)(numleafbrushes*sizeof(dleafbrushes[0])));
571         printf ("%5i surfedges    %7i\n"
572                 ,numsurfedges, (int)(numsurfedges*sizeof(dsurfedges[0])));
573         printf ("%5i edges        %7i\n"
574                 ,numedges, (int)(numedges*sizeof(dedge_t)));
575         printf ("      lightdata    %7i\n", lightdatasize);
576         printf ("      visdata      %7i\n", visdatasize);
577 }
578
579
580 //============================================
581
582 int                     num_entities;
583 entity_t        entities[MAX_MAP_ENTITIES];
584
585 void StripTrailing (char *e)
586 {
587         char    *s;
588
589         s = e + strlen(e)-1;
590         while (s >= e && *s <= 32)
591         {
592                 *s = 0;
593                 s--;
594         }
595 }
596
597 /*
598 =================
599 ParseEpair
600 =================
601 */
602 epair_t *ParseEpair (void)
603 {
604         epair_t *e;
605
606         e = malloc (sizeof(epair_t));
607         memset (e, 0, sizeof(epair_t));
608         
609         if (strlen(token) >= MAX_KEY-1)
610                 Error ("ParseEpar: token too long");
611         e->key = copystring(token);
612         GetToken (false);
613         if (strlen(token) >= MAX_VALUE-1)
614                 Error ("ParseEpar: token too long");
615         e->value = copystring(token);
616
617         // strip trailing spaces
618         StripTrailing (e->key);
619         StripTrailing (e->value);
620
621         return e;
622 }
623
624
625 /*
626 ================
627 ParseEntity
628 ================
629 */
630 qboolean        ParseEntity (void)
631 {
632         epair_t         *e;
633         entity_t        *mapent;
634
635         if (!GetToken (true))
636                 return false;
637
638         if (strcmp (token, "{") )
639                 Error ("ParseEntity: { not found");
640         
641         if (num_entities == MAX_MAP_ENTITIES)
642                 Error ("num_entities == MAX_MAP_ENTITIES");
643
644         mapent = &entities[num_entities];
645         num_entities++;
646
647         do
648         {
649                 if (!GetToken (true))
650                         Error ("ParseEntity: EOF without closing brace");
651                 if (!strcmp (token, "}") )
652                         break;
653                 e = ParseEpair ();
654                 e->next = mapent->epairs;
655                 mapent->epairs = e;
656         } while (1);
657         
658         return true;
659 }
660
661 /*
662 ================
663 ParseEntities
664
665 Parses the dentdata string into entities
666 ================
667 */
668 void ParseEntities (void)
669 {
670         num_entities = 0;
671         ParseFromMemory (dentdata, entdatasize);
672
673         while (ParseEntity ())
674         {
675         }       
676 }
677
678
679 /*
680 ================
681 UnparseEntities
682
683 Generates the dentdata string from all the entities
684 ================
685 */
686 void UnparseEntities (void)
687 {
688         char    *buf, *end;
689         epair_t *ep;
690         char    line[2048];
691         int             i;
692         char    key[1024], value[1024];
693
694         buf = dentdata;
695         end = buf;
696         *end = 0;
697         
698         for (i=0 ; i<num_entities ; i++)
699         {
700                 ep = entities[i].epairs;
701                 if (!ep)
702                         continue;       // ent got removed
703                 
704                 strcat (end,"{\n");
705                 end += 2;
706                                 
707                 for (ep = entities[i].epairs ; ep ; ep=ep->next)
708                 {
709                         strcpy (key, ep->key);
710                         StripTrailing (key);
711                         strcpy (value, ep->value);
712                         StripTrailing (value);
713                                 
714                         sprintf (line, "\"%s\" \"%s\"\n", key, value);
715                         strcat (end, line);
716                         end += strlen(line);
717                 }
718                 strcat (end,"}\n");
719                 end += 2;
720
721                 if (end > buf + MAX_MAP_ENTSTRING)
722                         Error ("Entity text too long");
723         }
724         entdatasize = end - buf + 1;
725 }
726
727 void PrintEntity (entity_t *ent)
728 {
729         epair_t *ep;
730         
731         printf ("------- entity %p -------\n", ent);
732         for (ep=ent->epairs ; ep ; ep=ep->next)
733         {
734                 printf ("%s = %s\n", ep->key, ep->value);
735         }
736
737 }
738
739 void    SetKeyValue (entity_t *ent, char *key, char *value)
740 {
741         epair_t *ep;
742         
743         for (ep=ent->epairs ; ep ; ep=ep->next)
744                 if (!strcmp (ep->key, key) )
745                 {
746                         free (ep->value);
747                         ep->value = copystring(value);
748                         return;
749                 }
750         ep = malloc (sizeof(*ep));
751         ep->next = ent->epairs;
752         ent->epairs = ep;
753         ep->key = copystring(key);
754         ep->value = copystring(value);
755 }
756
757 char    *ValueForKey (entity_t *ent, char *key)
758 {
759         epair_t *ep;
760         
761         for (ep=ent->epairs ; ep ; ep=ep->next)
762                 if (!strcmp (ep->key, key) )
763                         return ep->value;
764         return "";
765 }
766
767 vec_t   FloatForKey (entity_t *ent, char *key)
768 {
769         char    *k;
770         
771         k = ValueForKey (ent, key);
772         return atof(k);
773 }
774
775 void    GetVectorForKey (entity_t *ent, char *key, vec3_t vec)
776 {
777         char    *k;
778         double  v1, v2, v3;
779
780         k = ValueForKey (ent, key);
781 // scanf into doubles, then assign, so it is vec_t size independent
782         v1 = v2 = v3 = 0;
783         sscanf (k, "%lf %lf %lf", &v1, &v2, &v3);
784         vec[0] = v1;
785         vec[1] = v2;
786         vec[2] = v3;
787 }
788
789