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