d61f51be26e60237469ee828c37579ba0dc28bad
[divverent/netradiant.git] / tools / quake3 / q3map2 / map.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 MAP_C
33
34
35
36 /* dependencies */
37 #include "q3map2.h"
38
39
40
41 /* FIXME: remove these vars */
42
43 /* undefine to make plane finding use linear sort (note: really slow) */
44 #define USE_HASHING
45 #define PLANE_HASHES    8192
46
47 int                                             planehash[ PLANE_HASHES ];
48
49 int                                             c_boxbevels;
50 int                                             c_edgebevels;
51 int                                             c_areaportals;
52 int                                             c_detail;
53 int                                             c_structural;
54
55
56
57 /*
58 PlaneEqual()
59 ydnar: replaced with variable epsilon for djbob
60 */
61
62 #define NORMAL_EPSILON  0.00001
63 #define DIST_EPSILON    0.01
64
65 qboolean PlaneEqual( plane_t *p, vec3_t normal, vec_t dist )
66 {
67         float   ne, de;
68         
69         
70         /* get local copies */
71         ne = normalEpsilon;
72         de = distanceEpsilon;
73         
74         /* compare */
75         if( fabs( p->dist - dist ) <= de &&
76                 fabs( p->normal[ 0 ] - normal[ 0 ] ) <= ne &&
77                 fabs( p->normal[ 1 ] - normal[ 1 ] ) <= ne &&
78                 fabs( p->normal[ 2 ] - normal[ 2 ] ) <= ne )
79                 return qtrue;
80         
81         /* different */
82         return qfalse;
83 }
84
85
86
87 /*
88 AddPlaneToHash()
89 */
90
91 void AddPlaneToHash( plane_t *p )
92 {
93         int             hash;
94
95         
96         hash = (PLANE_HASHES - 1) & (int) fabs( p->dist );
97
98         p->hash_chain = planehash[hash];
99         planehash[hash] = p - mapplanes + 1;
100 }
101
102 /*
103 ================
104 CreateNewFloatPlane
105 ================
106 */
107 int CreateNewFloatPlane (vec3_t normal, vec_t dist)
108 {
109         plane_t *p, temp;
110
111         if (VectorLength(normal) < 0.5)
112         {
113                 Sys_Printf( "FloatPlane: bad normal\n");
114                 return -1;
115         }
116
117         // create a new plane
118         AUTOEXPAND_BY_REALLOC(mapplanes, nummapplanes+1, allocatedmapplanes, 1024);
119
120         p = &mapplanes[nummapplanes];
121         VectorCopy (normal, p->normal);
122         p->dist = dist;
123         p->type = (p+1)->type = PlaneTypeForNormal (p->normal);
124
125         VectorSubtract (vec3_origin, normal, (p+1)->normal);
126         (p+1)->dist = -dist;
127
128         nummapplanes += 2;
129
130         // allways put axial planes facing positive first
131         if (p->type < 3)
132         {
133                 if (p->normal[0] < 0 || p->normal[1] < 0 || p->normal[2] < 0)
134                 {
135                         // flip order
136                         temp = *p;
137                         *p = *(p+1);
138                         *(p+1) = temp;
139
140                         AddPlaneToHash (p);
141                         AddPlaneToHash (p+1);
142                         return nummapplanes - 1;
143                 }
144         }
145
146         AddPlaneToHash (p);
147         AddPlaneToHash (p+1);
148         return nummapplanes - 2;
149 }
150
151
152
153 /*
154 SnapNormal()
155 snaps a near-axial normal vector
156 */
157
158 void SnapNormal( vec3_t normal )
159 {
160         int             i;
161
162         for( i = 0; i < 3; i++ )
163         {
164                 if( fabs( normal[ i ] - 1 ) < normalEpsilon )
165                 {
166                         VectorClear( normal );
167                         normal[ i ] = 1;
168                         break;
169                 }
170                 if( fabs( normal[ i ] - -1 ) < normalEpsilon )
171                 {
172                         VectorClear( normal );
173                         normal[ i ] = -1;
174                         break;
175                 }
176         }
177 }
178
179
180
181 /*
182 SnapPlane()
183 snaps a plane to normal/distance epsilons
184 */
185
186 void SnapPlane( vec3_t normal, vec_t *dist, vec3_t center )
187 {
188 // SnapPlane disabled by LordHavoc because it often messes up collision
189 // brushes made from triangles of embedded models, and it has little effect
190 // on anything else (axial planes are usually derived from snapped points)
191 /*
192   SnapPlane reenabled by namespace because of multiple reports of
193   q3map2-crashes which were triggered by this patch.
194 */
195         // div0: ensure the point "center" stays on the plane (actually, this
196         // rotates the plane around the point center).
197         // if center lies on the plane, it is guaranteed to stay on the plane by
198         // this fix.
199         vec_t centerDist = DotProduct(normal, center);
200         SnapNormal( normal );
201         *dist += (DotProduct(normal, center) - centerDist);
202
203         if( fabs( *dist - Q_rint( *dist ) ) < distanceEpsilon )
204                 *dist = Q_rint( *dist );
205 }
206
207
208
209 /*
210 FindFloatPlane()
211 ydnar: changed to allow a number of test points to be supplied that
212 must be within an epsilon distance of the plane
213 */
214
215 int FindFloatPlane( vec3_t innormal, vec_t dist, int numPoints, vec3_t *points ) // NOTE: this has a side effect on the normal. Good or bad?
216
217 #ifdef USE_HASHING
218
219 {
220         int             i, j, hash, h;
221         int pidx;
222         plane_t *p;
223         vec_t   d;
224         vec3_t centerofweight;
225         vec3_t normal;
226
227         VectorClear(centerofweight);
228         for(i = 0; i < numPoints; ++i)
229                 VectorMA(centerofweight, 1.0 / numPoints, points[i], centerofweight);
230         
231         /* hash the plane */
232         VectorCopy(innormal, normal);
233         SnapPlane( normal, &dist, centerofweight );
234         hash = (PLANE_HASHES - 1) & (int) fabs( dist );
235         
236         /* search the border bins as well */
237         for( i = -1; i <= 1; i++ )
238         {
239                 h = (hash + i) & (PLANE_HASHES - 1);
240                 for( pidx = planehash[ h ] - 1; pidx != -1; pidx = mapplanes[pidx].hash_chain - 1 )
241                 {
242                         p = &mapplanes[pidx];
243
244                         /* do standard plane compare */
245                         if( !PlaneEqual( p, normal, dist ) )
246                                 continue;
247                         
248                         /* ydnar: uncomment the following line for old-style plane finding */
249                         //%     return p - mapplanes;
250                         
251                         /* ydnar: test supplied points against this plane */
252                         for( j = 0; j < numPoints; j++ )
253                         {
254                                 d = DotProduct( points[ j ], p->normal ) - p->dist;
255                                 if( fabs( d ) > distanceEpsilon )
256                                         break;
257                         }
258                         
259                         /* found a matching plane */
260                         if( j >= numPoints )
261                                 return p - mapplanes;
262                 }
263         }
264         
265         /* none found, so create a new one */
266         return CreateNewFloatPlane( normal, dist );
267 }
268
269 #else
270
271 {
272         int             i;
273         plane_t *p;
274         vec3_t normal;
275         
276
277         vec3_t centerofweight;
278
279         VectorClear(centerofweight);
280         for(i = 0; i < numPoints; ++i)
281                 VectorMA(centerofweight, 1.0 / numPoints, points[i], centerofweight);
282
283         VectorCopy(innormal, normal);
284         SnapPlane( normal, &dist, centerofweight );
285         for( i = 0, p = mapplanes; i < nummapplanes; i++, p++ )
286         {
287                 if( !PlaneEqual( p, normal, dist ) )
288                         continue;
289
290                 /* ydnar: uncomment the following line for old-style plane finding */
291                 //%     return i;
292                         
293                 /* ydnar: test supplied points against this plane */
294                 for( j = 0; j < numPoints; j++ )
295                 {
296                         d = DotProduct( points[ j ], p->normal ) - p->dist;
297                         if( fabs( d ) > distanceEpsilon )
298                                 break;
299                 }
300                 
301                 /* found a matching plane */
302                 if( j >= numPoints )
303                         return i;
304         }
305         
306         return CreateNewFloatPlane( normal, dist );
307 }
308
309 #endif
310
311
312
313 /*
314 MapPlaneFromPoints()
315 takes 3 points and finds the plane they lie in
316 */
317
318 int MapPlaneFromPoints( vec3_t *p )
319 {
320         vec3_t  t1, t2, normal;
321         vec_t   dist;
322         
323         
324         /* calc plane normal */
325         VectorSubtract( p[ 0 ], p[ 1 ], t1 );
326         VectorSubtract( p[ 2 ], p[ 1 ], t2 );
327         CrossProduct( t1, t2, normal );
328         VectorNormalize( normal, normal );
329         
330         /* calc plane distance */
331         dist = DotProduct( p[ 0 ], normal );
332         
333         /* store the plane */
334         return FindFloatPlane( normal, dist, 3, p );
335 }
336
337
338
339 /*
340 SetBrushContents()
341 the content flags and compile flags on all sides of a brush should be the same
342 */
343
344 void SetBrushContents( brush_t *b )
345 {
346         int                     contentFlags, compileFlags;
347         side_t          *s;
348         int                     i;
349         qboolean        mixed;
350         
351         
352         /* get initial compile flags from first side */
353         s = &b->sides[ 0 ];
354         contentFlags = s->contentFlags;
355         compileFlags = s->compileFlags;
356         b->contentShader = s->shaderInfo;
357         mixed = qfalse;
358         
359         /* get the content/compile flags for every side in the brush */
360         for( i = 1; i < b->numsides; i++, s++ )
361         {
362                 s = &b->sides[ i ];
363                 if( s->shaderInfo == NULL )
364                         continue;
365                 if( s->contentFlags != contentFlags || s->compileFlags != compileFlags )
366                         mixed = qtrue;
367
368                 contentFlags |= s->contentFlags;
369                 compileFlags |= s->compileFlags;
370         }
371         
372         /* ydnar: getting rid of this stupid warning */
373         //%     if( mixed )
374         //%             Sys_FPrintf( SYS_VRB,"Entity %i, Brush %i: mixed face contentFlags\n", b->entitynum, b->brushnum );
375
376         /* check for detail & structural */
377         if( (compileFlags & C_DETAIL) && (compileFlags & C_STRUCTURAL) )
378         {
379                 xml_Select( "Mixed detail and structural (defaulting to structural)", mapEnt->mapEntityNum, entitySourceBrushes, qfalse );
380                 compileFlags &= ~C_DETAIL;
381         }
382         
383         /* the fulldetail flag will cause detail brushes to be treated like normal brushes */
384         if( fulldetail )
385                 compileFlags &= ~C_DETAIL;
386         
387         /* all translucent brushes that aren't specifically made structural will be detail */
388         if( (compileFlags & C_TRANSLUCENT) && !(compileFlags & C_STRUCTURAL) )
389                 compileFlags |= C_DETAIL;
390         
391         /* detail? */
392         if( compileFlags & C_DETAIL )
393         {
394                 c_detail++;
395                 b->detail = qtrue;
396         }
397         else
398         {
399                 c_structural++;
400                 b->detail = qfalse;
401         }
402         
403         /* opaque? */
404         if( compileFlags & C_TRANSLUCENT )
405                 b->opaque = qfalse;
406         else
407                 b->opaque = qtrue;
408         
409         /* areaportal? */
410         if( compileFlags & C_AREAPORTAL )
411                 c_areaportals++;
412         
413         /* set brush flags */
414         b->contentFlags = contentFlags;
415         b->compileFlags = compileFlags;
416 }
417
418
419
420 /*
421 AddBrushBevels()
422 adds any additional planes necessary to allow the brush being
423 built to be expanded against axial bounding boxes
424 ydnar 2003-01-20: added mrelusive fixes
425 */
426
427 void AddBrushBevels( void )
428 {
429         int                     axis, dir;
430         int                     i, j, k, l, order;
431         side_t          sidetemp;
432         side_t          *s, *s2;
433         winding_t       *w, *w2;
434         vec3_t          normal;
435         float           dist;
436         vec3_t          vec, vec2;
437         float           d, minBack;
438
439         //
440         // add the axial planes
441         //
442         order = 0;
443         for ( axis = 0; axis < 3; axis++ ) {
444                 for ( dir = -1; dir <= 1; dir += 2, order++ ) {
445                         // see if the plane is allready present
446                         for ( i = 0, s = buildBrush->sides; i < buildBrush->numsides; i++, s++ )
447                         {
448                                 /* ydnar: testing disabling of mre code */
449                                 #if 0
450                                         if ( dir > 0 ) {
451                                                 if ( mapplanes[s->planenum].normal[axis] >= 0.9999f ) {
452                                                         break;
453                                                 }
454                                         }
455                                         else {
456                                                 if ( mapplanes[s->planenum].normal[axis] <= -0.9999f ) {
457                                                         break;
458                                                 }
459                                         }
460                                 #else
461                                         if( (dir > 0 && mapplanes[ s->planenum ].normal[ axis ] == 1.0f ) ||
462                                                 (dir < 0 && mapplanes[ s->planenum ].normal[ axis ] == -1.0f) )
463                                                 break;
464                                 #endif
465                         }
466
467                         if ( i == buildBrush->numsides ) {
468                                 // add a new side
469                                 if ( buildBrush->numsides == MAX_BUILD_SIDES ) {
470                                         xml_Select( "MAX_BUILD_SIDES", buildBrush->entityNum, buildBrush->brushNum, qtrue);
471                                 }
472                                 memset( s, 0, sizeof( *s ) );
473                                 buildBrush->numsides++;
474                                 VectorClear (normal);
475                                 normal[axis] = dir;
476
477                                 if( dir == 1 )
478                                 {
479                                         /* ydnar: adding bevel plane snapping for fewer bsp planes */
480                                         if( bevelSnap > 0 )
481                                                 dist = floor( buildBrush->maxs[ axis ] / bevelSnap ) * bevelSnap;
482                                         else
483                                                 dist = buildBrush->maxs[ axis ];
484                                 }
485                                 else
486                                 {
487                                         /* ydnar: adding bevel plane snapping for fewer bsp planes */
488                                         if( bevelSnap > 0 )
489                                                 dist = -ceil( buildBrush->mins[ axis ] / bevelSnap ) * bevelSnap;
490                                         else
491                                                 dist = -buildBrush->mins[ axis ];
492                                 }
493
494                                 s->planenum = FindFloatPlane( normal, dist, 0, NULL );
495                                 s->contentFlags = buildBrush->sides[ 0 ].contentFlags;
496                                 s->bevel = qtrue;
497                                 c_boxbevels++;
498                         }
499
500                         // if the plane is not in it canonical order, swap it
501                         if ( i != order ) {
502                                 sidetemp = buildBrush->sides[order];
503                                 buildBrush->sides[order] = buildBrush->sides[i];
504                                 buildBrush->sides[i] = sidetemp;
505                         }
506                 }
507         }
508
509         //
510         // add the edge bevels
511         //
512         if ( buildBrush->numsides == 6 ) {
513                 return;         // pure axial
514         }
515
516         // test the non-axial plane edges
517         for ( i = 6; i < buildBrush->numsides; i++ ) {
518                 s = buildBrush->sides + i;
519                 w = s->winding;
520                 if ( !w ) {
521                         continue;
522                 }
523                 for ( j = 0; j < w->numpoints; j++) {
524                         k = (j+1)%w->numpoints;
525                         VectorSubtract( w->p[j], w->p[k], vec );
526                         if ( VectorNormalize( vec, vec ) < 0.5f ) {
527                                 continue;
528                         }
529                         SnapNormal( vec );
530                         for ( k = 0; k < 3; k++ ) {
531                                 if ( vec[k] == -1.0f || vec[k] == 1.0f || (vec[k] == 0.0f && vec[(k+1)%3] == 0.0f) ) {
532                                         break;  // axial
533                                 }
534                         }
535                         if ( k != 3 ) {
536                                 continue;       // only test non-axial edges
537                         }
538
539                         /* debug code */
540                         //%     Sys_Printf( "-------------\n" );
541
542                         // try the six possible slanted axials from this edge
543                         for ( axis = 0; axis < 3; axis++ ) {
544                                 for ( dir = -1; dir <= 1; dir += 2 ) {
545                                         // construct a plane
546                                         VectorClear( vec2 );
547                                         vec2[axis] = dir;
548                                         CrossProduct( vec, vec2, normal );
549                                         if ( VectorNormalize( normal, normal ) < 0.5f ) {
550                                                 continue;
551                                         }
552                                         dist = DotProduct( w->p[j], normal );
553                                         
554                                         // if all the points on all the sides are
555                                         // behind this plane, it is a proper edge bevel
556                                         for ( k = 0; k < buildBrush->numsides; k++ ) {
557
558                                                 // if this plane has allready been used, skip it
559                                                 if ( PlaneEqual( &mapplanes[buildBrush->sides[k].planenum], normal, dist ) ) {
560                                                         break;
561                                                 }
562
563                                                 w2 = buildBrush->sides[k].winding;
564                                                 if ( !w2 ) {
565                                                         continue;
566                                                 }
567                                                 minBack = 0.0f;
568                                                 for ( l = 0; l < w2->numpoints; l++ ) {
569                                                         d = DotProduct( w2->p[l], normal ) - dist;
570                                                         if ( d > 0.1f ) {
571                                                                 break;  // point in front
572                                                         }
573                                                         if ( d < minBack ) {
574                                                                 minBack = d;
575                                                         }
576                                                 }
577                                                 // if some point was at the front
578                                                 if ( l != w2->numpoints ) {
579                                                         break;
580                                                 }
581
582                                                 // if no points at the back then the winding is on the bevel plane
583                                                 if ( minBack > -0.1f ) {
584                                                         //%     Sys_Printf( "On bevel plane\n" );
585                                                         break;
586                                                 }
587                                         }
588
589                                         if ( k != buildBrush->numsides ) {
590                                                 continue;       // wasn't part of the outer hull
591                                         }
592                                         
593                                         /* debug code */
594                                         //%     Sys_Printf( "n = %f %f %f\n", normal[ 0 ], normal[ 1 ], normal[ 2 ] );
595                                         
596                                         // add this plane
597                                         if( buildBrush->numsides == MAX_BUILD_SIDES ) {
598                                                 xml_Select( "MAX_BUILD_SIDES", buildBrush->entityNum, buildBrush->brushNum, qtrue);
599                                         }
600                                         s2 = &buildBrush->sides[buildBrush->numsides];
601                                         buildBrush->numsides++;
602                                         memset( s2, 0, sizeof( *s2 ) );
603
604                                         s2->planenum = FindFloatPlane( normal, dist, 1, &w->p[ j ] );
605                                         s2->contentFlags = buildBrush->sides[0].contentFlags;
606                                         s2->bevel = qtrue;
607                                         c_edgebevels++;
608                                 }
609                         }
610                 }
611         }
612 }
613
614
615
616 /*
617 FinishBrush()
618 produces a final brush based on the buildBrush->sides array
619 and links it to the current entity
620 */
621
622 static void MergeOrigin(entity_t *ent, vec3_t origin)
623 {
624         vec3_t adjustment;
625         char string[128];
626
627         /* we have not parsed the brush completely yet... */
628         GetVectorForKey( ent, "origin", ent->origin );
629
630         VectorMA(origin, -1, ent->originbrush_origin, adjustment);
631         VectorAdd(adjustment, ent->origin, ent->origin);
632         VectorCopy(origin, ent->originbrush_origin);
633
634         sprintf(string, "%f %f %f", ent->origin[0], ent->origin[1], ent->origin[2]);
635         SetKeyValue(ent, "origin", string);
636 }
637
638 brush_t *FinishBrush( qboolean noCollapseGroups )
639 {
640         brush_t         *b;
641         
642         
643         /* create windings for sides and bounds for brush */
644         if ( !CreateBrushWindings( buildBrush ) )
645                 return NULL;
646
647         /* origin brushes are removed, but they set the rotation origin for the rest of the brushes in the entity.
648            after the entire entity is parsed, the planenums and texinfos will be adjusted for the origin brush */
649         if( buildBrush->compileFlags & C_ORIGIN )
650         {
651                 vec3_t  origin;
652
653                 Sys_Printf( "Entity %i, Brush %i: origin brush detected\n", 
654                                 mapEnt->mapEntityNum, entitySourceBrushes );
655
656                 if( numEntities == 1 )
657                 {
658                         Sys_Printf( "Entity %i, Brush %i: origin brushes not allowed in world\n", 
659                                 mapEnt->mapEntityNum, entitySourceBrushes );
660                         return NULL;
661                 }
662                 
663                 VectorAdd (buildBrush->mins, buildBrush->maxs, origin);
664                 VectorScale (origin, 0.5, origin);
665
666                 MergeOrigin(&entities[ numEntities - 1 ], origin);
667
668                 /* don't keep this brush */
669                 return NULL;
670         }
671         
672         /* determine if the brush is an area portal */
673         if( buildBrush->compileFlags & C_AREAPORTAL )
674         {
675                 if( numEntities != 1 )
676                 {
677                         Sys_Printf ("Entity %i, Brush %i: areaportals only allowed in world\n", numEntities - 1, entitySourceBrushes );
678                         return NULL;
679                 }
680         }
681         
682         /* add bevel planes */
683         if(!noCollapseGroups)
684                 AddBrushBevels();
685         
686         /* keep it */
687         b = CopyBrush( buildBrush );
688         
689         /* set map entity and brush numbering */
690         b->entityNum = mapEnt->mapEntityNum;
691         b->brushNum = entitySourceBrushes;
692         
693         /* set original */
694         b->original = b;
695         
696         /* link opaque brushes to head of list, translucent brushes to end */
697         if( b->opaque || mapEnt->lastBrush == NULL )
698         {
699                 b->next = mapEnt->brushes;
700                 mapEnt->brushes = b;
701                 if( mapEnt->lastBrush == NULL )
702                         mapEnt->lastBrush = b;
703         }
704         else
705         {
706                 b->next = NULL;
707                 mapEnt->lastBrush->next = b;
708                 mapEnt->lastBrush = b;
709         }
710         
711         /* link colorMod volume brushes to the entity directly */
712         if( b->contentShader != NULL &&
713                 b->contentShader->colorMod != NULL &&
714                 b->contentShader->colorMod->type == CM_VOLUME )
715         {
716                 b->nextColorModBrush = mapEnt->colorModBrushes;
717                 mapEnt->colorModBrushes = b;
718         }
719         
720         /* return to sender */
721         return b;
722 }
723
724
725
726 /*
727 TextureAxisFromPlane()
728 determines best orthagonal axis to project a texture onto a wall
729 (must be identical in radiant!)
730 */
731
732 vec3_t  baseaxis[18] =
733 {
734         {0,0,1}, {1,0,0}, {0,-1,0},                     // floor
735         {0,0,-1}, {1,0,0}, {0,-1,0},            // ceiling
736         {1,0,0}, {0,1,0}, {0,0,-1},                     // west wall
737         {-1,0,0}, {0,1,0}, {0,0,-1},            // east wall
738         {0,1,0}, {1,0,0}, {0,0,-1},                     // south wall
739         {0,-1,0}, {1,0,0}, {0,0,-1}                     // north wall
740 };
741
742 void TextureAxisFromPlane( plane_t *pln, vec3_t xv, vec3_t yv )
743 {
744         int             bestaxis;
745         vec_t   dot,best;
746         int             i;
747         
748         best = 0;
749         bestaxis = 0;
750         
751         for (i=0 ; i<6 ; i++)
752         {
753                 dot = DotProduct (pln->normal, baseaxis[i*3]);
754                 if( dot > best + 0.0001f )      /* ydnar: bug 637 fix, suggested by jmonroe */
755                 {
756                         best = dot;
757                         bestaxis = i;
758                 }
759         }
760         
761         VectorCopy (baseaxis[bestaxis*3+1], xv);
762         VectorCopy (baseaxis[bestaxis*3+2], yv);
763 }
764
765
766
767 /*
768 QuakeTextureVecs()
769 creates world-to-texture mapping vecs for crappy quake plane arrangements
770 */
771
772 void QuakeTextureVecs( plane_t *plane, vec_t shift[ 2 ], vec_t rotate, vec_t scale[ 2 ], vec_t mappingVecs[ 2 ][ 4 ] )
773 {
774         vec3_t  vecs[2];
775         int             sv, tv;
776         vec_t   ang, sinv, cosv;
777         vec_t   ns, nt;
778         int             i, j;
779         
780         
781         TextureAxisFromPlane(plane, vecs[0], vecs[1]);
782         
783         if (!scale[0])
784                 scale[0] = 1;
785         if (!scale[1])
786                 scale[1] = 1;
787
788         // rotate axis
789         if (rotate == 0)
790                 { sinv = 0 ; cosv = 1; }
791         else if (rotate == 90)
792                 { sinv = 1 ; cosv = 0; }
793         else if (rotate == 180)
794                 { sinv = 0 ; cosv = -1; }
795         else if (rotate == 270)
796                 { sinv = -1 ; cosv = 0; }
797         else
798         {       
799                 ang = rotate / 180 * Q_PI;
800                 sinv = sin(ang);
801                 cosv = cos(ang);
802         }
803
804         if (vecs[0][0])
805                 sv = 0;
806         else if (vecs[0][1])
807                 sv = 1;
808         else
809                 sv = 2;
810                                 
811         if (vecs[1][0])
812                 tv = 0;
813         else if (vecs[1][1])
814                 tv = 1;
815         else
816                 tv = 2;
817                                         
818         for (i=0 ; i<2 ; i++) {
819                 ns = cosv * vecs[i][sv] - sinv * vecs[i][tv];
820                 nt = sinv * vecs[i][sv] +  cosv * vecs[i][tv];
821                 vecs[i][sv] = ns;
822                 vecs[i][tv] = nt;
823         }
824
825         for (i=0 ; i<2 ; i++)
826                 for (j=0 ; j<3 ; j++)
827                         mappingVecs[i][j] = vecs[i][j] / scale[i];
828
829         mappingVecs[0][3] = shift[0];
830         mappingVecs[1][3] = shift[1];
831 }
832
833
834
835 /*
836 ParseRawBrush()
837 parses the sides into buildBrush->sides[], nothing else.
838 no validation, back plane removal, etc.
839
840 Timo - 08/26/99
841 added brush epairs parsing ( ignoring actually )
842 Timo - 08/04/99
843 added exclusive brush primitive parsing
844 Timo - 08/08/99
845 support for old brush format back in
846 NOTE: it would be "cleaner" to have seperate functions to parse between old and new brushes
847 */
848
849 static void ParseRawBrush( qboolean onlyLights )
850 {
851         side_t                  *side;
852         vec3_t                  planePoints[ 3 ];
853         int                             planenum;
854         shaderInfo_t    *si;
855         vec_t                   shift[ 2 ];
856         vec_t                   rotate = 0;
857         vec_t                   scale[ 2 ];
858         char                    name[ MAX_QPATH ];
859         char                    shader[ MAX_QPATH ];
860         int                             flags;
861         
862         
863         /* initial setup */
864         buildBrush->numsides = 0;
865         buildBrush->detail = qfalse;
866         
867         /* bp */
868         if( g_bBrushPrimit == BPRIMIT_NEWBRUSHES )
869                 MatchToken( "{" );
870         
871         /* parse sides */
872         while( 1 )
873         {
874                 if( !GetToken( qtrue ) )
875                         break;
876                 if( !strcmp( token, "}" ) )
877                         break;
878                  
879                 /* ttimo : bp: here we may have to jump over brush epairs (only used in editor) */
880                 if( g_bBrushPrimit == BPRIMIT_NEWBRUSHES )
881                 {
882                         while( 1 )
883                         {
884                                 if( strcmp( token, "(" ) )
885                                         GetToken( qfalse );
886                                 else
887                                         break;
888                                 GetToken( qtrue );
889                         }
890                 }
891                 UnGetToken();
892                 
893                 /* test side count */
894                 if( buildBrush->numsides >= MAX_BUILD_SIDES )
895                         xml_Select( "MAX_BUILD_SIDES", buildBrush->entityNum, buildBrush->brushNum, qtrue );
896                 
897                 /* add side */
898                 side = &buildBrush->sides[ buildBrush->numsides ];
899                 memset( side, 0, sizeof( *side ) );
900                 buildBrush->numsides++;
901                 
902                 /* read the three point plane definition */
903                 Parse1DMatrix( 3, planePoints[ 0 ] );
904                 Parse1DMatrix( 3, planePoints[ 1 ] );
905                 Parse1DMatrix( 3, planePoints[ 2 ] );
906                 
907                 /* bp: read the texture matrix */
908                 if( g_bBrushPrimit == BPRIMIT_NEWBRUSHES )
909                         Parse2DMatrix( 2, 3, (float*) side->texMat );
910                 
911                 /* read shader name */
912                 GetToken( qfalse );
913                 strcpy( name, token );
914                 
915                 /* bp */
916                 if( g_bBrushPrimit == BPRIMIT_OLDBRUSHES )
917                 {
918                         GetToken( qfalse );
919                         shift[ 0 ] = atof( token );
920                         GetToken( qfalse );
921                         shift[ 1 ] = atof( token );
922                         GetToken( qfalse );
923                         rotate = atof( token ); 
924                         GetToken( qfalse );
925                         scale[ 0 ] = atof( token );
926                         GetToken( qfalse );
927                         scale[ 1 ] = atof( token );
928                 }
929                 
930                 /* set default flags and values */
931                 sprintf( shader, "textures/%s", name );
932                 if( onlyLights )
933                         si = &shaderInfo[ 0 ];
934                 else
935                         si = ShaderInfoForShader( shader );
936                 side->shaderInfo = si;
937                 side->surfaceFlags = si->surfaceFlags;
938                 side->contentFlags = si->contentFlags;
939                 side->compileFlags = si->compileFlags;
940                 side->value = si->value;
941                 
942                 /* ydnar: gs mods: bias texture shift */
943                 if( si->globalTexture == qfalse )
944                 {
945                         shift[ 0 ] -= (floor( shift[ 0 ] / si->shaderWidth ) * si->shaderWidth);
946                         shift[ 1 ] -= (floor( shift[ 1 ] / si->shaderHeight ) * si->shaderHeight);
947                 }
948                 
949                 /*
950                         historically, there are 3 integer values at the end of a brushside line in a .map file.
951                         in quake 3, the only thing that mattered was the first of these three values, which
952                         was previously the content flags. and only then did a single bit matter, the detail
953                         bit. because every game has its own special flags for specifying detail, the
954                         traditionally game-specified CONTENTS_DETAIL flag was overridden for Q3Map 2.3.0
955                         by C_DETAIL, defined in q3map2.h. the value is exactly as it was before, but
956                         is stored in compileFlags, as opposed to contentFlags, for multiple-game
957                         portability. :sigh:
958                 */
959                 
960                 if( TokenAvailable() )
961                 {
962                         /* get detail bit from map content flags */
963                         GetToken( qfalse );
964                         flags = atoi( token );
965                         if( flags & C_DETAIL )
966                                 side->compileFlags |= C_DETAIL;
967                         
968                         /* historical */
969                         GetToken( qfalse );
970                         //% td.flags = atoi( token );
971                         GetToken( qfalse );
972                         //% td.value = atoi( token );
973                 }
974                 
975                 /* find the plane number */
976                 planenum = MapPlaneFromPoints( planePoints );
977                 side->planenum = planenum;
978                 
979                 /* bp: get the texture mapping for this texturedef / plane combination */
980                 if( g_bBrushPrimit == BPRIMIT_OLDBRUSHES )
981                         QuakeTextureVecs( &mapplanes[ planenum ], shift, rotate, scale, side->vecs );
982         }
983         
984         /* bp */
985         if( g_bBrushPrimit == BPRIMIT_NEWBRUSHES )
986         {
987                 UnGetToken();
988                 MatchToken( "}" );
989                 MatchToken( "}" );
990         }
991 }
992
993
994
995 /*
996 RemoveDuplicateBrushPlanes
997 returns false if the brush has a mirrored set of planes,
998 meaning it encloses no volume.
999 also removes planes without any normal
1000 */
1001
1002 qboolean RemoveDuplicateBrushPlanes( brush_t *b )
1003 {
1004         int                     i, j, k;
1005         side_t          *sides;
1006
1007         sides = b->sides;
1008
1009         for ( i = 1 ; i < b->numsides ; i++ ) {
1010
1011                 // check for a degenerate plane
1012                 if ( sides[i].planenum == -1) {
1013                   xml_Select( "degenerate plane", b->entityNum, b->brushNum, qfalse );
1014                         // remove it
1015                         for ( k = i + 1 ; k < b->numsides ; k++ ) {
1016                                 sides[k-1] = sides[k];
1017                         }
1018                         b->numsides--;
1019                         i--;
1020                         continue;
1021                 }
1022
1023                 // check for duplication and mirroring
1024                 for ( j = 0 ; j < i ; j++ ) {
1025                         if ( sides[i].planenum == sides[j].planenum ) {
1026                           xml_Select( "duplicate plane", b->entityNum, b->brushNum, qfalse );
1027                                 // remove the second duplicate
1028                                 for ( k = i + 1 ; k < b->numsides ; k++ ) {
1029                                         sides[k-1] = sides[k];
1030                                 }
1031                                 b->numsides--;
1032                                 i--;
1033                                 break;
1034                         }
1035
1036                         if ( sides[i].planenum == (sides[j].planenum ^ 1) ) {
1037                                 // mirror plane, brush is invalid
1038                           xml_Select( "mirrored plane", b->entityNum, b->brushNum, qfalse );
1039                                 return qfalse;
1040                         }
1041                 }
1042         }
1043         return qtrue;
1044 }
1045
1046
1047
1048 /*
1049 ParseBrush()
1050 parses a brush out of a map file and sets it up
1051 */
1052
1053 static void ParseBrush( qboolean onlyLights, qboolean noCollapseGroups )
1054 {
1055         brush_t *b;
1056         
1057         
1058         /* parse the brush out of the map */
1059         ParseRawBrush( onlyLights );
1060         
1061         /* only go this far? */
1062         if( onlyLights )
1063                 return;
1064         
1065         /* set some defaults */
1066         buildBrush->portalareas[ 0 ] = -1;
1067         buildBrush->portalareas[ 1 ] = -1;
1068         buildBrush->entityNum = numMapEntities - 1;
1069         buildBrush->brushNum = entitySourceBrushes;
1070         
1071         /* if there are mirrored planes, the entire brush is invalid */
1072         if( !RemoveDuplicateBrushPlanes( buildBrush ) )
1073                 return;
1074         
1075         /* get the content for the entire brush */
1076         SetBrushContents( buildBrush );
1077         
1078         /* allow detail brushes to be removed */
1079         if( nodetail && (buildBrush->compileFlags & C_DETAIL) )
1080         {
1081                 //%     FreeBrush( buildBrush );
1082                 return;
1083         }
1084         
1085         /* allow liquid brushes to be removed */
1086         if( nowater && (buildBrush->compileFlags & C_LIQUID ) )
1087         {
1088                 //%     FreeBrush( buildBrush );
1089                 return;
1090         }
1091         
1092         /* ydnar: allow hint brushes to be removed */
1093         if( noHint && (buildBrush->compileFlags & C_HINT) )
1094         {
1095                 //%     FreeBrush( buildBrush );
1096                 return;
1097         }
1098         
1099         /* finish the brush */
1100         b = FinishBrush(noCollapseGroups);
1101 }
1102
1103
1104
1105 /*
1106 MoveBrushesToWorld()
1107 takes all of the brushes from the current entity and
1108 adds them to the world's brush list
1109 (used by func_group)
1110 */
1111
1112 void AdjustBrushesForOrigin( entity_t *ent );
1113 void MoveBrushesToWorld( entity_t *ent )
1114 {
1115         brush_t         *b, *next;
1116         parseMesh_t     *pm;
1117
1118         /* we need to undo the common/origin adjustment, and instead shift them by the entity key origin */
1119         VectorScale(ent->origin, -1, ent->originbrush_origin);
1120         AdjustBrushesForOrigin(ent);
1121         VectorClear(ent->originbrush_origin);
1122         
1123         /* move brushes */
1124         for( b = ent->brushes; b != NULL; b = next )
1125         {
1126                 /* get next brush */
1127                 next = b->next;
1128                 
1129                 /* link opaque brushes to head of list, translucent brushes to end */
1130                 if( b->opaque || entities[ 0 ].lastBrush == NULL )
1131                 {
1132                         b->next = entities[ 0 ].brushes;
1133                         entities[ 0 ].brushes = b;
1134                         if( entities[ 0 ].lastBrush == NULL )
1135                                 entities[ 0 ].lastBrush = b;
1136                 }
1137                 else
1138                 {
1139                         b->next = NULL;
1140                         entities[ 0 ].lastBrush->next = b;
1141                         entities[ 0 ].lastBrush = b;
1142                 }
1143         }
1144         ent->brushes = NULL;
1145         
1146         /* ydnar: move colormod brushes */
1147         if( ent->colorModBrushes != NULL )
1148         {
1149                 for( b = ent->colorModBrushes; b->nextColorModBrush != NULL; b = b->nextColorModBrush );
1150                 
1151                 b->nextColorModBrush = entities[ 0 ].colorModBrushes;
1152                 entities[ 0 ].colorModBrushes = ent->colorModBrushes;
1153                 
1154                 ent->colorModBrushes = NULL;
1155         }
1156         
1157         /* move patches */
1158         if( ent->patches != NULL )
1159         {
1160                 for( pm = ent->patches; pm->next != NULL; pm = pm->next );
1161                 
1162                 pm->next = entities[ 0 ].patches;
1163                 entities[ 0 ].patches = ent->patches;
1164                 
1165                 ent->patches = NULL;
1166         }
1167 }
1168
1169
1170
1171 /*
1172 AdjustBrushesForOrigin()
1173 */
1174
1175 void AdjustBrushesForOrigin( entity_t *ent )
1176 {
1177         
1178         int                     i;
1179         side_t          *s;
1180         vec_t           newdist;
1181         brush_t         *b;
1182         parseMesh_t     *p;
1183         
1184         /* walk brush list */
1185         for( b = ent->brushes; b != NULL; b = b->next )
1186         {
1187                 /* offset brush planes */
1188                 for( i = 0; i < b->numsides; i++)
1189                 {
1190                         /* get brush side */
1191                         s = &b->sides[ i ];
1192                         
1193                         /* offset side plane */
1194                         newdist = mapplanes[ s->planenum ].dist - DotProduct( mapplanes[ s->planenum ].normal, ent->originbrush_origin );
1195                         
1196                         /* find a new plane */
1197                         s->planenum = FindFloatPlane( mapplanes[ s->planenum ].normal, newdist, 0, NULL );
1198                 }
1199                 
1200                 /* rebuild brush windings (ydnar: just offsetting the winding above should be fine) */
1201                 CreateBrushWindings( b );
1202         }
1203         
1204         /* walk patch list */
1205         for( p = ent->patches; p != NULL; p = p->next )
1206         {
1207                 for( i = 0; i < (p->mesh.width * p->mesh.height); i++ )
1208                         VectorSubtract( p->mesh.verts[ i ].xyz, ent->originbrush_origin, p->mesh.verts[ i ].xyz );
1209         }
1210 }
1211
1212
1213
1214 /*
1215 SetEntityBounds() - ydnar
1216 finds the bounds of an entity's brushes (necessary for terrain-style generic metashaders)
1217 */
1218
1219 void SetEntityBounds( entity_t *e )
1220 {
1221         int                     i;
1222         brush_t *b;
1223         parseMesh_t     *p;
1224         vec3_t          mins, maxs;
1225         const char      *value;
1226
1227         
1228         
1229
1230         /* walk the entity's brushes/patches and determine bounds */
1231         ClearBounds( mins, maxs );
1232         for( b = e->brushes; b; b = b->next )
1233         {
1234                 AddPointToBounds( b->mins, mins, maxs );
1235                 AddPointToBounds( b->maxs, mins, maxs );
1236         }
1237         for( p = e->patches; p; p = p->next )
1238         {
1239                 for( i = 0; i < (p->mesh.width * p->mesh.height); i++ )
1240                         AddPointToBounds( p->mesh.verts[ i ].xyz, mins, maxs );
1241         }
1242         
1243         /* try to find explicit min/max key */
1244         value = ValueForKey( e, "min" ); 
1245         if( value[ 0 ] != '\0' )
1246                 GetVectorForKey( e, "min", mins );
1247         value = ValueForKey( e, "max" ); 
1248         if( value[ 0 ] != '\0' )
1249                 GetVectorForKey( e, "max", maxs );
1250         
1251         /* store the bounds */
1252         for( b = e->brushes; b; b = b->next )
1253         {
1254                 VectorCopy( mins, b->eMins );
1255                 VectorCopy( maxs, b->eMaxs );
1256         }
1257         for( p = e->patches; p; p = p->next )
1258         {
1259                 VectorCopy( mins, p->eMins );
1260                 VectorCopy( maxs, p->eMaxs );
1261         }
1262 }
1263
1264
1265
1266 /*
1267 LoadEntityIndexMap() - ydnar
1268 based on LoadAlphaMap() from terrain.c, a little more generic
1269 */
1270
1271 void LoadEntityIndexMap( entity_t *e )
1272 {
1273         int                             i, size, numLayers, w, h;
1274         const char              *value, *indexMapFilename, *shader;
1275         char                    ext[ MAX_QPATH ], offset[ 4096 ], *search, *space;
1276         byte                    *pixels;
1277         unsigned int    *pixels32;
1278         indexMap_t              *im;
1279         brush_t                 *b;
1280         parseMesh_t             *p;
1281         
1282         
1283         /* this only works with bmodel ents */
1284         if( e->brushes == NULL && e->patches == NULL )
1285                 return;
1286         
1287         /* determine if there is an index map (support legacy "alphamap" key as well) */
1288         value = ValueForKey( e, "_indexmap" );
1289         if( value[ 0 ] == '\0' )
1290                 value = ValueForKey( e, "alphamap" );
1291         if( value[ 0 ] == '\0' )
1292                 return;
1293         indexMapFilename = value;
1294         
1295         /* get number of layers (support legacy "layers" key as well) */
1296         value = ValueForKey( e, "_layers" );
1297         if( value[ 0 ] == '\0' )
1298                 value = ValueForKey( e, "layers" );
1299         if( value[ 0 ] == '\0' )
1300         {
1301                 Sys_Printf( "WARNING: Entity with index/alpha map \"%s\" has missing \"_layers\" or \"layers\" key\n", indexMapFilename );
1302                 Sys_Printf( "Entity will not be textured properly. Check your keys/values.\n" );
1303                 return;
1304         }
1305         numLayers = atoi( value );
1306         if( numLayers < 1 )
1307         {
1308                 Sys_Printf( "WARNING: Entity with index/alpha map \"%s\" has < 1 layer (%d)\n", indexMapFilename, numLayers );
1309                 Sys_Printf( "Entity will not be textured properly. Check your keys/values.\n" );
1310                 return;
1311         }
1312         
1313         /* get base shader name (support legacy "shader" key as well) */
1314         value = ValueForKey( mapEnt, "_shader" );
1315         if( value[ 0 ] == '\0' )
1316                 value = ValueForKey( e, "shader" );
1317         if( value[ 0 ] == '\0' )
1318         {
1319                 Sys_Printf( "WARNING: Entity with index/alpha map \"%s\" has missing \"_shader\" or \"shader\" key\n", indexMapFilename );
1320                 Sys_Printf( "Entity will not be textured properly. Check your keys/values.\n" );
1321                 return;
1322         }
1323         shader = value;
1324         
1325         /* note it */
1326         Sys_FPrintf( SYS_VRB, "Entity %d (%s) has shader index map \"%s\"\n",  mapEnt->mapEntityNum, ValueForKey( e, "classname" ), indexMapFilename );
1327         
1328         /* get index map file extension */
1329         ExtractFileExtension( indexMapFilename, ext );
1330         
1331         /* handle tga image */
1332         if( !Q_stricmp( ext, "tga" ) )
1333         {
1334                 /* load it */
1335                 Load32BitImage( indexMapFilename, &pixels32, &w, &h );
1336                 
1337                 /* convert to bytes */
1338                 size = w * h;
1339                 pixels = safe_malloc( size );
1340                 for( i = 0; i < size; i++ )
1341                 {
1342                         pixels[ i ] = ((pixels32[ i ] & 0xFF) * numLayers) / 256;
1343                         if( pixels[ i ] >= numLayers )
1344                                 pixels[ i ] = numLayers - 1;
1345                 }
1346                 
1347                 /* free the 32 bit image */
1348                 free( pixels32 );
1349         }
1350         else
1351         {
1352                 /* load it */
1353                 Load256Image( indexMapFilename, &pixels, NULL, &w, &h );
1354                 
1355                 /* debug code */
1356                 //%     Sys_Printf( "-------------------------------" );
1357                 
1358                 /* fix up out-of-range values */
1359                 size = w * h;
1360                 for( i = 0; i < size; i++ )
1361                 {
1362                         if( pixels[ i ] >= numLayers )
1363                                 pixels[ i ] = numLayers - 1;
1364                         
1365                         /* debug code */
1366                         //%     if( (i % w) == 0 )
1367                         //%             Sys_Printf( "\n" );
1368                         //%     Sys_Printf( "%c", pixels[ i ] + '0' );
1369                 }
1370                 
1371                 /* debug code */
1372                 //%     Sys_Printf( "\n-------------------------------\n" );
1373         }
1374         
1375         /* the index map must be at least 2x2 pixels */
1376         if( w < 2 || h < 2 )
1377         {
1378                 Sys_Printf( "WARNING: Entity with index/alpha map \"%s\" is smaller than 2x2 pixels\n", indexMapFilename );
1379                 Sys_Printf( "Entity will not be textured properly. Check your keys/values.\n" );
1380                 free( pixels );
1381                 return;
1382         }
1383
1384         /* create a new index map */
1385         im = safe_malloc( sizeof( *im ) );
1386         memset( im, 0, sizeof( *im ) );
1387         
1388         /* set it up */
1389         im->w = w;
1390         im->h = h;
1391         im->numLayers = numLayers;
1392         strcpy( im->name, indexMapFilename );
1393         strcpy( im->shader, shader );
1394         im->pixels = pixels;
1395         
1396         /* get height offsets */
1397         value = ValueForKey( mapEnt, "_offsets" );
1398         if( value[ 0 ] == '\0' )
1399                 value = ValueForKey( e, "offsets" );
1400         if( value[ 0 ] != '\0' )
1401         {
1402                 /* value is a space-seperated set of numbers */
1403                 strcpy( offset, value );
1404                 search = offset;
1405                 
1406                 /* get each value */
1407                 for( i = 0; i < 256 && *search != '\0'; i++ )
1408                 {
1409                         space = strstr( search, " " );
1410                         if( space != NULL )
1411                                 *space = '\0';
1412                         im->offsets[ i ] = atof( search );
1413                         if( space == NULL )
1414                                 break;
1415                         search = space + 1;
1416                 }
1417         }
1418         
1419         /* store the index map in every brush/patch in the entity */
1420         for( b = e->brushes; b != NULL; b = b->next )
1421                 b->im = im;
1422         for( p = e->patches; p != NULL; p = p->next )
1423                 p->im = im;
1424 }
1425
1426
1427
1428
1429
1430
1431
1432 /*
1433 ParseMapEntity()
1434 parses a single entity out of a map file
1435 */
1436
1437 static qboolean ParseMapEntity( qboolean onlyLights, qboolean noCollapseGroups )
1438 {
1439         epair_t                 *ep;
1440         const char              *classname, *value;
1441         float                   lightmapScale, shadeAngle;
1442         int                             lightmapSampleSize;
1443         char                    shader[ MAX_QPATH ];
1444         shaderInfo_t    *celShader = NULL;
1445         brush_t                 *brush;
1446         parseMesh_t             *patch;
1447         qboolean                funcGroup;
1448         int                             castShadows, recvShadows;
1449         
1450         
1451         /* eof check */
1452         if( !GetToken( qtrue ) )
1453                 return qfalse;
1454         
1455         /* conformance check */
1456         if( strcmp( token, "{" ) )
1457         {
1458                 Sys_Printf( "WARNING: ParseEntity: { not found, found %s on line %d - last entity was at: <%4.2f, %4.2f, %4.2f>...\n"
1459                         "Continuing to process map, but resulting BSP may be invalid.\n",
1460                         token, scriptline, entities[ numEntities ].origin[ 0 ], entities[ numEntities ].origin[ 1 ], entities[ numEntities ].origin[ 2 ] );
1461                 return qfalse;
1462         }
1463         
1464         /* range check */
1465         if( numEntities >= MAX_MAP_ENTITIES )
1466                 Error( "numEntities == MAX_MAP_ENTITIES" );
1467         
1468         /* setup */
1469         entitySourceBrushes = 0;
1470         mapEnt = &entities[ numEntities ];
1471         numEntities++;
1472         memset( mapEnt, 0, sizeof( *mapEnt ) );
1473         
1474         /* ydnar: true entity numbering */
1475         mapEnt->mapEntityNum = numMapEntities;
1476         numMapEntities++;
1477         
1478         /* loop */
1479         while( 1 )
1480         {
1481                 /* get initial token */
1482                 if( !GetToken( qtrue ) )
1483                 {
1484                         Sys_Printf( "WARNING: ParseEntity: EOF without closing brace\n"
1485                                 "Continuing to process map, but resulting BSP may be invalid.\n" );
1486                         return qfalse;
1487                 }
1488                 
1489                 if( !strcmp( token, "}" ) )
1490                         break;
1491                 
1492                 if( !strcmp( token, "{" ) )
1493                 {
1494                         /* parse a brush or patch */
1495                         if( !GetToken( qtrue ) )
1496                                 break;
1497                         
1498                         /* check */
1499                         if( !strcmp( token, "patchDef2" ) )
1500                         {
1501                                 numMapPatches++;
1502                                 ParsePatch( onlyLights );
1503                         }
1504                         else if( !strcmp( token, "terrainDef" ) )
1505                         {
1506                                 //% ParseTerrain();
1507                                 Sys_Printf( "WARNING: Terrain entity parsing not supported in this build.\n" ); /* ydnar */
1508                         }
1509                         else if( !strcmp( token, "brushDef" ) )
1510                         {
1511                                 if( g_bBrushPrimit == BPRIMIT_OLDBRUSHES )
1512                                         Error( "Old brush format not allowed in new brush format map" );
1513                                 g_bBrushPrimit = BPRIMIT_NEWBRUSHES;
1514                                 
1515                                 /* parse brush primitive */
1516                                 ParseBrush( onlyLights, noCollapseGroups );
1517                         }
1518                         else
1519                         {
1520                                 if( g_bBrushPrimit == BPRIMIT_NEWBRUSHES )
1521                                         Error( "New brush format not allowed in old brush format map" );
1522                                 g_bBrushPrimit = BPRIMIT_OLDBRUSHES;
1523                                 
1524                                 /* parse old brush format */
1525                                 UnGetToken();
1526                                 ParseBrush( onlyLights, noCollapseGroups );
1527                         }
1528                         entitySourceBrushes++;
1529                 }
1530                 else
1531                 {
1532                         /* parse a key / value pair */
1533                         ep = ParseEPair();
1534                         
1535                         /* ydnar: 2002-07-06 fixed wolf bug with empty epairs */
1536                         if( ep->key[ 0 ] != '\0' && ep->value[ 0 ] != '\0' )
1537                         {
1538                                 ep->next = mapEnt->epairs;
1539                                 mapEnt->epairs = ep;
1540                         }
1541                 }
1542         }
1543         
1544         /* ydnar: get classname */
1545         classname = ValueForKey( mapEnt, "classname" );
1546         
1547         /* ydnar: only lights? */
1548         if( onlyLights && Q_strncasecmp( classname, "light", 5 ) )
1549         {
1550                 numEntities--;
1551                 return qtrue;
1552         }
1553         
1554         /* ydnar: determine if this is a func_group */
1555         if( !Q_stricmp( "func_group", classname ) )
1556                 funcGroup = qtrue;
1557         else
1558                 funcGroup = qfalse;
1559         
1560         /* worldspawn (and func_groups) default to cast/recv shadows in worldspawn group */
1561         if( funcGroup || mapEnt->mapEntityNum == 0 )
1562         {
1563                 //%     Sys_Printf( "World:  %d\n", mapEnt->mapEntityNum );
1564                 castShadows = WORLDSPAWN_CAST_SHADOWS;
1565                 recvShadows = WORLDSPAWN_RECV_SHADOWS;
1566         }
1567         
1568         /* other entities don't cast any shadows, but recv worldspawn shadows */
1569         else
1570         {
1571                 //%     Sys_Printf( "Entity: %d\n", mapEnt->mapEntityNum );
1572                 castShadows = ENTITY_CAST_SHADOWS;
1573                 recvShadows = ENTITY_RECV_SHADOWS;
1574         }
1575         
1576         /* get explicit shadow flags */
1577         GetEntityShadowFlags( mapEnt, NULL, &castShadows, &recvShadows );
1578         
1579         /* vortex: added _ls key (short name of lightmapscale) */
1580         /* ydnar: get lightmap scaling value for this entity */
1581         lightmapScale = 0.0f;
1582         if( strcmp( "", ValueForKey( mapEnt, "lightmapscale" ) ) ||
1583                 strcmp( "", ValueForKey( mapEnt, "_lightmapscale" ) ) || 
1584                 strcmp( "", ValueForKey( mapEnt, "_ls" ) ) )
1585         {
1586                 /* get lightmap scale from entity */
1587                 lightmapScale = FloatForKey( mapEnt, "lightmapscale" );
1588                 if( lightmapScale <= 0.0f )
1589                         lightmapScale = FloatForKey( mapEnt, "_lightmapscale" );
1590                 if( lightmapScale <= 0.0f )
1591                         lightmapScale = FloatForKey( mapEnt, "_ls" );
1592                 if( lightmapScale < 0.0f )
1593                         lightmapScale = 0.0f;
1594                 if( lightmapScale > 0.0f )
1595                         Sys_Printf( "Entity %d (%s) has lightmap scale of %.4f\n", mapEnt->mapEntityNum, classname, lightmapScale );
1596         }
1597         
1598         /* ydnar: get cel shader :) for this entity */
1599         value = ValueForKey( mapEnt, "_celshader" );
1600         if( value[ 0 ] == '\0' )        
1601                 value = ValueForKey( &entities[ 0 ], "_celshader" );
1602         if( value[ 0 ] != '\0' )
1603         {
1604                 if(strcmp(value, "none"))
1605                 {
1606                         sprintf( shader, "textures/%s", value );
1607                         celShader = ShaderInfoForShader( shader );
1608                         Sys_Printf( "Entity %d (%s) has cel shader %s\n", mapEnt->mapEntityNum, classname, celShader->shader );
1609                 }
1610                 else
1611                 {
1612                         celShader = NULL;
1613                 }
1614         }
1615         else
1616                 celShader = (*globalCelShader ? ShaderInfoForShader(globalCelShader) : NULL);
1617
1618         /* jal : entity based _shadeangle */
1619         shadeAngle = 0.0f;
1620         if ( strcmp( "", ValueForKey( mapEnt, "_shadeangle" ) ) )
1621                 shadeAngle = FloatForKey( mapEnt, "_shadeangle" );
1622         /* vortex' aliases */
1623         else if ( strcmp( "", ValueForKey( mapEnt, "_smoothnormals" ) ) )
1624                 shadeAngle = FloatForKey( mapEnt, "_smoothnormals" );
1625         else if ( strcmp( "", ValueForKey( mapEnt, "_sn" ) ) )
1626                 shadeAngle = FloatForKey( mapEnt, "_sn" );
1627         else if ( strcmp( "", ValueForKey( mapEnt, "_smooth" ) ) )
1628                 shadeAngle = FloatForKey( mapEnt, "_smooth" );
1629         
1630         if( shadeAngle < 0.0f )
1631                 shadeAngle = 0.0f;
1632
1633         if( shadeAngle > 0.0f )
1634                 Sys_Printf( "Entity %d (%s) has shading angle of %.4f\n", mapEnt->mapEntityNum, classname, shadeAngle );
1635         
1636         /* jal : entity based _samplesize */
1637         lightmapSampleSize = 0;
1638         if ( strcmp( "", ValueForKey( mapEnt, "_lightmapsamplesize" ) ) )
1639                 lightmapSampleSize = IntForKey( mapEnt, "_lightmapsamplesize" );
1640         else if ( strcmp( "", ValueForKey( mapEnt, "_samplesize" ) ) )
1641                 lightmapSampleSize = IntForKey( mapEnt, "_samplesize" );
1642         
1643         if( lightmapSampleSize < 0 )
1644                 lightmapSampleSize = 0;
1645
1646         if( lightmapSampleSize > 0 )
1647                 Sys_Printf( "Entity %d (%s) has lightmap sample size of %d\n", mapEnt->mapEntityNum, classname, lightmapSampleSize );
1648         
1649         /* attach stuff to everything in the entity */
1650         for( brush = mapEnt->brushes; brush != NULL; brush = brush->next )
1651         {
1652                 brush->entityNum = mapEnt->mapEntityNum;
1653                 brush->castShadows = castShadows;
1654                 brush->recvShadows = recvShadows;
1655                 brush->lightmapSampleSize = lightmapSampleSize;
1656                 brush->lightmapScale = lightmapScale;
1657                 brush->celShader = celShader;
1658                 brush->shadeAngleDegrees = shadeAngle;
1659         }
1660         
1661         for( patch = mapEnt->patches; patch != NULL; patch = patch->next )
1662         {
1663                 patch->entityNum = mapEnt->mapEntityNum;
1664                 patch->castShadows = castShadows;
1665                 patch->recvShadows = recvShadows;
1666                 patch->lightmapSampleSize = lightmapSampleSize;
1667                 patch->lightmapScale = lightmapScale;
1668                 patch->celShader = celShader;
1669         }
1670         
1671         /* ydnar: gs mods: set entity bounds */
1672         SetEntityBounds( mapEnt );
1673         
1674         /* ydnar: gs mods: load shader index map (equivalent to old terrain alphamap) */
1675         LoadEntityIndexMap( mapEnt );
1676         
1677         /* get entity origin and adjust brushes */
1678         GetVectorForKey( mapEnt, "origin", mapEnt->origin );
1679         if( mapEnt->originbrush_origin[ 0 ] || mapEnt->originbrush_origin[ 1 ] || mapEnt->originbrush_origin[ 2 ] )
1680                 AdjustBrushesForOrigin( mapEnt );
1681
1682         /* group_info entities are just for editor grouping (fixme: leak!) */
1683         if( !noCollapseGroups && !Q_stricmp( "group_info", classname ) )
1684         {
1685                 numEntities--;
1686                 return qtrue;
1687         }
1688         
1689         /* group entities are just for editor convenience, toss all brushes into worldspawn */
1690         if( !noCollapseGroups && funcGroup )
1691         {
1692                 MoveBrushesToWorld( mapEnt );
1693                 numEntities--;
1694                 return qtrue;
1695         }
1696         
1697         /* done */
1698         return qtrue;
1699 }
1700
1701
1702
1703 /*
1704 LoadMapFile()
1705 loads a map file into a list of entities
1706 */
1707
1708 void LoadMapFile( char *filename, qboolean onlyLights, qboolean noCollapseGroups )
1709 {               
1710         FILE            *file;
1711         brush_t         *b;
1712         int                     oldNumEntities = 0, numMapBrushes;
1713         
1714         
1715         /* note it */
1716         Sys_FPrintf( SYS_VRB, "--- LoadMapFile ---\n" );
1717         Sys_Printf( "Loading %s\n", filename );
1718         
1719         /* hack */
1720         file = SafeOpenRead( filename );
1721         fclose( file );
1722         
1723         /* load the map file */
1724         LoadScriptFile( filename, -1 );
1725         
1726         /* setup */
1727         if( onlyLights )
1728                 oldNumEntities = numEntities;
1729         else
1730                 numEntities = 0;
1731         
1732         /* initial setup */
1733         numMapDrawSurfs = 0;
1734         c_detail = 0;
1735         g_bBrushPrimit = BPRIMIT_UNDEFINED;
1736         
1737         /* allocate a very large temporary brush for building the brushes as they are loaded */
1738         buildBrush = AllocBrush( MAX_BUILD_SIDES );
1739         
1740         /* parse the map file */
1741         while( ParseMapEntity( onlyLights, noCollapseGroups ) );
1742         
1743         /* light loading */
1744         if( onlyLights )
1745         {
1746                 /* emit some statistics */
1747                 Sys_FPrintf( SYS_VRB, "%9d light entities\n", numEntities - oldNumEntities );
1748         }
1749         else
1750         {
1751                 /* set map bounds */
1752                 ClearBounds( mapMins, mapMaxs );
1753                 for( b = entities[ 0 ].brushes; b; b = b->next )
1754                 {
1755                         AddPointToBounds( b->mins, mapMins, mapMaxs );
1756                         AddPointToBounds( b->maxs, mapMins, mapMaxs );
1757                 }
1758                 
1759                 /* get brush counts */
1760                 numMapBrushes = CountBrushList( entities[ 0 ].brushes );
1761                 if( (float) c_detail / (float) numMapBrushes < 0.10f && numMapBrushes > 500 )
1762                         Sys_Printf( "WARNING: Over 90 percent structural map detected. Compile time may be adversely affected.\n" );
1763                 
1764                 /* emit some statistics */
1765                 Sys_FPrintf( SYS_VRB, "%9d total world brushes\n", numMapBrushes );
1766                 Sys_FPrintf( SYS_VRB, "%9d detail brushes\n", c_detail );
1767                 Sys_FPrintf( SYS_VRB, "%9d patches\n", numMapPatches);
1768                 Sys_FPrintf( SYS_VRB, "%9d boxbevels\n", c_boxbevels);
1769                 Sys_FPrintf( SYS_VRB, "%9d edgebevels\n", c_edgebevels);
1770                 Sys_FPrintf( SYS_VRB, "%9d entities\n", numEntities );
1771                 Sys_FPrintf( SYS_VRB, "%9d planes\n", nummapplanes);
1772                 Sys_Printf( "%9d areaportals\n", c_areaportals);
1773                 Sys_Printf( "Size: %5.0f, %5.0f, %5.0f to %5.0f, %5.0f, %5.0f\n",
1774                         mapMins[ 0 ], mapMins[ 1 ], mapMins[ 2 ],
1775                         mapMaxs[ 0 ], mapMaxs[ 1 ], mapMaxs[ 2 ]);
1776                 
1777                 /* write bogus map */
1778                 if( fakemap )
1779                         WriteBSPBrushMap( "fakemap.map", entities[ 0 ].brushes );
1780         }
1781 }