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