mark two shader checks nullable
[divverent/netradiant.git] / tools / quake3 / q3map2 / fog.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 FOG_C
33
34
35
36 /* dependencies */
37 #include "q3map2.h"
38
39
40
41 int                     numFogFragments;
42 int                     numFogPatchFragments;
43
44
45
46 /*
47 DrawSurfToMesh()
48 converts a patch drawsurface to a mesh_t
49 */
50
51 mesh_t *DrawSurfToMesh( mapDrawSurface_t *ds )
52 {
53         mesh_t          *m;
54         
55         
56         m = safe_malloc( sizeof( *m ) );
57         m->width = ds->patchWidth;
58         m->height = ds->patchHeight;
59         m->verts = safe_malloc( sizeof(m->verts[ 0 ]) * m->width * m->height );
60         memcpy( m->verts, ds->verts, sizeof(m->verts[ 0 ]) * m->width * m->height );
61         
62         return m;
63 }
64
65
66
67 /*
68 SplitMeshByPlane()
69 chops a mesh by a plane
70 */
71
72 void SplitMeshByPlane( mesh_t *in, vec3_t normal, float dist, mesh_t **front, mesh_t **back )
73 {
74         int             w, h, split;
75         float   d[MAX_PATCH_SIZE][MAX_PATCH_SIZE];
76         bspDrawVert_t   *dv, *v1, *v2;
77         int             c_front, c_back, c_on;
78         mesh_t  *f, *b;
79         int             i;
80         float   frac;
81         int             frontAprox, backAprox;
82
83         for ( i = 0 ; i < 2 ; i++ ) {
84                 dv = in->verts;
85                 c_front = 0;
86                 c_back = 0;
87                 c_on = 0;
88                 for ( h = 0 ; h < in->height ; h++ ) {
89                         for ( w = 0 ; w < in->width ; w++, dv++ ) {
90                                 d[h][w] = DotProduct( dv->xyz, normal ) - dist;
91                                 if ( d[h][w] > ON_EPSILON ) {
92                                         c_front++;
93                                 } else if ( d[h][w] < -ON_EPSILON ) {
94                                         c_back++;
95                                 } else {
96                                         c_on++;
97                                 }
98                         }
99                 }
100
101                 *front = NULL;
102                 *back = NULL;
103
104                 if ( !c_front ) {
105                         *back = in;
106                         return;
107                 }
108                 if ( !c_back ) {
109                         *front = in;
110                         return;
111                 }
112
113                 // find a split point
114                 split = -1;
115                 for ( w = 0 ; w < in->width -1 ; w++ ) {
116                         if ( ( d[0][w] < 0 ) != ( d[0][w+1] < 0 ) ) {
117                                 if ( split == -1 ) {
118                                         split = w;
119                                         break;
120                                 }
121                         }
122                 }
123
124                 if ( split == -1 ) {
125                         if ( i == 1 ) {
126                                 Sys_FPrintf (SYS_VRB, "No crossing points in patch\n");
127                                 *front = in;
128                                 return;
129                         }
130
131                         in = TransposeMesh( in );
132                         InvertMesh( in );
133                         continue;
134                 }
135
136                 // make sure the split point stays the same for all other rows
137                 for ( h = 1 ; h < in->height ; h++ ) {
138                         for ( w = 0 ; w < in->width -1 ; w++ ) {
139                                 if ( ( d[h][w] < 0 ) != ( d[h][w+1] < 0 ) ) {
140                                         if ( w != split ) {
141                                                 Sys_Printf( "multiple crossing points for patch -- can't clip\n");
142                                                 *front = in;
143                                                 return;
144                                         }
145                                 }
146                         }
147                         if ( ( d[h][split] < 0 ) == ( d[h][split+1] < 0 ) ) {
148                                 Sys_Printf( "differing crossing points for patch -- can't clip\n");
149                                 *front = in;
150                                 return;
151                         }
152                 }
153
154                 break;
155         }
156
157
158         // create two new meshes
159         f = safe_malloc( sizeof( *f ) );
160         f->width = split + 2;
161         if ( ! (f->width & 1) ) {
162                 f->width++;
163                 frontAprox = 1;
164         } else {
165                 frontAprox = 0;
166         }
167         if ( f->width > MAX_PATCH_SIZE ) {
168                 Error( "MAX_PATCH_SIZE after split");
169         }
170         f->height = in->height;
171         f->verts = safe_malloc( sizeof(f->verts[0]) * f->width * f->height );
172
173         b = safe_malloc( sizeof( *b ) );
174         b->width = in->width - split;
175         if ( ! (b->width & 1) ) {
176                 b->width++;
177                 backAprox = 1;
178         } else {
179                 backAprox = 0;
180         }
181         if ( b->width > MAX_PATCH_SIZE ) {
182                 Error( "MAX_PATCH_SIZE after split");
183         }
184         b->height = in->height;
185         b->verts = safe_malloc( sizeof(b->verts[0]) * b->width * b->height );
186
187         if ( d[0][0] > 0 ) {
188                 *front = f;
189                 *back = b;
190         } else {
191                 *front = b;
192                 *back = f;
193         }
194
195         // distribute the points
196         for ( w = 0 ; w < in->width ; w++ ) {
197                 for ( h = 0 ; h < in->height ; h++ ) {
198                         if ( w <= split ) {
199                                 f->verts[ h * f->width + w ] = in->verts[ h * in->width + w ];
200                         } else {
201                                 b->verts[ h * b->width + w - split + backAprox ] = in->verts[ h * in->width + w ];
202                         }
203                 }
204         }
205
206         // clip the crossing line
207         for ( h = 0; h < in->height; h++ )
208         {
209                 dv = &f->verts[ h * f->width + split + 1 ];
210                 v1 = &in->verts[ h * in->width + split ];
211                 v2 = &in->verts[ h * in->width + split + 1 ];
212
213                 frac = d[h][split] / ( d[h][split] - d[h][split+1] );
214                 
215                 /* interpolate */
216                 //%     for( i = 0; i < 10; i++ )
217                 //%             dv->xyz[ i ] = v1->xyz[ i ] + frac * (v2->xyz[ i ] - v1->xyz[ i ]);
218                 //%     dv->xyz[10] = 0;        // set all 4 colors to 0 
219                 LerpDrawVertAmount( v1, v2, frac, dv );
220                 
221                 if ( frontAprox ) {
222                         f->verts[ h * f->width + split + 2 ] = *dv;
223                 }
224                 b->verts[ h * b->width ] = *dv;
225                 if ( backAprox ) {
226                         b->verts[ h * b->width + 1 ] = *dv;
227                 }
228         }
229
230         /*
231 PrintMesh( in );
232 Sys_Printf("\n");
233 PrintMesh( f );
234 Sys_Printf("\n");
235 PrintMesh( b );
236 Sys_Printf("\n");
237         */
238
239         FreeMesh( in );
240 }
241
242
243 /*
244 ChopPatchSurfaceByBrush()
245 chops a patch up by a fog brush
246 */
247
248 qboolean ChopPatchSurfaceByBrush( entity_t *e, mapDrawSurface_t *ds, brush_t *b )
249 {
250         int                     i, j;
251         side_t          *s;
252         plane_t         *plane;
253         mesh_t          *outside[MAX_BRUSH_SIDES];
254         int                     numOutside;
255         mesh_t          *m, *front, *back;
256         mapDrawSurface_t        *newds;
257
258         m = DrawSurfToMesh( ds );
259         numOutside = 0;
260         
261         // only split by the top and bottom planes to avoid
262         // some messy patch clipping issues
263         
264         for ( i = 4 ; i <= 5 ; i++ ) {
265                 s = &b->sides[ i ];
266                 plane = &mapplanes[ s->planenum ];
267
268                 SplitMeshByPlane( m, plane->normal, plane->dist, &front, &back );
269
270                 if ( !back ) {
271                         // nothing actually contained inside
272                         for ( j = 0 ; j < numOutside ; j++ ) {
273                                 FreeMesh( outside[j] );
274                         }
275                         return qfalse;
276                 }
277                 m = back;
278
279                 if ( front ) {
280                         if ( numOutside == MAX_BRUSH_SIDES ) {
281                                 Error( "MAX_BRUSH_SIDES" );
282                         }
283                         outside[ numOutside ] = front;
284                         numOutside++;
285                 }
286         }
287
288         /* all of outside fragments become seperate drawsurfs */
289         numFogPatchFragments += numOutside;
290         for( i = 0; i < numOutside; i++ )
291         {
292                 /* transpose and invert the chopped patch (fixes potential crash. fixme: why?) */
293                 outside[ i ] = TransposeMesh( outside[ i ] );
294                 InvertMesh( outside[ i ] );
295                 
296                 /* ydnar: do this the hacky right way */
297                 newds = AllocDrawSurface( SURFACE_PATCH );
298                 memcpy( newds, ds, sizeof( *ds ) );
299                 newds->patchWidth = outside[ i ]->width;
300                 newds->patchHeight = outside[ i ]->height;
301                 newds->numVerts = outside[ i ]->width * outside[ i ]->height;
302                 newds->verts = safe_malloc( newds->numVerts * sizeof( *newds->verts ) );
303                 memcpy( newds->verts, outside[ i ]->verts, newds->numVerts * sizeof( *newds->verts ) );
304                 
305                 /* free the source mesh */
306                 FreeMesh( outside[ i ] );
307         }
308         
309         /* only rejigger this patch if it was chopped */
310         //%     Sys_Printf( "Inside: %d x %d\n", m->width, m->height );
311         if( numOutside > 0 )
312         {
313                 /* transpose and invert the chopped patch (fixes potential crash. fixme: why?) */
314                 m = TransposeMesh( m );
315                 InvertMesh( m );
316                 
317                 /* replace ds with m */
318                 ds->patchWidth = m->width;
319                 ds->patchHeight = m->height;
320                 ds->numVerts = m->width * m->height;
321                 free( ds->verts );
322                 ds->verts = safe_malloc( ds->numVerts * sizeof( *ds->verts ) );
323                 memcpy( ds->verts, m->verts, ds->numVerts * sizeof( *ds->verts ) );
324         }
325         
326         /* free the source mesh and return */
327         FreeMesh( m );
328         return qtrue;
329 }
330
331
332
333 /*
334 WindingFromDrawSurf()
335 creates a winding from a surface's verts
336 */
337
338 winding_t *WindingFromDrawSurf( mapDrawSurface_t *ds )
339 {
340         winding_t       *w;
341         int                     i;
342
343         // we use the first point of the surface, maybe something more clever would be useful
344         // (actually send the whole draw surface would be cool?)
345         if( ds->numVerts >= MAX_POINTS_ON_WINDING )
346         {
347                 int max = ds->numVerts;
348                 vec3_t p[256];
349
350                 if(max > 256)
351                         max = 256;
352
353                 for ( i = 0 ; i < max ; i++ ) {
354                         VectorCopy( ds->verts[i].xyz, p[i] );
355                 }
356
357                 xml_Winding( "WindingFromDrawSurf failed: MAX_POINTS_ON_WINDING exceeded", p, max, qtrue );
358         }
359
360         w = AllocWinding( ds->numVerts );
361         w->numpoints = ds->numVerts;
362         for ( i = 0 ; i < ds->numVerts ; i++ ) {
363                 VectorCopy( ds->verts[i].xyz, w->p[i] );
364         }
365         return w;
366 }
367
368
369
370 /*
371 ChopFaceSurfaceByBrush()
372 chops up a face drawsurface by a fog brush, with a potential fragment left inside
373 */
374
375 qboolean ChopFaceSurfaceByBrush( entity_t *e, mapDrawSurface_t *ds, brush_t *b )
376 {
377         int                                     i, j;
378         side_t                          *s;
379         plane_t                         *plane;
380         winding_t                       *w;
381         winding_t                       *front, *back;
382         winding_t                       *outside[ MAX_BRUSH_SIDES ];
383         int                                     numOutside;
384         mapDrawSurface_t        *newds;
385         
386         
387         /* dummy check */
388         if( ds->sideRef == NULL || ds->sideRef->side == NULL )
389                 return qfalse;
390         
391         /* initial setup */
392         w = WindingFromDrawSurf( ds );
393         numOutside = 0;
394         
395         /* chop by each brush side */
396         for( i = 0; i < b->numsides; i++ )
397         {
398                 /* get brush side and plane */
399                 s = &b->sides[ i ];
400                 plane = &mapplanes[ s->planenum ];
401                 
402                 /* handle coplanar outfacing (don't fog) */
403                 if( ds->sideRef->side->planenum == s->planenum )
404                         return qfalse;
405                 
406                 /* handle coplanar infacing (keep inside) */
407                 if( (ds->sideRef->side->planenum ^ 1) == s->planenum )
408                         continue;
409                 
410                 /* general case */
411                 ClipWindingEpsilonStrict( w, plane->normal, plane->dist, ON_EPSILON, &front, &back ); /* strict; if plane is "almost identical" to face, both ways to continue can be wrong, so we better not fog it */
412                 FreeWinding( w );
413                 
414                 if( back == NULL )
415                 {
416                         /* nothing actually contained inside */
417                         for( j = 0; j < numOutside; j++ )
418                                 FreeWinding( outside[ j ] );
419                         return qfalse;
420                 }
421                 
422                 if( front != NULL )
423                 {
424                         if( numOutside == MAX_BRUSH_SIDES )
425                                 Error( "MAX_BRUSH_SIDES" );
426                         outside[ numOutside ] = front;
427                         numOutside++;
428                 }
429                 
430                 w = back;
431         }
432         
433         /* fixme: celshaded surface fragment errata */
434         
435         /* all of outside fragments become seperate drawsurfs */
436         numFogFragments += numOutside;
437         s = ds->sideRef->side;
438         for( i = 0; i < numOutside; i++ )
439         {
440                 newds = DrawSurfaceForSide( e, ds->mapBrush, s, outside[ i ] );
441                 newds->fogNum = ds->fogNum;
442                 FreeWinding( outside[ i ] );
443         }
444         
445         /* ydnar: the old code neglected to snap to 0.125 for the fragment
446                   inside the fog brush, leading to sparklies. this new code does
447                           the right thing and uses the original surface's brush side */
448         
449         /* build a drawsurf for it */
450         newds = DrawSurfaceForSide( e, ds->mapBrush, s, w );
451         if( newds == NULL )
452                 return qfalse;
453         
454         /* copy new to original */
455         ClearSurface( ds );
456         memcpy( ds, newds, sizeof( mapDrawSurface_t ) );
457         
458         /* didn't really add a new drawsurface... :) */
459         numMapDrawSurfs--;
460         
461         /* return ok */
462         return qtrue;
463 }
464
465
466
467 /*
468 FogDrawSurfaces()
469 call after the surface list has been pruned, before tjunction fixing
470 */
471
472 void FogDrawSurfaces( entity_t *e )
473 {
474         int                                     i, j, k, fogNum;
475         fog_t                           *fog;
476         mapDrawSurface_t        *ds;
477         vec3_t                          mins, maxs;
478         int                                     fogged, numFogged;
479         int                                     numBaseDrawSurfs;
480         
481         
482         /* note it */
483         Sys_FPrintf( SYS_VRB, "----- FogDrawSurfs -----\n" );
484         
485         /* reset counters */
486         numFogged = 0;
487         numFogFragments = 0;
488         
489         /* walk fog list */
490         for( fogNum = 0; fogNum < numMapFogs; fogNum++ )
491         {
492                 /* get fog */
493                 fog = &mapFogs[ fogNum ];
494                 
495                 /* clip each surface into this, but don't clip any of the resulting fragments to the same brush */
496                 numBaseDrawSurfs = numMapDrawSurfs;
497                 for( i = 0; i < numBaseDrawSurfs; i++ )
498                 {
499                         /* get the drawsurface */
500                         ds = &mapDrawSurfs[ i ];
501                         
502                         /* no fog? */
503                         if( ds->shaderInfo->noFog )
504                                 continue;
505                         
506                         /* global fog doesn't have a brush */
507                         if( fog->brush == NULL )
508                         {
509                                 /* don't re-fog already fogged surfaces */
510                                 if( ds->fogNum >= 0 )
511                                         continue;
512                                 fogged = 1;
513                         }
514                         else
515                         {
516                                 /* find drawsurface bounds */
517                                 ClearBounds( mins, maxs );
518                                 for( j = 0; j < ds->numVerts; j++ )
519                                         AddPointToBounds( ds->verts[ j ].xyz, mins, maxs );
520
521                                 /* check against the fog brush */
522                                 for( k = 0; k < 3; k++ )
523                                 {
524                                         if( mins[ k ] > fog->brush->maxs[ k ] )
525                                                 break;
526                                         if( maxs[ k ] < fog->brush->mins[ k ] )
527                                                 break;
528                                 }
529                                 
530                                 /* no intersection? */
531                                 if( k < 3 )
532                                         continue;
533                                 
534                                 /* ydnar: gs mods: handle the various types of surfaces */
535                                 switch( ds->type )
536                                 {
537                                         /* handle brush faces */
538                                         case SURFACE_FACE:
539                                                 fogged = ChopFaceSurfaceByBrush( e, ds, fog->brush );
540                                                 break;
541                                         
542                                         /* handle patches */
543                                         case SURFACE_PATCH:
544                                                 fogged = ChopPatchSurfaceByBrush( e, ds, fog->brush );
545                                                 break;
546                                         
547                                         /* handle triangle surfaces (fixme: split triangle surfaces) */
548                                         case SURFACE_TRIANGLES:
549                                         case SURFACE_FORCED_META:
550                                         case SURFACE_META:
551                                                 fogged = 1;
552                                                 break;
553
554                                         /* no fogging */
555                                         default:
556                                                 fogged = 0;
557                                                 break;
558                                 }
559                         }
560                         
561                         /* is this surface fogged? */
562                         if( fogged )
563                         {
564                                 numFogged += fogged;
565                                 ds->fogNum = fogNum;
566                         }
567                 }
568         }
569         
570         /* emit some statistics */
571         Sys_FPrintf( SYS_VRB, "%9d fog polygon fragments\n", numFogFragments );
572         Sys_FPrintf( SYS_VRB, "%9d fog patch fragments\n", numFogPatchFragments );
573         Sys_FPrintf( SYS_VRB, "%9d fogged drawsurfs\n", numFogged );
574 }
575
576
577
578 /*
579 FogForPoint() - ydnar
580 gets the fog number for a point in space
581 */
582
583 int FogForPoint( vec3_t point, float epsilon )
584 {
585         int                             fogNum, i, j;
586         float                   dot;
587         qboolean                inside;
588         brush_t                 *brush;
589         plane_t                 *plane;
590         
591         
592         /* start with bogus fog num */
593         fogNum = defaultFogNum;
594         
595         /* walk the list of fog volumes */
596         for( i = 0; i < numMapFogs; i++ )
597         {
598                 /* sof2: global fog doesn't reference a brush */
599                 if( mapFogs[ i ].brush == NULL )
600                 {
601                         fogNum = i;
602                         continue;
603                 }
604                 
605                 /* get fog brush */
606                 brush = mapFogs[ i ].brush;
607                 
608                 /* check point against all planes */
609                 inside = qtrue;
610                 for( j = 0; j < brush->numsides && inside; j++ )
611                 {
612                         plane = &mapplanes[ brush->sides[ j ].planenum ];       /* note usage of map planes here */
613                         dot = DotProduct( point, plane->normal );
614                         dot -= plane->dist;
615                         if( dot > epsilon )
616                                 inside = qfalse;
617                 }
618                 
619                 /* if inside, return the fog num */
620                 if( inside )
621                 {
622                         //%     Sys_Printf( "FogForPoint: %f, %f, %f in fog %d\n", point[ 0 ], point[ 1 ], point[ 2 ], i );
623                         return i;
624                 }
625         }
626         
627         /* if the point made it this far, it's not inside any fog volumes (or inside global fog) */
628         return fogNum;
629 }
630
631
632
633 /*
634 FogForBounds() - ydnar
635 gets the fog number for a bounding box
636 */
637
638 int FogForBounds( vec3_t mins, vec3_t maxs, float epsilon )
639 {
640         int                             fogNum, i, j;
641         float                   highMin, lowMax, volume, bestVolume;
642         vec3_t                  fogMins, fogMaxs, overlap;
643         brush_t                 *brush;
644         
645         
646         /* start with bogus fog num */
647         fogNum = defaultFogNum;
648         
649         /* init */
650         bestVolume = 0.0f;
651         
652         /* walk the list of fog volumes */
653         for( i = 0; i < numMapFogs; i++ )
654         {
655                 /* sof2: global fog doesn't reference a brush */
656                 if( mapFogs[ i ].brush == NULL )
657                 {
658                         fogNum = i;
659                         continue;
660                 }
661                 
662                 /* get fog brush */
663                 brush = mapFogs[ i ].brush;
664                 
665                 /* get bounds */
666                 fogMins[ 0 ] = brush->mins[ 0 ] - epsilon;
667                 fogMins[ 1 ] = brush->mins[ 1 ] - epsilon;
668                 fogMins[ 2 ] = brush->mins[ 2 ] - epsilon;
669                 fogMaxs[ 0 ] = brush->maxs[ 0 ] + epsilon;
670                 fogMaxs[ 1 ] = brush->maxs[ 1 ] + epsilon;
671                 fogMaxs[ 2 ] = brush->maxs[ 2 ] + epsilon;
672                 
673                 /* check against bounds */
674                 for( j = 0; j < 3; j++ )
675                 {
676                         if( mins[ j ] > fogMaxs[ j ] || maxs[ j ] < fogMins[ j ] )
677                                 break;
678                         highMin = mins[ j ] > fogMins[ j ] ? mins[ j ] : fogMins[ j ];
679                         lowMax = maxs[ j ] < fogMaxs[ j ] ? maxs[ j ] : fogMaxs[ j ];
680                         overlap[ j ] = lowMax - highMin;
681                         if( overlap[ j ] < 1.0f )
682                                 overlap[ j ] = 1.0f;
683                 }
684                 
685                 /* no overlap */
686                 if( j < 3 )
687                         continue;
688                 
689                 /* get volume */
690                 volume = overlap[ 0 ] * overlap[ 1 ] * overlap[ 2 ];
691                 
692                 /* test against best volume */
693                 if( volume > bestVolume )
694                 {
695                         bestVolume = volume;
696                         fogNum = i;
697                 }
698         }
699         
700         /* if the point made it this far, it's not inside any fog volumes (or inside global fog) */
701         return fogNum;
702 }
703
704
705
706 /*
707 CreateMapFogs() - ydnar
708 generates a list of map fogs
709 */
710
711 void CreateMapFogs( void )
712 {
713         int                     i;
714         entity_t        *entity;
715         brush_t         *brush;
716         fog_t           *fog;
717         vec3_t          invFogDir;
718         const char      *globalFog;
719         
720         
721         /* skip? */
722         if( nofog )
723                 return;
724         
725         /* note it */
726         Sys_FPrintf( SYS_VRB, "--- CreateMapFogs ---\n" );
727         
728         /* walk entities */
729         for( i = 0; i < numEntities; i++ )
730         {
731                 /* get entity */
732                 entity = &entities[ i ];
733                 
734                 /* walk entity brushes */
735                 for( brush = entity->brushes; brush != NULL; brush = brush->next )
736                 {
737                         /* ignore non-fog brushes */
738                         if( brush->contentShader->fogParms == qfalse )
739                                 continue;
740                         
741                         /* test limit */
742                         if( numMapFogs >= MAX_MAP_FOGS )
743                                 Error( "Exceeded MAX_MAP_FOGS (%d)", MAX_MAP_FOGS );
744                         
745                         /* set up fog */
746                         fog = &mapFogs[ numMapFogs++ ];
747                         fog->si = brush->contentShader;
748                         fog->brush = brush;
749                         fog->visibleSide = -1;
750                         
751                         /* if shader specifies an explicit direction, then find a matching brush side with an opposed normal */
752                         if( VectorLength( fog->si->fogDir ) )
753                         {
754                                 /* flip it */
755                                 VectorScale( fog->si->fogDir, -1.0f, invFogDir );
756                                 
757                                 /* find the brush side */
758                                 for( i = 0; i < brush->numsides; i++ )
759                                 {
760                                         if( VectorCompare( invFogDir, mapplanes[ brush->sides[ i ].planenum ].normal ) )
761                                         {
762                                                 fog->visibleSide = i;
763                                                 //%     Sys_Printf( "Brush num: %d Side num: %d\n", fog->brushNum, fog->visibleSide );
764                                                 break;
765                                         }
766                                 }
767                         }
768                 }
769         }
770         
771         /* ydnar: global fog */
772         globalFog = ValueForKey( &entities[ 0 ], "_fog" );
773         if( globalFog[ 0 ] == '\0' )
774                 globalFog = ValueForKey( &entities[ 0 ], "fog" );
775         if( globalFog[ 0 ] != '\0' )
776         {
777                 /* test limit */
778                 if( numMapFogs >= MAX_MAP_FOGS )
779                         Error( "Exceeded MAX_MAP_FOGS (%d) trying to add global fog", MAX_MAP_FOGS );
780                 
781                 /* note it */
782                 Sys_FPrintf( SYS_VRB, "Map has global fog shader %s\n", globalFog );
783                 
784                 /* set up fog */
785                 fog = &mapFogs[ numMapFogs++ ];
786                 fog->si = ShaderInfoForShaderNull( globalFog );
787                 if( fog->si == NULL )
788                         Error( "Invalid shader \"%s\" referenced trying to add global fog", globalFog );
789                 fog->brush = NULL;
790                 fog->visibleSide = -1;
791                 
792                 /* set as default fog */
793                 defaultFogNum = numMapFogs - 1;
794                 
795                 /* mark all worldspawn brushes as fogged */
796                 for( brush = entities[ 0 ].brushes; brush != NULL; brush = brush->next )
797                         ApplySurfaceParm( "fog", &brush->contentFlags, NULL, &brush->compileFlags );
798         }
799         
800         /* emit some stats */
801         Sys_FPrintf( SYS_VRB, "%9d fogs\n", numMapFogs );
802 }
803