]> git.xonotic.org Git - xonotic/netradiant.git/blob - tools/quake3/q3map2/light.c
9f06cfd361e6955e61057dca3b81a58d1b6f7175
[xonotic/netradiant.git] / tools / quake3 / q3map2 / light.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 LIGHT_C
33
34
35
36 /* dependencies */
37 #include "q3map2.h"
38
39
40
41 /*
42 CreateSunLight() - ydnar
43 this creates a sun light
44 */
45
46 static void CreateSunLight( sun_t *sun )
47 {
48         int                     i;
49         float           photons, d, angle, elevation, da, de;
50         vec3_t          direction;
51         light_t         *light;
52         
53         
54         /* dummy check */
55         if( sun == NULL )
56                 return;
57         
58         /* fixup */
59         if( sun->numSamples < 1 )
60                 sun->numSamples = 1;
61         
62         /* set photons */
63         photons = sun->photons / sun->numSamples;
64         
65         /* create the right number of suns */
66         for( i = 0; i < sun->numSamples; i++ )
67         {
68                 /* calculate sun direction */
69                 if( i == 0 )
70                         VectorCopy( sun->direction, direction );
71                 else
72                 {
73                         /*
74                                 sun->direction[ 0 ] = cos( angle ) * cos( elevation );
75                                 sun->direction[ 1 ] = sin( angle ) * cos( elevation );
76                                 sun->direction[ 2 ] = sin( elevation );
77                                 
78                                 xz_dist   = sqrt( x*x + z*z )
79                                 latitude  = atan2( xz_dist, y ) * RADIANS
80                                 longitude = atan2( x,       z ) * RADIANS
81                         */
82                         
83                         d = sqrt( sun->direction[ 0 ] * sun->direction[ 0 ] + sun->direction[ 1 ] * sun->direction[ 1 ] );
84                         angle = atan2( sun->direction[ 1 ], sun->direction[ 0 ] );
85                         elevation = atan2( sun->direction[ 2 ], d );
86                         
87                         /* jitter the angles (loop to keep random sample within sun->deviance steridians) */
88                         do
89                         {
90                                 da = (Random() * 2.0f - 1.0f) * sun->deviance;
91                                 de = (Random() * 2.0f - 1.0f) * sun->deviance;
92                         }
93                         while( (da * da + de * de) > (sun->deviance * sun->deviance) );
94                         angle += da;
95                         elevation += de;
96                         
97                         /* debug code */
98                         //%     Sys_Printf( "%d: Angle: %3.4f Elevation: %3.3f\n", sun->numSamples, (angle / Q_PI * 180.0f), (elevation / Q_PI * 180.0f) );
99                         
100                         /* create new vector */
101                         direction[ 0 ] = cos( angle ) * cos( elevation );
102                         direction[ 1 ] = sin( angle ) * cos( elevation );
103                         direction[ 2 ] = sin( elevation );
104                 }
105                 
106                 /* create a light */
107                 numSunLights++;
108                 light = safe_malloc( sizeof( *light ) );
109                 memset( light, 0, sizeof( *light ) );
110                 light->next = lights;
111                 lights = light;
112                 
113                 /* initialize the light */
114                 light->flags = LIGHT_SUN_DEFAULT;
115                 light->type = EMIT_SUN;
116                 light->fade = 1.0f;
117                 light->falloffTolerance = falloffTolerance;
118                 light->filterRadius = sun->filterRadius / sun->numSamples;
119                 light->style = noStyles ? LS_NORMAL : sun->style;
120                 
121                 /* set the light's position out to infinity */
122                 VectorMA( vec3_origin, (MAX_WORLD_COORD * 8.0f), direction, light->origin );    /* MAX_WORLD_COORD * 2.0f */
123                 
124                 /* set the facing to be the inverse of the sun direction */
125                 VectorScale( direction, -1.0, light->normal );
126                 light->dist = DotProduct( light->origin, light->normal );
127                 
128                 /* set color and photons */
129                 VectorCopy( sun->color, light->color );
130                 light->photons = photons * skyScale;
131         }
132
133         /* another sun? */
134         if( sun->next != NULL )
135                 CreateSunLight( sun->next );
136 }
137
138
139
140 /*
141 CreateSkyLights() - ydnar
142 simulates sky light with multiple suns
143 */
144
145 static void CreateSkyLights( vec3_t color, float value, int iterations, float filterRadius, int style )
146 {
147         int                     i, j, numSuns;
148         int                     angleSteps, elevationSteps;
149         float           angle, elevation;
150         float           angleStep, elevationStep;
151         float           step, start;
152         sun_t           sun;
153         
154         
155         /* dummy check */
156         if( value <= 0.0f || iterations < 2 )
157                 return;
158         
159         /* calculate some stuff */
160         step = 2.0f / (iterations - 1);
161         start = -1.0f;
162         
163         /* basic sun setup */
164         VectorCopy( color, sun.color );
165         sun.deviance = 0.0f;
166         sun.filterRadius = filterRadius;
167         sun.numSamples = 1;
168         sun.style = noStyles ? LS_NORMAL : style;
169         sun.next = NULL;
170         
171         /* setup */
172         elevationSteps = iterations - 1;
173         angleSteps = elevationSteps * 4;
174         angle = 0.0f;
175         elevationStep = DEG2RAD( 90.0f / iterations );  /* skip elevation 0 */
176         angleStep = DEG2RAD( 360.0f / angleSteps );
177         
178         /* calc individual sun brightness */
179         numSuns = angleSteps * elevationSteps + 1;
180         sun.photons = value / numSuns;
181         
182         /* iterate elevation */
183         elevation = elevationStep * 0.5f;
184         angle = 0.0f;
185         for( i = 0, elevation = elevationStep * 0.5f; i < elevationSteps; i++ )
186         {
187                 /* iterate angle */
188                 for( j = 0; j < angleSteps; j++ )
189                 {
190                         /* create sun */
191                         sun.direction[ 0 ] = cos( angle ) * cos( elevation );
192                         sun.direction[ 1 ] = sin( angle ) * cos( elevation );
193                         sun.direction[ 2 ] = sin( elevation );
194                         CreateSunLight( &sun );
195                         
196                         /* move */
197                         angle += angleStep;
198                 }
199                         
200                 /* move */
201                 elevation += elevationStep;
202                 angle += angleStep / elevationSteps;
203         }
204         
205         /* create vertical sun */
206         VectorSet( sun.direction, 0.0f, 0.0f, 1.0f );
207         CreateSunLight( &sun );
208         
209         /* short circuit */
210         return;
211 }
212
213
214
215 /*
216 CreateEntityLights()
217 creates lights from light entities
218 */
219
220 void CreateEntityLights( void )
221 {
222         int                             i, j;
223         light_t                 *light, *light2;
224         entity_t                *e, *e2;
225         const char              *name;
226         const char              *target;
227         vec3_t                  dest;
228         const char              *_color;
229         float                   intensity, scale, deviance, filterRadius;
230         int                             spawnflags, flags, numSamples;
231         qboolean                junior;
232
233         
234         /* go throught entity list and find lights */
235         for( i = 0; i < numEntities; i++ )
236         {
237                 /* get entity */
238                 e = &entities[ i ];
239                 name = ValueForKey( e, "classname" );
240                 
241                 /* ydnar: check for lightJunior */
242                 if( Q_strncasecmp( name, "lightJunior", 11 ) == 0 )
243                         junior = qtrue;
244                 else if( Q_strncasecmp( name, "light", 5 ) == 0 )
245                         junior = qfalse;
246                 else
247                         continue;
248                 
249                 /* lights with target names (and therefore styles) are only parsed from BSP */
250                 target = ValueForKey( e, "targetname" );
251                 if( target[ 0 ] != '\0' && i >= numBSPEntities )
252                         continue;
253                 
254                 /* create a light */
255                 numPointLights++;
256                 light = safe_malloc( sizeof( *light ) );
257                 memset( light, 0, sizeof( *light ) );
258                 light->next = lights;
259                 lights = light;
260                 
261                 /* handle spawnflags */
262                 spawnflags = IntForKey( e, "spawnflags" );
263                 
264                 /* ydnar: quake 3+ light behavior */
265                 if( wolfLight == qfalse )
266                 {
267                         /* set default flags */
268                         flags = LIGHT_Q3A_DEFAULT;
269                         
270                         /* linear attenuation? */
271                         if( spawnflags & 1 )
272                         {
273                                 flags |= LIGHT_ATTEN_LINEAR;
274                                 flags &= ~LIGHT_ATTEN_ANGLE;
275                         }
276                         
277                         /* no angle attenuate? */
278                         if( spawnflags & 2 )
279                                 flags &= ~LIGHT_ATTEN_ANGLE;
280                 }
281                 
282                 /* ydnar: wolf light behavior */
283                 else
284                 {
285                         /* set default flags */
286                         flags = LIGHT_WOLF_DEFAULT;
287                         
288                         /* inverse distance squared attenuation? */
289                         if( spawnflags & 1 )
290                         {
291                                 flags &= ~LIGHT_ATTEN_LINEAR;
292                                 flags |= LIGHT_ATTEN_ANGLE;
293                         }
294                         
295                         /* angle attenuate? */
296                         if( spawnflags & 2 )
297                                 flags |= LIGHT_ATTEN_ANGLE;
298                 }
299                 
300                 /* other flags (borrowed from wolf) */
301                 
302                 /* wolf dark light? */
303                 if( (spawnflags & 4) || (spawnflags & 8) )
304                         flags |= LIGHT_DARK;
305                 
306                 /* nogrid? */
307                 if( spawnflags & 16 )
308                         flags &= ~LIGHT_GRID;
309                 
310                 /* junior? */
311                 if( junior )
312                 {
313                         flags |= LIGHT_GRID;
314                         flags &= ~LIGHT_SURFACES;
315                 }
316
317                 /* vortex: unnormalized? */
318                 if (spawnflags & 32)
319                         flags |= LIGHT_UNNORMALIZED;
320
321                 /* vortex: distance atten? */
322                 if (spawnflags & 64)
323                         flags |= LIGHT_ATTEN_DISTANCE;
324
325                 /* store the flags */
326                 light->flags = flags;
327                 
328                 /* ydnar: set fade key (from wolf) */
329                 light->fade = 1.0f;
330                 if( light->flags & LIGHT_ATTEN_LINEAR )
331                 {
332                         light->fade = FloatForKey( e, "fade" );
333                         if( light->fade == 0.0f )
334                                 light->fade = 1.0f;
335                 }
336                 
337                 /* ydnar: set angle scaling (from vlight) */
338                 light->angleScale = FloatForKey( e, "_anglescale" );
339                 if( light->angleScale != 0.0f )
340                         light->flags |= LIGHT_ATTEN_ANGLE;
341                 
342                 /* set origin */
343                 GetVectorForKey( e, "origin", light->origin);
344                 light->style = IntForKey( e, "_style" );
345                 if( light->style == LS_NORMAL )
346                         light->style = IntForKey( e, "style" );
347                 if( light->style < LS_NORMAL || light->style >= LS_NONE )
348                         Error( "Invalid lightstyle (%d) on entity %d", light->style, i );
349                 
350                 if( light->style != LS_NORMAL ) {
351                         Sys_FPrintf (SYS_WRN, "WARNING: Styled light found targeting %s\n **", target );
352                 }
353
354                 /* set light intensity */
355                 intensity = FloatForKey( e, "_light" );
356                 if( intensity == 0.0f )
357                         intensity = FloatForKey( e, "light" );
358                 if( intensity == 0.0f)
359                         intensity = 300.0f;
360                 
361                 /* ydnar: set light scale (sof2) */
362                 scale = FloatForKey( e, "scale" );
363                 if( scale == 0.0f )
364                         scale = 1.0f;
365                 intensity *= scale;
366                 
367                 /* ydnar: get deviance and samples */
368                 deviance = FloatForKey( e, "_deviance" );
369                 if( deviance == 0.0f )
370                         deviance = FloatForKey( e, "_deviation" );
371                 if( deviance == 0.0f )
372                         deviance = FloatForKey( e, "_jitter" );
373                 numSamples = IntForKey( e, "_samples" );
374                 if( deviance < 0.0f || numSamples < 1 )
375                 {
376                         deviance = 0.0f;
377                         numSamples = 1;
378                 }
379                 intensity /= numSamples;
380                 
381                 /* ydnar: get filter radius */
382                 filterRadius = FloatForKey( e, "_filterradius" );
383                 if( filterRadius == 0.0f )
384                         filterRadius = FloatForKey( e, "_filteradius" );
385                 if( filterRadius == 0.0f )
386                         filterRadius = FloatForKey( e, "_filter" );
387                 if( filterRadius < 0.0f )
388                         filterRadius = 0.0f;
389                 light->filterRadius = filterRadius;
390                 
391                 /* set light color */
392                 _color = ValueForKey( e, "_color" );
393                 if( _color && _color[ 0 ] )
394                 {
395                         sscanf( _color, "%f %f %f", &light->color[ 0 ], &light->color[ 1 ], &light->color[ 2 ] );
396                         if (!(light->flags & LIGHT_UNNORMALIZED))
397                         {
398                                 ColorNormalize( light->color, light->color );
399                         }
400                 }
401                 else
402                         light->color[ 0 ] = light->color[ 1 ] = light->color[ 2 ] = 1.0f;
403
404                 intensity = intensity * pointScale;
405                 light->photons = intensity;
406
407                 light->type = EMIT_POINT;
408                 
409                 /* set falloff threshold */
410                 light->falloffTolerance = falloffTolerance / numSamples;
411                 
412                 /* lights with a target will be spotlights */
413                 target = ValueForKey( e, "target" );
414                 if( target[ 0 ] )
415                 {
416                         float           radius;
417                         float           dist;
418                         sun_t           sun;
419                         const char      *_sun;
420                         
421                         
422                         /* get target */
423                         e2 = FindTargetEntity( target );
424                         if( e2 == NULL )
425                         {
426                                 Sys_Printf( "WARNING: light at (%i %i %i) has missing target\n",
427                                         (int) light->origin[ 0 ], (int) light->origin[ 1 ], (int) light->origin[ 2 ] );
428                         }
429                         else
430                         {
431                                 /* not a point light */
432                                 numPointLights--;
433                                 numSpotLights++;
434                                 
435                                 /* make a spotlight */
436                                 GetVectorForKey( e2, "origin", dest );
437                                 VectorSubtract( dest, light->origin, light->normal );
438                                 dist = VectorNormalize( light->normal, light->normal );
439                                 radius = FloatForKey( e, "radius" );
440                                 if( !radius )
441                                         radius = 64;
442                                 if( !dist )
443                                         dist = 64;
444                                 light->radiusByDist = (radius + 16) / dist;
445                                 light->type = EMIT_SPOT;
446                                 
447                                 /* ydnar: wolf mods: spotlights always use nonlinear + angle attenuation */
448                                 light->flags &= ~LIGHT_ATTEN_LINEAR;
449                                 light->flags |= LIGHT_ATTEN_ANGLE;
450                                 light->fade = 1.0f;
451                                 
452                                 /* ydnar: is this a sun? */
453                                 _sun = ValueForKey( e, "_sun" );
454                                 if( _sun[ 0 ] == '1' )
455                                 {
456                                         /* not a spot light */
457                                         numSpotLights--;
458                                         
459                                         /* unlink this light */
460                                         lights = light->next;
461                                         
462                                         /* make a sun */
463                                         VectorScale( light->normal, -1.0f, sun.direction );
464                                         VectorCopy( light->color, sun.color );
465                                         sun.photons = (intensity / pointScale);
466                                         sun.deviance = deviance / 180.0f * Q_PI;
467                                         sun.numSamples = numSamples;
468                                         sun.style = noStyles ? LS_NORMAL : light->style;
469                                         sun.next = NULL;
470                                         
471                                         /* make a sun light */
472                                         CreateSunLight( &sun );
473                                         
474                                         /* free original light */
475                                         free( light );
476                                         light = NULL;
477                                         
478                                         /* skip the rest of this love story */
479                                         continue;
480                                 }
481                         }
482                 }
483                 
484                 /* jitter the light */
485                 for( j = 1; j < numSamples; j++ )
486                 {
487                         /* create a light */
488                         light2 = safe_malloc( sizeof( *light ) );
489                         memcpy( light2, light, sizeof( *light ) );
490                         light2->next = lights;
491                         lights = light2;
492                         
493                         /* add to counts */
494                         if( light->type == EMIT_SPOT )
495                                 numSpotLights++;
496                         else
497                                 numPointLights++;
498                         
499                         /* jitter it */
500                         light2->origin[ 0 ] = light->origin[ 0 ] + (Random() * 2.0f - 1.0f) * deviance;
501                         light2->origin[ 1 ] = light->origin[ 1 ] + (Random() * 2.0f - 1.0f) * deviance;
502                         light2->origin[ 2 ] = light->origin[ 2 ] + (Random() * 2.0f - 1.0f) * deviance;
503                 }
504         }
505 }
506
507
508
509 /*
510 CreateSurfaceLights() - ydnar
511 this hijacks the radiosity code to generate surface lights for first pass
512 */
513
514 #define APPROX_BOUNCE   1.0f
515
516 void CreateSurfaceLights( void )
517 {
518         int                                     i;
519         bspDrawSurface_t        *ds;
520         surfaceInfo_t           *info;
521         shaderInfo_t            *si;
522         light_t                         *light;
523         float                           subdivide;
524         vec3_t                          origin;
525         clipWork_t                      cw;
526         const char                      *nss;
527         
528         
529         /* get sun shader supressor */
530         nss = ValueForKey( &entities[ 0 ], "_noshadersun" );
531         
532         /* walk the list of surfaces */
533         for( i = 0; i < numBSPDrawSurfaces; i++ )
534         {
535                 /* get surface and other bits */
536                 ds = &bspDrawSurfaces[ i ];
537                 info = &surfaceInfos[ i ];
538                 si = info->si;
539                 
540                 /* sunlight? */
541                 if( si->sun != NULL && nss[ 0 ] != '1' )
542                 {
543                         Sys_FPrintf( SYS_VRB, "Sun: %s\n", si->shader );
544                         CreateSunLight( si->sun );
545                         si->sun = NULL; /* FIXME: leak! */
546                 }
547                 
548                 /* sky light? */
549                 if( si->skyLightValue > 0.0f )
550                 {
551                         Sys_FPrintf( SYS_VRB, "Sky: %s\n", si->shader );
552                         CreateSkyLights( si->color, si->skyLightValue, si->skyLightIterations, si->lightFilterRadius, si->lightStyle );
553                         si->skyLightValue = 0.0f;       /* FIXME: hack! */
554                 }
555                 
556                 /* try to early out */
557                 if( si->value <= 0 )
558                         continue;
559                 
560                 /* autosprite shaders become point lights */
561                 if( si->autosprite )
562                 {
563                         /* create an average xyz */
564                         VectorAdd( info->mins, info->maxs, origin );
565                         VectorScale( origin, 0.5f, origin );
566                         
567                         /* create a light */
568                         light = safe_malloc( sizeof( *light ) );
569                         memset( light, 0, sizeof( *light ) );
570                         light->next = lights;
571                         lights = light;
572                         
573                         /* set it up */
574                         light->flags = LIGHT_Q3A_DEFAULT;
575                         light->type = EMIT_POINT;
576                         light->photons = si->value * pointScale;
577                         light->fade = 1.0f;
578                         light->si = si;
579                         VectorCopy( origin, light->origin );
580                         VectorCopy( si->color, light->color );
581                         light->falloffTolerance = falloffTolerance;
582                         light->style = si->lightStyle;
583                         
584                         /* add to point light count and continue */
585                         numPointLights++;
586                         continue;
587                 }
588                 
589                 /* get subdivision amount */
590                 if( si->lightSubdivide > 0 )
591                         subdivide = si->lightSubdivide;
592                 else
593                         subdivide = defaultLightSubdivide;
594                 
595                 /* switch on type */
596                 switch( ds->surfaceType )
597                 {
598                         case MST_PLANAR:
599                         case MST_TRIANGLE_SOUP:
600                                 RadLightForTriangles( i, 0, info->lm, si, APPROX_BOUNCE, subdivide, &cw );
601                                 break;
602                         
603                         case MST_PATCH:
604                                 RadLightForPatch( i, 0, info->lm, si, APPROX_BOUNCE, subdivide, &cw );
605                                 break;
606                         
607                         default:
608                                 break;
609                 }
610         }
611 }
612
613
614
615 /*
616 SetEntityOrigins()
617 find the offset values for inline models
618 */
619
620 void SetEntityOrigins( void )
621 {
622         int                                     i, j, k, f;
623         entity_t                        *e;
624         vec3_t                          origin;
625         const char                      *key;
626         int                                     modelnum;
627         bspModel_t                      *dm;
628         bspDrawSurface_t        *ds;
629         
630         
631         /* ydnar: copy drawverts into private storage for nefarious purposes */
632         yDrawVerts = safe_malloc( numBSPDrawVerts * sizeof( bspDrawVert_t ) );
633         memcpy( yDrawVerts, bspDrawVerts, numBSPDrawVerts * sizeof( bspDrawVert_t ) );
634         
635         /* set the entity origins */
636         for( i = 0; i < numEntities; i++ )
637         {
638                 /* get entity and model */
639                 e = &entities[ i ];
640                 key = ValueForKey( e, "model" );
641                 if( key[ 0 ] != '*' )
642                         continue;
643                 modelnum = atoi( key + 1 );
644                 dm = &bspModels[ modelnum ];
645                 
646                 /* get entity origin */
647                 key = ValueForKey( e, "origin" );
648                 if( key[ 0 ] == '\0' )
649                         continue;
650                 GetVectorForKey( e, "origin", origin );
651                 
652                 /* set origin for all surfaces for this model */
653                 for( j = 0; j < dm->numBSPSurfaces; j++ )
654                 {
655                         /* get drawsurf */
656                         ds = &bspDrawSurfaces[ dm->firstBSPSurface + j ];
657                         
658                         /* set its verts */
659                         for( k = 0; k < ds->numVerts; k++ )
660                         {
661                                 f = ds->firstVert + k;
662                                 VectorAdd( origin, bspDrawVerts[ f ].xyz, yDrawVerts[ f ].xyz );
663                         }
664                 }
665         }
666 }
667
668
669
670 /*
671 PointToPolygonFormFactor()
672 calculates the area over a point/normal hemisphere a winding covers
673 ydnar: fixme: there has to be a faster way to calculate this
674 without the expensive per-vert sqrts and transcendental functions
675 ydnar 2002-09-30: added -faster switch because only 19% deviance > 10%
676 between this and the approximation
677 */
678
679 #define ONE_OVER_2PI    0.159154942f    //% (1.0f / (2.0f * 3.141592657f))
680
681 float PointToPolygonFormFactor( const vec3_t point, const vec3_t normal, const winding_t *w )
682 {
683         vec3_t          triVector, triNormal;
684         int                     i, j;
685         vec3_t          dirs[ MAX_POINTS_ON_WINDING ];
686         float           total;
687         float           dot, angle, facing;
688         
689         
690         /* this is expensive */
691         for( i = 0; i < w->numpoints; i++ )
692         {
693                 VectorSubtract( w->p[ i ], point, dirs[ i ] );
694                 VectorNormalize( dirs[ i ], dirs[ i ] );
695         }
696         
697         /* duplicate first vertex to avoid mod operation */
698         VectorCopy( dirs[ 0 ], dirs[ i ] );
699         
700         /* calculcate relative area */
701         total = 0.0f;
702         for( i = 0; i < w->numpoints; i++ )
703         {
704                 /* get a triangle */
705                 j = i + 1;
706                 dot = DotProduct( dirs[ i ], dirs[ j ] );
707                 
708                 /* roundoff can cause slight creep, which gives an IND from acos */
709                 if( dot > 1.0f )
710                         dot = 1.0f;
711                 else if( dot < -1.0f )
712                         dot = -1.0f;
713                 
714                 /* get the angle */
715                 angle = acos( dot );
716                 
717                 CrossProduct( dirs[ i ], dirs[ j ], triVector );
718                 if( VectorNormalize( triVector, triNormal ) < 0.0001f )
719                         continue;
720                 
721                 facing = DotProduct( normal, triNormal );
722                 total += facing * angle;
723                 
724                 /* ydnar: this was throwing too many errors with radiosity + crappy maps. ignoring it. */
725                 if( total > 6.3f || total < -6.3f )
726                         return 0.0f;
727         }
728         
729         /* now in the range of 0 to 1 over the entire incoming hemisphere */
730         //%     total /= (2.0f * 3.141592657f);
731         total *= ONE_OVER_2PI;
732         return total;
733 }
734
735
736
737 /*
738 LightContributionTosample()
739 determines the amount of light reaching a sample (luxel or vertex) from a given light
740 */
741
742 int LightContributionToSample( trace_t *trace )
743 {
744         light_t                 *light;
745         float                   angle;
746         float                   add;
747         float                   dist;
748         
749         
750         /* get light */
751         light = trace->light;
752         
753         /* clear color */
754         VectorClear( trace->color );
755         VectorClear( trace->colorNoShadow );
756         
757         /* ydnar: early out */
758         if( !(light->flags & LIGHT_SURFACES) || light->envelope <= 0.0f )
759                 return 0;
760         
761         /* do some culling checks */
762         if( light->type != EMIT_SUN )
763         {
764                 /* MrE: if the light is behind the surface */
765                 if( trace->twoSided == qfalse )
766                         if( DotProduct( light->origin, trace->normal ) - DotProduct( trace->origin, trace->normal ) < 0.0f )
767                                 return 0;
768                 
769                 /* ydnar: test pvs */
770                 if( !ClusterVisible( trace->cluster, light->cluster ) )
771                         return 0;
772         }
773         
774         /* exact point to polygon form factor */
775         if( light->type == EMIT_AREA )
776         {
777                 float           factor;
778                 float           d;
779                 vec3_t          pushedOrigin;
780                 
781                 /* project sample point into light plane */
782                 d = DotProduct( trace->origin, light->normal ) - light->dist;
783                 if( d < 3.0f )
784                 {
785                         /* sample point behind plane? */
786                         if( !(light->flags & LIGHT_TWOSIDED) && d < -1.0f )
787                                 return 0;
788                         
789                         /* sample plane coincident? */
790                         if( d > -3.0f && DotProduct( trace->normal, light->normal ) > 0.9f )
791                                 return 0;
792                 }
793                 
794                 /* nudge the point so that it is clearly forward of the light */
795                 /* so that surfaces meeting a light emiter don't get black edges */
796                 if( d > -8.0f && d < 8.0f )
797                         VectorMA( trace->origin, (8.0f - d), light->normal, pushedOrigin );                             
798                 else
799                         VectorCopy( trace->origin, pushedOrigin );
800                 
801                 /* get direction and distance */
802                 VectorCopy( light->origin, trace->end );
803                 dist = SetupTrace( trace );
804                 if( dist >= light->envelope )
805                         return 0;
806                 
807                 /* ptpff approximation */
808                 if( faster )
809                 {
810                         /* angle attenuation */
811                         angle = DotProduct( trace->normal, trace->direction );
812                         
813                         /* twosided lighting */
814                         if( trace->twoSided )
815                                 angle = fabs( angle );
816                         
817                         /* attenuate */
818                         angle *= -DotProduct( light->normal, trace->direction );
819                         if( angle == 0.0f )
820                                 return 0;
821                         else if( angle < 0.0f &&
822                                 (trace->twoSided || (light->flags & LIGHT_TWOSIDED)) )
823                                 angle = -angle;
824                         add = light->photons / (dist * dist) * angle;
825                 }
826                 else
827                 {
828                         /* calculate the contribution */
829                         factor = PointToPolygonFormFactor( pushedOrigin, trace->normal, light->w );
830                         if( factor == 0.0f )
831                                 return 0;
832                         else if( factor < 0.0f )
833                         {
834                                 /* twosided lighting */
835                                 if( trace->twoSided || (light->flags & LIGHT_TWOSIDED) )
836                                 {
837                                         factor = -factor;
838
839                                         /* push light origin to other side of the plane */
840                                         VectorMA( light->origin, -2.0f, light->normal, trace->end );
841                                         dist = SetupTrace( trace );
842                                         if( dist >= light->envelope )
843                                                 return 0;
844                                 }
845                                 else
846                                         return 0;
847                         }
848                         
849                         /* ydnar: moved to here */
850                         add = factor * light->add;
851                 }
852         }
853         
854         /* point/spot lights */
855         else if( light->type == EMIT_POINT || light->type == EMIT_SPOT )
856         {
857                 /* get direction and distance */
858                 VectorCopy( light->origin, trace->end );
859                 dist = SetupTrace( trace );
860                 if( dist >= light->envelope )
861                         return 0;
862                 
863                 /* clamp the distance to prevent super hot spots */
864                 if( dist < 16.0f )
865                         dist = 16.0f;
866                 
867                 /* angle attenuation */
868                 angle = (light->flags & LIGHT_ATTEN_ANGLE) ? DotProduct( trace->normal, trace->direction ) : 1.0f;
869                 if( light->angleScale != 0.0f )
870                 {
871                         angle /= light->angleScale;
872                         if( angle > 1.0f )
873                                 angle = 1.0f;
874                 }
875                 
876                 /* twosided lighting */
877                 if( trace->twoSided )
878                         angle = fabs( angle );
879                 
880                 /* attenuate */
881                 if( light->flags & LIGHT_ATTEN_LINEAR )
882                 {
883                         add = angle * light->photons * linearScale - (dist * light->fade);
884                         if( add < 0.0f )
885                                 add = 0.0f;
886                 }
887                 else
888                         add = light->photons / (dist * dist) * angle;
889                 
890                 /* handle spotlights */
891                 if( light->type == EMIT_SPOT )
892                 {
893                         float   distByNormal, radiusAtDist, sampleRadius;
894                         vec3_t  pointAtDist, distToSample;
895         
896                         /* do cone calculation */
897                         distByNormal = -DotProduct( trace->displacement, light->normal );
898                         if( distByNormal < 0.0f )
899                                 return 0;
900                         VectorMA( light->origin, distByNormal, light->normal, pointAtDist );
901                         radiusAtDist = light->radiusByDist * distByNormal;
902                         VectorSubtract( trace->origin, pointAtDist, distToSample );
903                         sampleRadius = VectorLength( distToSample );
904                         
905                         /* outside the cone */
906                         if( sampleRadius >= radiusAtDist )
907                                 return 0;
908                         
909                         /* attenuate */
910                         if( sampleRadius > (radiusAtDist - 32.0f) )
911                                 add *= ((radiusAtDist - sampleRadius) / 32.0f);
912                 }
913         }
914         
915         /* ydnar: sunlight */
916         else if( light->type == EMIT_SUN )
917         {
918                 /* get origin and direction */
919                 VectorAdd( trace->origin, light->origin, trace->end );
920                 dist = SetupTrace( trace );
921                 
922                 /* angle attenuation */
923                 angle = (light->flags & LIGHT_ATTEN_ANGLE)
924                         ? DotProduct( trace->normal, trace->direction )
925                         : 1.0f;
926                 
927                 /* twosided lighting */
928                 if( trace->twoSided )
929                         angle = fabs( angle );
930                 
931                 /* attenuate */
932                 add = light->photons * angle;
933                 if( add <= 0.0f )
934                         return 0;
935
936                 /* VorteX: set noShadow color */
937                 VectorScale(light->color, add, trace->colorNoShadow);
938                 
939                 /* setup trace */
940                 trace->testAll = qtrue;
941                 VectorScale( light->color, add, trace->color );
942                 
943                 /* trace to point */
944                 if( trace->testOcclusion && !trace->forceSunlight )
945                 {
946                         /* trace */
947                         TraceLine( trace );
948                         if( !(trace->compileFlags & C_SKY) || trace->opaque )
949                         {
950                                 VectorClear( trace->color );
951                                 return -1;
952                         }
953                 }
954                 
955                 /* return to sender */
956                 return 1;
957         }
958
959         /* VorteX: set noShadow color */
960         VectorScale(light->color, add, trace->colorNoShadow);
961         
962         /* ydnar: changed to a variable number */
963         if( add <= 0.0f || (add <= light->falloffTolerance && (light->flags & LIGHT_FAST_ACTUAL)) )
964                 return 0;
965         
966         /* setup trace */
967         trace->testAll = qfalse;
968         VectorScale( light->color, add, trace->color );
969         
970         /* raytrace */
971         TraceLine( trace );
972         if( trace->passSolid || trace->opaque )
973         {
974                 VectorClear( trace->color );
975                 return -1;
976         }
977         
978         /* return to sender */
979         return 1;
980 }
981
982
983
984 /*
985 LightingAtSample()
986 determines the amount of light reaching a sample (luxel or vertex)
987 */
988
989 void LightingAtSample( trace_t *trace, byte styles[ MAX_LIGHTMAPS ], vec3_t colors[ MAX_LIGHTMAPS ] )
990 {
991         int                             i, lightmapNum;
992         
993         
994         /* clear colors */
995         for( lightmapNum = 0; lightmapNum < MAX_LIGHTMAPS; lightmapNum++ )
996                 VectorClear( colors[ lightmapNum ] );
997         
998         /* ydnar: normalmap */
999         if( normalmap )
1000         {
1001                 colors[ 0 ][ 0 ] = (trace->normal[ 0 ] + 1.0f) * 127.5f;
1002                 colors[ 0 ][ 1 ] = (trace->normal[ 1 ] + 1.0f) * 127.5f;
1003                 colors[ 0 ][ 2 ] = (trace->normal[ 2 ] + 1.0f) * 127.5f;
1004                 return;
1005         }
1006         
1007         /* ydnar: don't bounce ambient all the time */
1008         if( !bouncing )
1009                 VectorCopy( ambientColor, colors[ 0 ] );
1010         
1011         /* ydnar: trace to all the list of lights pre-stored in tw */
1012         for( i = 0; i < trace->numLights && trace->lights[ i ] != NULL; i++ )
1013         {
1014                 /* set light */
1015                 trace->light = trace->lights[ i ];
1016                 
1017                 /* style check */
1018                 for( lightmapNum = 0; lightmapNum < MAX_LIGHTMAPS; lightmapNum++ )
1019                 {
1020                         if( styles[ lightmapNum ] == trace->light->style ||
1021                                 styles[ lightmapNum ] == LS_NONE )
1022                                 break;
1023                 }
1024                 
1025                 /* max of MAX_LIGHTMAPS (4) styles allowed to hit a sample */
1026                 if( lightmapNum >= MAX_LIGHTMAPS )
1027                         continue;
1028                 
1029                 /* sample light */
1030                 LightContributionToSample( trace );
1031                 if( trace->color[ 0 ] == 0.0f && trace->color[ 1 ] == 0.0f && trace->color[ 2 ] == 0.0f )
1032                         continue;
1033                 
1034                 /* handle negative light */
1035                 if( trace->light->flags & LIGHT_NEGATIVE )
1036                         VectorScale( trace->color, -1.0f, trace->color );
1037                 
1038                 /* set style */
1039                 styles[ lightmapNum ] = trace->light->style;
1040                 
1041                 /* add it */
1042                 VectorAdd( colors[ lightmapNum ], trace->color, colors[ lightmapNum ] );
1043                 
1044                 /* cheap mode */
1045                 if( cheap &&
1046                         colors[ 0 ][ 0 ] >= 255.0f &&
1047                         colors[ 0 ][ 1 ] >= 255.0f &&
1048                         colors[ 0 ][ 2 ] >= 255.0f )
1049                         break;
1050         }
1051 }
1052
1053
1054
1055 /*
1056 LightContributionToPoint()
1057 for a given light, how much light/color reaches a given point in space (with no facing)
1058 note: this is similar to LightContributionToSample() but optimized for omnidirectional sampling
1059 */
1060
1061 int LightContributionToPoint( trace_t *trace )
1062 {
1063         light_t         *light;
1064         float           add, dist;
1065         
1066         
1067         /* get light */
1068         light = trace->light;
1069         
1070         /* clear color */
1071         VectorClear( trace->color );
1072         
1073         /* ydnar: early out */
1074         if( !(light->flags & LIGHT_GRID) || light->envelope <= 0.0f )
1075                 return qfalse;
1076         
1077         /* is this a sun? */
1078         if( light->type != EMIT_SUN )
1079         {
1080                 /* sun only? */
1081                 if( sunOnly )
1082                         return qfalse;
1083                 
1084                 /* test pvs */
1085                 if( !ClusterVisible( trace->cluster, light->cluster ) )
1086                         return qfalse;
1087         }
1088         
1089         /* ydnar: check origin against light's pvs envelope */
1090         if( trace->origin[ 0 ] > light->maxs[ 0 ] || trace->origin[ 0 ] < light->mins[ 0 ] ||
1091                 trace->origin[ 1 ] > light->maxs[ 1 ] || trace->origin[ 1 ] < light->mins[ 1 ] ||
1092                 trace->origin[ 2 ] > light->maxs[ 2 ] || trace->origin[ 2 ] < light->mins[ 2 ] )
1093         {
1094                 gridBoundsCulled++;
1095                 return qfalse;
1096         }
1097         
1098         /* set light origin */
1099         if( light->type == EMIT_SUN )
1100                 VectorAdd( trace->origin, light->origin, trace->end );
1101         else
1102                 VectorCopy( light->origin, trace->end );
1103         
1104         /* set direction */
1105         dist = SetupTrace( trace );
1106         
1107         /* test envelope */
1108         if( dist > light->envelope )
1109         {
1110                 gridEnvelopeCulled++;
1111                 return qfalse;
1112         }
1113         
1114         /* ptpff approximation */
1115         if( light->type == EMIT_AREA && faster )
1116         {
1117                 /* clamp the distance to prevent super hot spots */
1118                 if( dist < 16.0f )
1119                         dist = 16.0f;
1120                 
1121                 /* attenuate */
1122                 add = light->photons / (dist * dist);
1123         }
1124         
1125         /* exact point to polygon form factor */
1126         else if( light->type == EMIT_AREA )
1127         {
1128                 float           factor, d;
1129                 vec3_t          pushedOrigin;
1130                 
1131                 
1132                 /* see if the point is behind the light */
1133                 d = DotProduct( trace->origin, light->normal ) - light->dist;
1134                 if( !(light->flags & LIGHT_TWOSIDED) && d < -1.0f )
1135                         return qfalse;
1136                 
1137                 /* nudge the point so that it is clearly forward of the light */
1138                 /* so that surfaces meeting a light emiter don't get black edges */
1139                 if( d > -8.0f && d < 8.0f )
1140                         VectorMA( trace->origin, (8.0f - d), light->normal, pushedOrigin );                             
1141                 else
1142                         VectorCopy( trace->origin, pushedOrigin );
1143                 
1144                 /* calculate the contribution (ydnar 2002-10-21: [bug 642] bad normal calc) */
1145                 factor = PointToPolygonFormFactor( pushedOrigin, trace->direction, light->w );
1146                 if( factor == 0.0f )
1147                         return qfalse;
1148                 else if( factor < 0.0f )
1149                 {
1150                         if( light->flags & LIGHT_TWOSIDED )
1151                                 factor = -factor;
1152                         else
1153                                 return qfalse;
1154                 }
1155                 
1156                 /* ydnar: moved to here */
1157                 add = factor * light->add;
1158         }
1159         
1160         /* point/spot lights */
1161         else if( light->type == EMIT_POINT || light->type == EMIT_SPOT )
1162         {
1163                 /* clamp the distance to prevent super hot spots */
1164                 if( dist < 16.0f )
1165                         dist = 16.0f;
1166                 
1167                 /* attenuate */
1168                 if( light->flags & LIGHT_ATTEN_LINEAR )
1169                 {
1170                         add = light->photons * linearScale - (dist * light->fade);
1171                         if( add < 0.0f )
1172                                 add = 0.0f;
1173                 }
1174                 else
1175                         add = light->photons / (dist * dist);
1176                 
1177                 /* handle spotlights */
1178                 if( light->type == EMIT_SPOT )
1179                 {
1180                         float   distByNormal, radiusAtDist, sampleRadius;
1181                         vec3_t  pointAtDist, distToSample;
1182                         
1183                         
1184                         /* do cone calculation */
1185                         distByNormal = -DotProduct( trace->displacement, light->normal );
1186                         if( distByNormal < 0.0f )
1187                                 return qfalse;
1188                         VectorMA( light->origin, distByNormal, light->normal, pointAtDist );
1189                         radiusAtDist = light->radiusByDist * distByNormal;
1190                         VectorSubtract( trace->origin, pointAtDist, distToSample );
1191                         sampleRadius = VectorLength( distToSample );
1192                         
1193                         /* outside the cone */
1194                         if( sampleRadius >= radiusAtDist )
1195                                 return qfalse;
1196                         
1197                         /* attenuate */
1198                         if( sampleRadius > (radiusAtDist - 32.0f) )
1199                                 add *= ((radiusAtDist - sampleRadius) / 32.0f);
1200                 }
1201         }
1202         
1203         /* ydnar: sunlight */
1204         else if( light->type == EMIT_SUN )
1205         {
1206                 /* attenuate */
1207                 add = light->photons;
1208                 if( add <= 0.0f )
1209                         return qfalse;
1210                 
1211                 /* setup trace */
1212                 trace->testAll = qtrue;
1213                 VectorScale( light->color, add, trace->color );
1214                 
1215                 /* trace to point */
1216                 if( trace->testOcclusion && !trace->forceSunlight )
1217                 {
1218                         /* trace */
1219                         TraceLine( trace );
1220                         if( !(trace->compileFlags & C_SKY) || trace->opaque )
1221                         {
1222                                 VectorClear( trace->color );
1223                                 return -1;
1224                         }
1225                 }
1226                 
1227                 /* return to sender */
1228                 return qtrue;
1229         }
1230         
1231         /* unknown light type */
1232         else
1233                 return qfalse;
1234         
1235         /* ydnar: changed to a variable number */
1236         if( add <= 0.0f || (add <= light->falloffTolerance && (light->flags & LIGHT_FAST_ACTUAL)) )
1237                 return qfalse;
1238         
1239         /* setup trace */
1240         trace->testAll = qfalse;
1241         VectorScale( light->color, add, trace->color );
1242         
1243         /* trace */
1244         TraceLine( trace );
1245         if( trace->passSolid )
1246         {
1247                 VectorClear( trace->color );
1248                 return qfalse;
1249         }
1250         
1251         /* we have a valid sample */
1252         return qtrue;
1253 }
1254
1255
1256
1257 /*
1258 TraceGrid()
1259 grid samples are for quickly determining the lighting
1260 of dynamically placed entities in the world
1261 */
1262
1263 #define MAX_CONTRIBUTIONS       32768
1264
1265 typedef struct
1266 {
1267         vec3_t          dir;
1268         vec3_t          color;
1269         int                     style;
1270 }
1271 contribution_t;
1272
1273 void TraceGrid( int num )
1274 {
1275         int                                             i, j, x, y, z, mod, step, numCon, numStyles;
1276         float                                   d;
1277         vec3_t                                  baseOrigin, cheapColor, color;
1278         rawGridPoint_t                  *gp;
1279         bspGridPoint_t                  *bgp;
1280         contribution_t                  contributions[ MAX_CONTRIBUTIONS ];
1281         trace_t                                 trace;
1282         
1283         
1284         /* get grid points */
1285         gp = &rawGridPoints[ num ];
1286         bgp = &bspGridPoints[ num ];
1287         
1288         /* get grid origin */
1289         mod = num;
1290         z = mod / (gridBounds[ 0 ] * gridBounds[ 1 ]);
1291         mod -= z * (gridBounds[ 0 ] * gridBounds[ 1 ]);
1292         y = mod / gridBounds[ 0 ];
1293         mod -= y * gridBounds[ 0 ];
1294         x = mod;
1295         
1296         trace.origin[ 0 ] = gridMins[ 0 ] + x * gridSize[ 0 ];
1297         trace.origin[ 1 ] = gridMins[ 1 ] + y * gridSize[ 1 ];
1298         trace.origin[ 2 ] = gridMins[ 2 ] + z * gridSize[ 2 ];
1299         
1300         /* set inhibit sphere */
1301         if( gridSize[ 0 ] > gridSize[ 1 ] && gridSize[ 0 ] > gridSize[ 2 ] )
1302                 trace.inhibitRadius = gridSize[ 0 ] * 0.5f;
1303         else if( gridSize[ 1 ] > gridSize[ 0 ] && gridSize[ 1 ] > gridSize[ 2 ] )
1304                 trace.inhibitRadius = gridSize[ 1 ] * 0.5f;
1305         else
1306                 trace.inhibitRadius = gridSize[ 2 ] * 0.5f;
1307         
1308         /* find point cluster */
1309         trace.cluster = ClusterForPointExt( trace.origin, GRID_EPSILON );
1310         if( trace.cluster < 0 )
1311         {
1312                 /* try to nudge the origin around to find a valid point */
1313                 VectorCopy( trace.origin, baseOrigin );
1314                 for( step = 9; step <= 18; step += 9 )
1315                 {
1316                         for( i = 0; i < 8; i++ )
1317                         {
1318                                 VectorCopy( baseOrigin, trace.origin );
1319                                 if( i & 1 )
1320                                         trace.origin[ 0 ] += step;
1321                                 else
1322                                         trace.origin[ 0 ] -= step;
1323                                 
1324                                 if( i & 2 )
1325                                         trace.origin[ 1 ] += step;
1326                                 else
1327                                         trace.origin[ 1 ] -= step;
1328                                 
1329                                 if( i & 4 )
1330                                         trace.origin[ 2 ] += step;
1331                                 else
1332                                         trace.origin[ 2 ] -= step;
1333                                 
1334                                 /* ydnar: changed to find cluster num */
1335                                 trace.cluster = ClusterForPointExt( trace.origin, VERTEX_EPSILON );
1336                                 if( trace.cluster >= 0 )
1337                                         break;
1338                         }
1339                         
1340                         if( i != 8 )
1341                                 break;
1342                 }
1343                 
1344                 /* can't find a valid point at all */
1345                 if( step > 18 )
1346                         return;
1347         }
1348         
1349         /* setup trace */
1350         trace.testOcclusion = !noTrace;
1351         trace.forceSunlight = qfalse;
1352         trace.recvShadows = WORLDSPAWN_RECV_SHADOWS;
1353         trace.numSurfaces = 0;
1354         trace.surfaces = NULL;
1355         trace.numLights = 0;
1356         trace.lights = NULL;
1357         
1358         /* clear */
1359         numCon = 0;
1360         VectorClear( cheapColor );
1361         
1362         /* trace to all the lights, find the major light direction, and divide the
1363            total light between that along the direction and the remaining in the ambient */
1364         for( trace.light = lights; trace.light != NULL; trace.light = trace.light->next )
1365         {
1366                 float           addSize;
1367                 
1368                 
1369                 /* sample light */
1370                 if( !LightContributionToPoint( &trace ) )
1371                         continue;
1372                 
1373                 /* handle negative light */
1374                 if( trace.light->flags & LIGHT_NEGATIVE )
1375                         VectorScale( trace.color, -1.0f, trace.color );
1376                 
1377                 /* add a contribution */
1378                 VectorCopy( trace.color, contributions[ numCon ].color );
1379                 VectorCopy( trace.direction, contributions[ numCon ].dir );
1380                 contributions[ numCon ].style = trace.light->style;
1381                 numCon++;
1382                 
1383                 /* push average direction around */
1384                 addSize = VectorLength( trace.color );
1385                 VectorMA( gp->dir, addSize, trace.direction, gp->dir );
1386                 
1387                 /* stop after a while */
1388                 if( numCon >= (MAX_CONTRIBUTIONS - 1) )
1389                         break;
1390                 
1391                 /* ydnar: cheap mode */
1392                 VectorAdd( cheapColor, trace.color, cheapColor );
1393                 if( cheapgrid && cheapColor[ 0 ] >= 255.0f && cheapColor[ 1 ] >= 255.0f && cheapColor[ 2 ] >= 255.0f )
1394                         break;
1395         }
1396         
1397         /////// Floodlighting for point //////////////////
1398         //do our floodlight ambient occlusion loop, and add a single contribution based on the brightest dir
1399         if (floodlighty)
1400         {
1401                 int q;
1402                 float addSize,f;
1403                 vec3_t col,dir;
1404                 col[0]=col[1]=col[2]=floodlightIntensity;
1405                 dir[0]=dir[1]=0;
1406                 dir[2]=1;
1407
1408                 trace.testOcclusion = qtrue;
1409                 trace.forceSunlight = qfalse;
1410                 trace.inhibitRadius = DEFAULT_INHIBIT_RADIUS;
1411                 trace.testAll = qtrue;
1412
1413                 for (q=0;q<2;q++)
1414                 {
1415                         if (q==0) //upper hemisphere
1416                         {
1417                                 trace.normal[0]=0;
1418                                 trace.normal[1]=0;
1419                                 trace.normal[2]=1;
1420                         }
1421                         else //lower hemisphere
1422                         {
1423                                 trace.normal[0]=0;
1424                                 trace.normal[1]=0;
1425                                 trace.normal[2]=-1;
1426                         }
1427
1428                         f = FloodLightForSample(&trace, floodlightDistance, floodlight_lowquality);
1429
1430                         contributions[ numCon ].color[0]=col[0]*f;
1431                         contributions[ numCon ].color[1]=col[1]*f;
1432                         contributions[ numCon ].color[2]=col[2]*f;
1433
1434                         contributions[ numCon ].dir[0]=dir[0];
1435                         contributions[ numCon ].dir[1]=dir[1];
1436                         contributions[ numCon ].dir[2]=dir[2];
1437
1438                         contributions[ numCon ].style = 0;
1439                         numCon++;
1440                         /* push average direction around */
1441                         addSize = VectorLength( col );
1442                         VectorMA( gp->dir, addSize, dir, gp->dir );
1443                 }
1444         }
1445         /////////////////////
1446
1447         /* normalize to get primary light direction */
1448         VectorNormalize( gp->dir, gp->dir );
1449         
1450         /* now that we have identified the primary light direction,
1451            go back and separate all the light into directed and ambient */
1452
1453         numStyles = 1;
1454         for( i = 0; i < numCon; i++ )
1455         {
1456                 /* get relative directed strength */
1457                 d = DotProduct( contributions[ i ].dir, gp->dir );
1458                 /* we map 1 to gridDirectionality, and 0 to gridAmbientDirectionality */
1459                 d = gridAmbientDirectionality + d * (gridDirectionality - gridAmbientDirectionality);
1460                 if( d < 0.0f )
1461                         d = 0.0f;
1462                 
1463                 /* find appropriate style */
1464                 for( j = 0; j < numStyles; j++ )
1465                 {
1466                         if( gp->styles[ j ] == contributions[ i ].style )
1467                                 break;
1468                 }
1469                 
1470                 /* style not found? */
1471                 if( j >= numStyles )
1472                 {
1473                         /* add a new style */
1474                         if( numStyles < MAX_LIGHTMAPS )
1475                         {
1476                                 gp->styles[ numStyles ] = contributions[ i ].style;
1477                                 bgp->styles[ numStyles ] = contributions[ i ].style;
1478                                 numStyles++;
1479                                 //%     Sys_Printf( "(%d, %d) ", num, contributions[ i ].style );
1480                         }
1481                         
1482                         /* fallback */
1483                         else
1484                                 j = 0;
1485                 }
1486                 
1487                 /* add the directed color */
1488                 VectorMA( gp->directed[ j ], d, contributions[ i ].color, gp->directed[ j ] );
1489                 
1490                 /* ambient light will be at 1/4 the value of directed light */
1491                 /* (ydnar: nuke this in favor of more dramatic lighting?) */
1492                 /* (PM: how about actually making it work? d=1 when it got here for single lights/sun :P */
1493 //              d = 0.25f;
1494                 /* (Hobbes: always setting it to .25 is hardly any better) */
1495                 d = 0.25f * (1.0f - d);
1496                 VectorMA( gp->ambient[ j ], d, contributions[ i ].color, gp->ambient[ j ] );
1497
1498 /*
1499  * div0:
1500  * the total light average = ambient value + 0.25 * sum of all directional values
1501  * we can also get the total light average as 0.25 * the sum of all contributions
1502  *
1503  * 0.25 * sum(contribution_i) == ambient + 0.25 * sum(d_i contribution_i)
1504  *
1505  * THIS YIELDS:
1506  * ambient == 0.25 * sum((1 - d_i) contribution_i)
1507  *
1508  * So, 0.25f * (1.0f - d) IS RIGHT. If you want to tune it, tune d BEFORE.
1509  */
1510         }
1511         
1512         
1513         /* store off sample */
1514         for( i = 0; i < MAX_LIGHTMAPS; i++ )
1515         {
1516 #if 0
1517                 /* do some fudging to keep the ambient from being too low (2003-07-05: 0.25 -> 0.125) */
1518                 if( !bouncing )
1519                         VectorMA( gp->ambient[ i ], 0.125f, gp->directed[ i ], gp->ambient[ i ] );
1520 #endif
1521                 
1522                 /* set minimum light and copy off to bytes */
1523                 VectorCopy( gp->ambient[ i ], color );
1524                 for( j = 0; j < 3; j++ )
1525                         if( color[ j ] < minGridLight[ j ] )
1526                                 color[ j ] = minGridLight[ j ];
1527
1528                 /* vortex: apply gridscale and gridambientscale here */
1529                 ColorToBytes( color, bgp->ambient[ i ], gridScale*gridAmbientScale );
1530                 ColorToBytes( gp->directed[ i ], bgp->directed[ i ], gridScale );
1531         }
1532         
1533         /* debug code */
1534         #if 0
1535                 //%     Sys_FPrintf( SYS_VRB, "%10d %10d %10d ", &gp->ambient[ 0 ][ 0 ], &gp->ambient[ 0 ][ 1 ], &gp->ambient[ 0 ][ 2 ] );
1536                 Sys_FPrintf( SYS_VRB, "%9d Amb: (%03.1f %03.1f %03.1f) Dir: (%03.1f %03.1f %03.1f)\n",
1537                         num,
1538                         gp->ambient[ 0 ][ 0 ], gp->ambient[ 0 ][ 1 ], gp->ambient[ 0 ][ 2 ],
1539                         gp->directed[ 0 ][ 0 ], gp->directed[ 0 ][ 1 ], gp->directed[ 0 ][ 2 ] );
1540         #endif
1541         
1542         /* store direction */
1543         if( !bouncing )
1544                 NormalToLatLong( gp->dir, bgp->latLong );
1545 }
1546
1547
1548
1549 /*
1550 SetupGrid()
1551 calculates the size of the lightgrid and allocates memory
1552 */
1553
1554 void SetupGrid( void )
1555 {
1556         int                     i, j;
1557         vec3_t          maxs, oldGridSize;
1558         const char      *value;
1559         char            temp[ 64 ];
1560         
1561          
1562         /* don't do this if not grid lighting */
1563         if( noGridLighting )
1564                 return;
1565         
1566         /* ydnar: set grid size */
1567         value = ValueForKey( &entities[ 0 ], "gridsize" );
1568         if( value[ 0 ] != '\0' )
1569                 sscanf( value, "%f %f %f", &gridSize[ 0 ], &gridSize[ 1 ], &gridSize[ 2 ] );
1570         
1571         /* quantize it */
1572         VectorCopy( gridSize, oldGridSize );
1573         for( i = 0; i < 3; i++ )
1574                 gridSize[ i ] = gridSize[ i ] >= 8.0f ? floor( gridSize[ i ] ) : 8.0f;
1575         
1576         /* ydnar: increase gridSize until grid count is smaller than max allowed */
1577         numRawGridPoints = MAX_MAP_LIGHTGRID + 1;
1578         j = 0;
1579         while( numRawGridPoints > MAX_MAP_LIGHTGRID )
1580         {
1581                 /* get world bounds */
1582                 for( i = 0; i < 3; i++ )
1583                 {
1584                         gridMins[ i ] = gridSize[ i ] * ceil( bspModels[ 0 ].mins[ i ] / gridSize[ i ] );
1585                         maxs[ i ] = gridSize[ i ] * floor( bspModels[ 0 ].maxs[ i ] / gridSize[ i ] );
1586                         gridBounds[ i ] = (maxs[ i ] - gridMins[ i ]) / gridSize[ i ] + 1;
1587                 }
1588         
1589                 /* set grid size */
1590                 numRawGridPoints = gridBounds[ 0 ] * gridBounds[ 1 ] * gridBounds[ 2 ];
1591                 
1592                 /* increase grid size a bit */
1593                 if( numRawGridPoints > MAX_MAP_LIGHTGRID )
1594                         gridSize[ j++ % 3 ] += 16.0f;
1595         }
1596         
1597         /* print it */
1598         Sys_Printf( "Grid size = { %1.0f, %1.0f, %1.0f }\n", gridSize[ 0 ], gridSize[ 1 ], gridSize[ 2 ] );
1599         
1600         /* different? */
1601         if( !VectorCompare( gridSize, oldGridSize ) )
1602         {
1603                 sprintf( temp, "%.0f %.0f %.0f", gridSize[ 0 ], gridSize[ 1 ], gridSize[ 2 ] );
1604                 SetKeyValue( &entities[ 0 ], "gridsize", (const char*) temp );
1605                 Sys_FPrintf( SYS_VRB, "Storing adjusted grid size\n" );
1606         }
1607         
1608         /* 2nd variable. fixme: is this silly? */
1609         numBSPGridPoints = numRawGridPoints;
1610         
1611         /* allocate lightgrid */
1612         rawGridPoints = safe_malloc( numRawGridPoints * sizeof( *rawGridPoints ) );
1613         memset( rawGridPoints, 0, numRawGridPoints * sizeof( *rawGridPoints ) );
1614         
1615         if( bspGridPoints != NULL )
1616                 free( bspGridPoints );
1617         bspGridPoints = safe_malloc( numBSPGridPoints * sizeof( *bspGridPoints ) );
1618         memset( bspGridPoints, 0, numBSPGridPoints * sizeof( *bspGridPoints ) );
1619         
1620         /* clear lightgrid */
1621         for( i = 0; i < numRawGridPoints; i++ )
1622         {
1623                 VectorCopy( ambientColor, rawGridPoints[ i ].ambient[ j ] );
1624                 rawGridPoints[ i ].styles[ 0 ] = LS_NORMAL;
1625                 bspGridPoints[ i ].styles[ 0 ] = LS_NORMAL;
1626                 for( j = 1; j < MAX_LIGHTMAPS; j++ )
1627                 {
1628                         rawGridPoints[ i ].styles[ j ] = LS_NONE;
1629                         bspGridPoints[ i ].styles[ j ] = LS_NONE;
1630                 }
1631         }
1632         
1633         /* note it */
1634         Sys_Printf( "%9d grid points\n", numRawGridPoints );
1635 }
1636
1637
1638
1639 /*
1640 LightWorld()
1641 does what it says...
1642 */
1643
1644 void LightWorld( void )
1645 {
1646         vec3_t          color;
1647         float           f;
1648         int                     b, bt;
1649         qboolean        minVertex, minGrid;
1650         const char      *value;
1651         
1652
1653         /* ydnar: smooth normals */
1654         if( shade )
1655         {
1656                 Sys_Printf( "--- SmoothNormals ---\n" );
1657                 SmoothNormals();
1658         }
1659         
1660         /* determine the number of grid points */
1661         Sys_Printf( "--- SetupGrid ---\n" );
1662         SetupGrid();
1663         
1664         /* find the optional minimum lighting values */
1665         GetVectorForKey( &entities[ 0 ], "_color", color );
1666         if( VectorLength( color ) == 0.0f )
1667                 VectorSet( color, 1.0, 1.0, 1.0 );
1668         
1669         /* ambient */
1670         f = FloatForKey( &entities[ 0 ], "_ambient" );
1671         if( f == 0.0f )
1672                 f = FloatForKey( &entities[ 0 ], "ambient" );
1673         VectorScale( color, f, ambientColor );
1674         
1675         /* minvertexlight */
1676         minVertex = qfalse;
1677         value = ValueForKey( &entities[ 0 ], "_minvertexlight" );
1678         if( value[ 0 ] != '\0' )
1679         {
1680                 minVertex = qtrue;
1681                 f = atof( value );
1682                 VectorScale( color, f, minVertexLight );
1683         }
1684         
1685         /* mingridlight */
1686         minGrid = qfalse;
1687         value = ValueForKey( &entities[ 0 ], "_mingridlight" );
1688         if( value[ 0 ] != '\0' )
1689         {
1690                 minGrid = qtrue;
1691                 f = atof( value );
1692                 VectorScale( color, f, minGridLight );
1693         }
1694         
1695         /* minlight */
1696         value = ValueForKey( &entities[ 0 ], "_minlight" );
1697         if( value[ 0 ] != '\0' )
1698         {
1699                 f = atof( value );
1700                 VectorScale( color, f, minLight );
1701                 if( minVertex == qfalse )
1702                         VectorScale( color, f, minVertexLight );
1703                 if( minGrid == qfalse )
1704                         VectorScale( color, f, minGridLight );
1705         }
1706         
1707         /* create world lights */
1708         Sys_FPrintf( SYS_VRB, "--- CreateLights ---\n" );
1709         CreateEntityLights();
1710         CreateSurfaceLights();
1711         Sys_Printf( "%9d point lights\n", numPointLights );
1712         Sys_Printf( "%9d spotlights\n", numSpotLights );
1713         Sys_Printf( "%9d diffuse (area) lights\n", numDiffuseLights );
1714         Sys_Printf( "%9d sun/sky lights\n", numSunLights );
1715         
1716         /* calculate lightgrid */
1717         if( !noGridLighting )
1718         {
1719                 /* ydnar: set up light envelopes */
1720                 SetupEnvelopes( qtrue, fastgrid );
1721                 
1722                 Sys_Printf( "--- TraceGrid ---\n" );
1723                 RunThreadsOnIndividual( numRawGridPoints, qtrue, TraceGrid );
1724                 Sys_Printf( "%d x %d x %d = %d grid\n",
1725                         gridBounds[ 0 ], gridBounds[ 1 ], gridBounds[ 2 ], numBSPGridPoints );
1726                 
1727                 /* ydnar: emit statistics on light culling */
1728                 Sys_FPrintf( SYS_VRB, "%9d grid points envelope culled\n", gridEnvelopeCulled );
1729                 Sys_FPrintf( SYS_VRB, "%9d grid points bounds culled\n", gridBoundsCulled );
1730         }
1731         
1732         /* slight optimization to remove a sqrt */
1733         subdivideThreshold *= subdivideThreshold;
1734         
1735         /* map the world luxels */
1736         Sys_Printf( "--- MapRawLightmap ---\n" );
1737         RunThreadsOnIndividual( numRawLightmaps, qtrue, MapRawLightmap );
1738         Sys_Printf( "%9d luxels\n", numLuxels );
1739         Sys_Printf( "%9d luxels mapped\n", numLuxelsMapped );
1740         Sys_Printf( "%9d luxels occluded\n", numLuxelsOccluded );
1741         
1742         /* dirty them up */
1743         if( dirty )
1744         {
1745                 Sys_Printf( "--- DirtyRawLightmap ---\n" );
1746
1747
1748
1749
1750                 RunThreadsOnIndividual( numRawLightmaps, qtrue, DirtyRawLightmap );
1751         }
1752         
1753         /* floodlight pass */
1754         FloodlightRawLightmaps();
1755
1756         /* ydnar: set up light envelopes */
1757         SetupEnvelopes( qfalse, fast );
1758         
1759         /* light up my world */
1760         lightsPlaneCulled = 0;
1761         lightsEnvelopeCulled = 0;
1762         lightsBoundsCulled = 0;
1763         lightsClusterCulled = 0;
1764         
1765         Sys_Printf( "--- IlluminateRawLightmap ---\n" );
1766         RunThreadsOnIndividual( numRawLightmaps, qtrue, IlluminateRawLightmap );
1767         Sys_Printf( "%9d luxels illuminated\n", numLuxelsIlluminated );
1768         
1769         StitchSurfaceLightmaps();
1770         
1771         Sys_Printf( "--- IlluminateVertexes ---\n" );
1772         RunThreadsOnIndividual( numBSPDrawSurfaces, qtrue, IlluminateVertexes );
1773         Sys_Printf( "%9d vertexes illuminated\n", numVertsIlluminated );
1774         
1775         /* ydnar: emit statistics on light culling */
1776         Sys_FPrintf( SYS_VRB, "%9d lights plane culled\n", lightsPlaneCulled );
1777         Sys_FPrintf( SYS_VRB, "%9d lights envelope culled\n", lightsEnvelopeCulled );
1778         Sys_FPrintf( SYS_VRB, "%9d lights bounds culled\n", lightsBoundsCulled );
1779         Sys_FPrintf( SYS_VRB, "%9d lights cluster culled\n", lightsClusterCulled );
1780         
1781         /* radiosity */
1782         b = 1;
1783         bt = bounce;
1784         while( bounce > 0 )
1785         {
1786                 /* store off the bsp between bounces */
1787                 StoreSurfaceLightmaps();
1788                 UnparseEntities();
1789                 Sys_Printf( "Writing %s\n", source );
1790                 WriteBSPFile( source );
1791                 
1792                 /* note it */
1793                 Sys_Printf( "\n--- Radiosity (bounce %d of %d) ---\n", b, bt );
1794                 
1795                 /* flag bouncing */
1796                 bouncing = qtrue;
1797                 VectorClear( ambientColor );
1798                 floodlighty = qfalse;
1799                 
1800                 /* generate diffuse lights */
1801                 RadFreeLights();
1802                 RadCreateDiffuseLights();
1803                 
1804                 /* setup light envelopes */
1805                 SetupEnvelopes( qfalse, fastbounce );
1806                 if( numLights == 0 )
1807                 {
1808                         Sys_Printf( "No diffuse light to calculate, ending radiosity.\n" );
1809                         break;
1810                 }
1811                 
1812                 /* add to lightgrid */
1813                 if( bouncegrid )
1814                 {
1815                         gridEnvelopeCulled = 0;
1816                         gridBoundsCulled = 0;
1817                         
1818                         Sys_Printf( "--- BounceGrid ---\n" );
1819                         RunThreadsOnIndividual( numRawGridPoints, qtrue, TraceGrid );
1820                         Sys_FPrintf( SYS_VRB, "%9d grid points envelope culled\n", gridEnvelopeCulled );
1821                         Sys_FPrintf( SYS_VRB, "%9d grid points bounds culled\n", gridBoundsCulled );
1822                 }
1823                 
1824                 /* light up my world */
1825                 lightsPlaneCulled = 0;
1826                 lightsEnvelopeCulled = 0;
1827                 lightsBoundsCulled = 0;
1828                 lightsClusterCulled = 0;
1829                 
1830                 Sys_Printf( "--- IlluminateRawLightmap ---\n" );
1831                 RunThreadsOnIndividual( numRawLightmaps, qtrue, IlluminateRawLightmap );
1832                 Sys_Printf( "%9d luxels illuminated\n", numLuxelsIlluminated );
1833                 Sys_Printf( "%9d vertexes illuminated\n", numVertsIlluminated );
1834                 
1835                 StitchSurfaceLightmaps();
1836                 
1837                 Sys_Printf( "--- IlluminateVertexes ---\n" );
1838                 RunThreadsOnIndividual( numBSPDrawSurfaces, qtrue, IlluminateVertexes );
1839                 Sys_Printf( "%9d vertexes illuminated\n", numVertsIlluminated );
1840                 
1841                 /* ydnar: emit statistics on light culling */
1842                 Sys_FPrintf( SYS_VRB, "%9d lights plane culled\n", lightsPlaneCulled );
1843                 Sys_FPrintf( SYS_VRB, "%9d lights envelope culled\n", lightsEnvelopeCulled );
1844                 Sys_FPrintf( SYS_VRB, "%9d lights bounds culled\n", lightsBoundsCulled );
1845                 Sys_FPrintf( SYS_VRB, "%9d lights cluster culled\n", lightsClusterCulled );
1846                 
1847                 /* interate */
1848                 bounce--;
1849                 b++;
1850         }
1851 }
1852
1853
1854
1855 /*
1856 LightMain()
1857 main routine for light processing
1858 */
1859
1860 int LightMain( int argc, char **argv )
1861 {
1862         int                     i;
1863         float           f;
1864         char            mapSource[ 1024 ];
1865         const char      *value;
1866         int lightmapMergeSize = 0;
1867         
1868         
1869         /* note it */
1870         Sys_Printf( "--- Light ---\n" );
1871         Sys_Printf( "--- ProcessGameSpecific ---\n" );
1872
1873         /* set standard game flags */
1874         wolfLight = game->wolfLight;
1875         if (wolfLight == qtrue)
1876                 Sys_Printf( " lightning model: wolf\n" );
1877         else
1878                 Sys_Printf( " lightning model: quake3\n" );
1879
1880         lmCustomSize = game->lightmapSize;
1881         Sys_Printf( " lightmap size: %d x %d pixels\n", lmCustomSize, lmCustomSize );
1882
1883         lightmapGamma = game->lightmapGamma;
1884         Sys_Printf( " lightning gamma: %f\n", lightmapGamma );
1885
1886         lightmapCompensate = game->lightmapCompensate;
1887         Sys_Printf( " lightning compensation: %f\n", lightmapCompensate );
1888
1889         lightmapExposure = game->lightmapExposure;
1890         Sys_Printf( " lightning exposure: %f\n", lightmapExposure );
1891
1892         gridScale = game->gridScale;
1893         Sys_Printf( " lightgrid scale: %f\n", gridScale );
1894
1895         gridAmbientScale = game->gridAmbientScale;
1896         Sys_Printf( " lightgrid ambient scale: %f\n", gridAmbientScale );
1897
1898         noStyles = game->noStyles;
1899         if (noStyles == qtrue)
1900                 Sys_Printf( " shader lightstyles hack: disabled\n" );
1901         else
1902                 Sys_Printf( " shader lightstyles hack: enabled\n" );
1903
1904         keepLights = game->keepLights;
1905         if (keepLights == qtrue)
1906                 Sys_Printf( " keep lights: enabled\n" );
1907         else
1908                 Sys_Printf( " keep lights: disabled\n" );
1909
1910         patchShadows = game->patchShadows;
1911         if (patchShadows == qtrue)
1912                 Sys_Printf( " patch shadows: enabled\n" );
1913         else
1914                 Sys_Printf( " patch shadows: disabled\n" );
1915
1916         deluxemap = game->deluxeMap;
1917         deluxemode = game->deluxeMode;
1918         if (deluxemap == qtrue)
1919         {
1920                 if (deluxemode)
1921                         Sys_Printf( " deluxemapping: enabled with tangentspace deluxemaps\n" );
1922                 else
1923                         Sys_Printf( " deluxemapping: enabled with modelspace deluxemaps\n" );
1924         }
1925         else
1926                 Sys_Printf( " deluxemapping: disabled\n" );
1927
1928         Sys_Printf( "--- ProcessCommandLine ---\n" );
1929         
1930         /* process commandline arguments */
1931         for( i = 1; i < (argc - 1); i++ )
1932         {
1933                 /* lightsource scaling */
1934                 if( !strcmp( argv[ i ], "-point" ) || !strcmp( argv[ i ], "-pointscale" ) )
1935                 {
1936                         f = atof( argv[ i + 1 ] );
1937                         pointScale *= f;
1938                         Sys_Printf( "Point (entity) light scaled by %f to %f\n", f, pointScale );
1939                         i++;
1940                 }
1941                 
1942                 else if( !strcmp( argv[ i ], "-area" ) || !strcmp( argv[ i ], "-areascale" ) )
1943                 {
1944                         f = atof( argv[ i + 1 ] );
1945                         areaScale *= f;
1946                         Sys_Printf( "Area (shader) light scaled by %f to %f\n", f, areaScale );
1947                         i++;
1948                 }
1949                 
1950                 else if( !strcmp( argv[ i ], "-sky" ) || !strcmp( argv[ i ], "-skyscale" ) )
1951                 {
1952                         f = atof( argv[ i + 1 ] );
1953                         skyScale *= f;
1954                         Sys_Printf( "Sky/sun light scaled by %f to %f\n", f, skyScale );
1955                         i++;
1956                 }
1957                 
1958                 else if( !strcmp( argv[ i ], "-bouncescale" ) )
1959                 {
1960                         f = atof( argv[ i + 1 ] );
1961                         bounceScale *= f;
1962                         Sys_Printf( "Bounce (radiosity) light scaled by %f to %f\n", f, bounceScale );
1963                         i++;
1964                 }
1965                 
1966                 else if( !strcmp( argv[ i ], "-scale" ) )
1967                 {
1968                         f = atof( argv[ i + 1 ] );
1969                         pointScale *= f;
1970                         areaScale *= f;
1971                         skyScale *= f;
1972                         bounceScale *= f;
1973                         Sys_Printf( "All light scaled by %f\n", f );
1974                         i++;
1975                 }
1976
1977                 else if( !strcmp( argv[ i ], "-gridscale" ) )
1978                 {
1979                         f = atof( argv[ i + 1 ] );
1980                         Sys_Printf( "Grid lightning scaled by %f\n", f );
1981                         gridScale *= f;
1982                         i++;
1983                 }
1984
1985                 else if( !strcmp( argv[ i ], "-gridambientscale" ) )
1986                 {
1987                         f = atof( argv[ i + 1 ] );
1988                         Sys_Printf( "Grid ambient lightning scaled by %f\n", f );
1989                         gridAmbientScale *= f;
1990                         i++;
1991                 }
1992
1993                 else if( !strcmp( argv[ i ], "-griddirectionality" ) )
1994                 {
1995                         f = atof( argv[ i + 1 ] );
1996                         if(f < 0) f = 0;
1997                         if(f > gridAmbientDirectionality) f = gridAmbientDirectionality;
1998                         Sys_Printf( "Grid directionality is %f\n", f );
1999                         gridDirectionality *= f;
2000                         i++;
2001                 }
2002
2003                 else if( !strcmp( argv[ i ], "-gridambientdirectionality" ) )
2004                 {
2005                         f = atof( argv[ i + 1 ] );
2006                         if(f > gridDirectionality) f = gridDirectionality
2007                         if(f > 1) f = 1;
2008                         Sys_Printf( "Grid ambient directionality is %f\n", f );
2009                         gridAmbientDirectionality *= f;
2010                         i++;
2011                 }
2012                 
2013                 else if( !strcmp( argv[ i ], "-gamma" ) )
2014                 {
2015                         f = atof( argv[ i + 1 ] );
2016                         lightmapGamma = f;
2017                         Sys_Printf( "Lighting gamma set to %f\n", lightmapGamma );
2018                         i++;
2019                 }
2020                 
2021                 else if( !strcmp( argv[ i ], "-exposure" ) )
2022                 {
2023                         f = atof( argv[ i + 1 ] );
2024                         lightmapExposure = f;
2025                         Sys_Printf( "Lighting exposure set to %f\n", lightmapExposure );
2026                         i++;
2027                 }
2028
2029                 else if( !strcmp( argv[ i ], "-compensate" ) )
2030                 {
2031                         f = atof( argv[ i + 1 ] );
2032                         if( f <= 0.0f )
2033                                 f = 1.0f;
2034                         lightmapCompensate = f;
2035                         Sys_Printf( "Lighting compensation set to 1/%f\n", lightmapCompensate );
2036                         i++;
2037                 }
2038                 
2039                 /* ydnar switches */
2040                 else if( !strcmp( argv[ i ], "-bounce" ) )
2041                 {
2042                         bounce = atoi( argv[ i + 1 ] );
2043                         if( bounce < 0 )
2044                                 bounce = 0;
2045                         else if( bounce > 0 )
2046                                 Sys_Printf( "Radiosity enabled with %d bounce(s)\n", bounce );
2047                         i++;
2048                 }
2049                 
2050                 else if( !strcmp( argv[ i ], "-supersample" ) || !strcmp( argv[ i ], "-super" ) )
2051                 {
2052                         superSample = atoi( argv[ i + 1 ] );
2053                         if( superSample < 1 )
2054                                 superSample = 1;
2055                         else if( superSample > 1 )
2056                                 Sys_Printf( "Ordered-grid supersampling enabled with %d sample(s) per lightmap texel\n", (superSample * superSample) );
2057                         i++;
2058                 }
2059                 
2060                 else if( !strcmp( argv[ i ], "-samples" ) )
2061                 {
2062                         lightSamples = atoi( argv[ i + 1 ] );
2063                         if( lightSamples < 1 )
2064                                 lightSamples = 1;
2065                         else if( lightSamples > 1 )
2066                                 Sys_Printf( "Adaptive supersampling enabled with %d sample(s) per lightmap texel\n", lightSamples );
2067                         i++;
2068                 }
2069                 
2070                 else if( !strcmp( argv[ i ], "-filter" ) )
2071                 {
2072                         filter = qtrue;
2073                         Sys_Printf( "Lightmap filtering enabled\n" );
2074                 }
2075                 
2076                 else if( !strcmp( argv[ i ], "-dark" ) )
2077                 {
2078                         dark = qtrue;
2079                         Sys_Printf( "Dark lightmap seams enabled\n" );
2080                 }
2081                 
2082                 else if( !strcmp( argv[ i ], "-shadeangle" ) )
2083                 {
2084                         shadeAngleDegrees = atof( argv[ i + 1 ] );
2085                         if( shadeAngleDegrees < 0.0f )
2086                                 shadeAngleDegrees = 0.0f;
2087                         else if( shadeAngleDegrees > 0.0f )
2088                         {
2089                                 shade = qtrue;
2090                                 Sys_Printf( "Phong shading enabled with a breaking angle of %f degrees\n", shadeAngleDegrees );
2091                         }
2092                         i++;
2093                 }
2094                 
2095                 else if( !strcmp( argv[ i ], "-thresh" ) )
2096                 {
2097                         subdivideThreshold = atof( argv[ i + 1 ] );
2098                         if( subdivideThreshold < 0 )
2099                                 subdivideThreshold = DEFAULT_SUBDIVIDE_THRESHOLD;
2100                         else
2101                                 Sys_Printf( "Subdivision threshold set at %.3f\n", subdivideThreshold );
2102                         i++;
2103                 }
2104                 
2105                 else if( !strcmp( argv[ i ], "-approx" ) )
2106                 {
2107                         approximateTolerance = atoi( argv[ i + 1 ] );
2108                         if( approximateTolerance < 0 )
2109                                 approximateTolerance = 0;
2110                         else if( approximateTolerance > 0 )
2111                                 Sys_Printf( "Approximating lightmaps within a byte tolerance of %d\n", approximateTolerance );
2112                         i++;
2113                 }
2114                 else if( !strcmp( argv[ i ], "-deluxe" ) || !strcmp( argv[ i ], "-deluxemap" ) )
2115                 {
2116                         deluxemap = qtrue;
2117                         Sys_Printf( "Generating deluxemaps for average light direction\n" );
2118                 }
2119                 else if( !strcmp( argv[ i ], "-deluxemode" ))
2120                 {
2121                         deluxemode = atoi( argv[ i + 1 ] );
2122                         if (deluxemode == 0 || deluxemode > 1 || deluxemode < 0)
2123                         {
2124                                 Sys_Printf( "Generating modelspace deluxemaps\n" );
2125                                 deluxemode = 0;
2126                         }
2127                         else 
2128                                 Sys_Printf( "Generating tangentspace deluxemaps\n" );
2129                         i++;
2130                 }
2131                 else if( !strcmp( argv[ i ], "-nodeluxe" ) || !strcmp( argv[ i ], "-nodeluxemap" ) )
2132                 {
2133                         deluxemap = qfalse;
2134                         Sys_Printf( "Disabling generating of deluxemaps for average light direction\n" );
2135                 }
2136                 else if( !strcmp( argv[ i ], "-external" ) )
2137                 {
2138                         externalLightmaps = qtrue;
2139                         Sys_Printf( "Storing all lightmaps externally\n" );
2140                 }
2141
2142                 else if( !strcmp( argv[ i ], "-lightmapsize" ) )
2143                 {
2144                         lmCustomSize = atoi( argv[ i + 1 ] );
2145                         
2146                         /* must be a power of 2 and greater than 2 */
2147                         if( ((lmCustomSize - 1) & lmCustomSize) || lmCustomSize < 2 )
2148                         {
2149                                 Sys_Printf( "WARNING: Lightmap size must be a power of 2, greater or equal to 2 pixels.\n" );
2150                                 lmCustomSize = game->lightmapSize;
2151                         }
2152                         i++;
2153                         Sys_Printf( "Default lightmap size set to %d x %d pixels\n", lmCustomSize, lmCustomSize );
2154                         
2155                         /* enable external lightmaps */
2156                         if( lmCustomSize != game->lightmapSize )
2157                         {
2158                                 externalLightmaps = qtrue;
2159                                 Sys_Printf( "Storing all lightmaps externally\n" );
2160                         }
2161                 }
2162                 
2163                 else if( !strcmp( argv[ i ], "-rawlightmapsizelimit" ) )
2164                 {
2165                         lmLimitSize = atoi( argv[ i + 1 ] );
2166                         
2167                         i++;
2168                         Sys_Printf( "Raw lightmap size limit set to %d x %d pixels\n", lmLimitSize, lmLimitSize );
2169                 }
2170                 
2171                 else if( !strcmp( argv[ i ], "-lightmapdir" ) )
2172                 {
2173                         lmCustomDir = argv[i + 1];
2174                         i++;
2175                         Sys_Printf( "Lightmap directory set to %s\n", lmCustomDir );
2176                         externalLightmaps = qtrue;
2177                         Sys_Printf( "Storing all lightmaps externally\n" );
2178                 }
2179                 
2180                 /* ydnar: add this to suppress warnings */
2181                 else if( !strcmp( argv[ i ],  "-custinfoparms") )
2182                 {
2183                         Sys_Printf( "Custom info parms enabled\n" );
2184                         useCustomInfoParms = qtrue;
2185                 }
2186                 
2187                 else if( !strcmp( argv[ i ], "-wolf" ) )
2188                 {
2189                         /* -game should already be set */
2190                         wolfLight = qtrue;
2191                         Sys_Printf( "Enabling Wolf lighting model (linear default)\n" );
2192                 }
2193                 
2194                 else if( !strcmp( argv[ i ], "-q3" ) )
2195                 {
2196                         /* -game should already be set */
2197                         wolfLight = qfalse;
2198                         Sys_Printf( "Enabling Quake 3 lighting model (nonlinear default)\n" );
2199                 }
2200                 
2201                 else if( !strcmp( argv[ i ], "-sunonly" ) )
2202                 {
2203                         sunOnly = qtrue;
2204                         Sys_Printf( "Only computing sunlight\n" );
2205                 }
2206                 
2207                 else if( !strcmp( argv[ i ], "-bounceonly" ) )
2208                 {
2209                         bounceOnly = qtrue;
2210                         Sys_Printf( "Storing bounced light (radiosity) only\n" );
2211                 }
2212                 
2213                 else if( !strcmp( argv[ i ], "-nocollapse" ) )
2214                 {
2215                         noCollapse = qtrue;
2216                         Sys_Printf( "Identical lightmap collapsing disabled\n" );
2217                 }
2218
2219                 else if( !strcmp( argv[ i ], "-nolightmapsearch" ) )
2220                 {
2221                         lightmapSearchBlockSize = 1;
2222                         Sys_Printf( "No lightmap searching - all lightmaps will be sequential\n" );
2223                 }
2224                 
2225                 else if( !strcmp( argv[ i ], "-lightmapsearchpower" ) )
2226                 {
2227                         lightmapMergeSize = (game->lightmapSize << atoi(argv[i+1]));
2228                         ++i;
2229                         Sys_Printf( "Restricted lightmap searching enabled - optimize for lightmap merge power %d (size %d)\n", atoi(argv[i]), lightmapMergeSize );
2230                 }
2231                 
2232                 else if( !strcmp( argv[ i ], "-lightmapsearchblocksize" ) )
2233                 {
2234                         lightmapSearchBlockSize = atoi(argv[i+1]);
2235                         ++i;
2236                         Sys_Printf( "Restricted lightmap searching enabled - block size set to %d\n", lightmapSearchBlockSize );
2237                 }
2238                 
2239                 else if( !strcmp( argv[ i ], "-shade" ) )
2240                 {
2241                         shade = qtrue;
2242                         Sys_Printf( "Phong shading enabled\n" );
2243                 }
2244                 
2245                 else if( !strcmp( argv[ i ], "-bouncegrid") )
2246                 {
2247                         bouncegrid = qtrue;
2248                         if( bounce > 0 )
2249                                 Sys_Printf( "Grid lighting with radiosity enabled\n" );
2250                 }
2251                 
2252                 else if( !strcmp( argv[ i ], "-smooth" ) )
2253                 {
2254                         lightSamples = EXTRA_SCALE;
2255                         Sys_Printf( "The -smooth argument is deprecated, use \"-samples 2\" instead\n" );
2256                 }
2257                 
2258                 else if( !strcmp( argv[ i ], "-fast" ) )
2259                 {
2260                         fast = qtrue;
2261                         fastgrid = qtrue;
2262                         fastbounce = qtrue;
2263                         Sys_Printf( "Fast mode enabled\n" );
2264                 }
2265                 
2266                 else if( !strcmp( argv[ i ], "-faster" ) )
2267                 {
2268                         faster = qtrue;
2269                         fast = qtrue;
2270                         fastgrid = qtrue;
2271                         fastbounce = qtrue;
2272                         Sys_Printf( "Faster mode enabled\n" );
2273                 }
2274                 
2275                 else if( !strcmp( argv[ i ], "-fastgrid" ) )
2276                 {
2277                         fastgrid = qtrue;
2278                         Sys_Printf( "Fast grid lighting enabled\n" );
2279                 }
2280                 
2281                 else if( !strcmp( argv[ i ], "-fastbounce" ) )
2282                 {
2283                         fastbounce = qtrue;
2284                         Sys_Printf( "Fast bounce mode enabled\n" );
2285                 }
2286                 
2287                 else if( !strcmp( argv[ i ], "-cheap" ) )
2288                 {
2289                         cheap = qtrue;
2290                         cheapgrid = qtrue;
2291                         Sys_Printf( "Cheap mode enabled\n" );
2292                 }
2293
2294                 else if( !strcmp( argv[ i ], "-cheapgrid" ) )
2295                 {
2296                         cheapgrid = qtrue;
2297                         Sys_Printf( "Cheap grid mode enabled\n" );
2298                 }
2299                 
2300                 else if( !strcmp( argv[ i ], "-normalmap" ) )
2301                 {
2302                         normalmap = qtrue;
2303                         Sys_Printf( "Storing normal map instead of lightmap\n" );
2304                 }
2305                 
2306                 else if( !strcmp( argv[ i ], "-trisoup" ) )
2307                 {
2308                         trisoup = qtrue;
2309                         Sys_Printf( "Converting brush faces to triangle soup\n" );
2310                 }
2311                 
2312                 else if( !strcmp( argv[ i ], "-debug" ) )
2313                 {
2314                         debug = qtrue;
2315                         Sys_Printf( "Lightmap debugging enabled\n" );
2316                 }
2317                 
2318                 else if( !strcmp( argv[ i ], "-debugsurfaces" ) || !strcmp( argv[ i ], "-debugsurface" ) )
2319                 {
2320                         debugSurfaces = qtrue;
2321                         Sys_Printf( "Lightmap surface debugging enabled\n" );
2322                 }
2323                 
2324                 else if( !strcmp( argv[ i ], "-debugunused" ) )
2325                 {
2326                         debugUnused = qtrue;
2327                         Sys_Printf( "Unused luxel debugging enabled\n" );
2328                 }
2329
2330                 else if( !strcmp( argv[ i ], "-debugaxis" ) )
2331                 {
2332                         debugAxis = qtrue;
2333                         Sys_Printf( "Lightmap axis debugging enabled\n" );
2334                 }
2335                 
2336                 else if( !strcmp( argv[ i ], "-debugcluster" ) )
2337                 {
2338                         debugCluster = qtrue;
2339                         Sys_Printf( "Luxel cluster debugging enabled\n" );
2340                 }
2341                 
2342                 else if( !strcmp( argv[ i ], "-debugorigin" ) )
2343                 {
2344                         debugOrigin = qtrue;
2345                         Sys_Printf( "Luxel origin debugging enabled\n" );
2346                 }
2347                 
2348                 else if( !strcmp( argv[ i ], "-debugdeluxe" ) )
2349                 {
2350                         deluxemap = qtrue;
2351                         debugDeluxemap = qtrue;
2352                         Sys_Printf( "Deluxemap debugging enabled\n" );
2353                 }
2354                 
2355                 else if( !strcmp( argv[ i ], "-export" ) )
2356                 {
2357                         exportLightmaps = qtrue;
2358                         Sys_Printf( "Exporting lightmaps\n" );
2359                 }
2360                 
2361                 else if( !strcmp(argv[ i ], "-notrace" )) 
2362                 {
2363                         noTrace = qtrue;
2364                         Sys_Printf( "Shadow occlusion disabled\n" );
2365                 }
2366                 else if( !strcmp(argv[ i ], "-patchshadows" ) )
2367                 {
2368                         patchShadows = qtrue;
2369                         Sys_Printf( "Patch shadow casting enabled\n" );
2370                 }
2371                 else if( !strcmp( argv[ i ], "-extra" ) )
2372                 {
2373                         superSample = EXTRA_SCALE;              /* ydnar */
2374                         Sys_Printf( "The -extra argument is deprecated, use \"-super 2\" instead\n" );
2375                 }
2376                 else if( !strcmp( argv[ i ], "-extrawide" ) )
2377                 {
2378                         superSample = EXTRAWIDE_SCALE;  /* ydnar */
2379                         filter = qtrue;                                 /* ydnar */
2380                         Sys_Printf( "The -extrawide argument is deprecated, use \"-filter [-super 2]\" instead\n");
2381                 }
2382                 else if( !strcmp( argv[ i ], "-samplesize" ) )
2383                 {
2384                         sampleSize = atoi( argv[ i + 1 ] );
2385                         if( sampleSize < 1 )
2386                                 sampleSize = 1;
2387                         i++;
2388                         Sys_Printf( "Default lightmap sample size set to %dx%d units\n", sampleSize, sampleSize );
2389                 }
2390                 else if( !strcmp( argv[ i ], "-minsamplesize" ) )
2391                 {
2392                         minSampleSize = atoi( argv[ i + 1 ] );
2393                         if( minSampleSize < 1 )
2394                                 minSampleSize = 1;
2395                         i++;
2396                         Sys_Printf( "Minimum lightmap sample size set to %dx%d units\n", minSampleSize, minSampleSize );
2397                 }
2398                 else if( !strcmp( argv[ i ],  "-samplescale" ) )
2399                 {
2400                         sampleScale = atoi( argv[ i + 1 ] );
2401                         i++;
2402                         Sys_Printf( "Lightmaps sample scale set to %d\n", sampleScale);
2403                 }
2404                 else if( !strcmp( argv[ i ], "-novertex" ) )
2405                 {
2406                         noVertexLighting = qtrue;
2407                         Sys_Printf( "Disabling vertex lighting\n" );
2408                 }
2409                 else if( !strcmp( argv[ i ], "-nogrid" ) )
2410                 {
2411                         noGridLighting = qtrue;
2412                         Sys_Printf( "Disabling grid lighting\n" );
2413                 }
2414                 else if( !strcmp( argv[ i ], "-border" ) )
2415                 {
2416                         lightmapBorder = qtrue;
2417                         Sys_Printf( "Adding debug border to lightmaps\n" );
2418                 }
2419                 else if( !strcmp( argv[ i ], "-nosurf" ) )
2420                 {
2421                         noSurfaces = qtrue;
2422                         Sys_Printf( "Not tracing against surfaces\n" );
2423                 }
2424                 else if( !strcmp( argv[ i ], "-dump" ) )
2425                 {
2426                         dump = qtrue;
2427                         Sys_Printf( "Dumping radiosity lights into numbered prefabs\n" );
2428                 }
2429                 else if( !strcmp( argv[ i ], "-lomem" ) )
2430                 {
2431                         loMem = qtrue;
2432                         Sys_Printf( "Enabling low-memory (potentially slower) lighting mode\n" );
2433                 }
2434                 else if( !strcmp( argv[ i ], "-nostyle" ) || !strcmp( argv[ i ], "-nostyles" ) )
2435                 {
2436                         noStyles = qtrue;
2437                         Sys_Printf( "Disabling lightstyles\n" );
2438                 }
2439                 else if( !strcmp( argv[ i ], "-style" ) || !strcmp( argv[ i ], "-styles" ) )
2440                 {
2441                         noStyles = qfalse;
2442                         Sys_Printf( "Enabling lightstyles\n" );
2443                 }
2444                 else if( !strcmp( argv[ i ], "-keeplights" ))
2445                 {
2446                         keepLights = qtrue;
2447                         Sys_Printf( "Leaving light entities on map after compile\n" );
2448                 }
2449                 else if( !strcmp( argv[ i ], "-cpma" ) )
2450                 {
2451                         cpmaHack = qtrue;
2452                         Sys_Printf( "Enabling Challenge Pro Mode Asstacular Vertex Lighting Mode (tm)\n" );
2453                 }
2454                 else if( !strcmp( argv[ i ], "-floodlight" ) )
2455                 {
2456                         floodlighty = qtrue;
2457                         Sys_Printf( "FloodLighting enabled\n" );
2458                 }
2459                 else if( !strcmp( argv[ i ], "-debugnormals" ) )
2460                 {
2461                         debugnormals = qtrue;
2462                         Sys_Printf( "DebugNormals enabled\n" );
2463                 }
2464                 else if( !strcmp( argv[ i ], "-lowquality" ) )
2465                 {
2466                         floodlight_lowquality = qtrue;
2467                         Sys_Printf( "Low Quality FloodLighting enabled\n" );
2468                 }
2469                 
2470                 /* r7: dirtmapping */
2471                 else if( !strcmp( argv[ i ], "-dirty" ) )
2472                 {
2473                         dirty = qtrue;
2474                         Sys_Printf( "Dirtmapping enabled\n" );
2475                 }
2476                 else if( !strcmp( argv[ i ], "-dirtdebug" ) || !strcmp( argv[ i ], "-debugdirt" ) )
2477                 {
2478                         dirtDebug = qtrue;
2479                         Sys_Printf( "Dirtmap debugging enabled\n" );
2480                 }
2481                 else if( !strcmp( argv[ i ], "-dirtmode" ) )
2482                 {
2483                         dirtMode = atoi( argv[ i + 1 ] );
2484                         if( dirtMode != 0 && dirtMode != 1 )
2485                                 dirtMode = 0;
2486                         if( dirtMode == 1 )
2487                                 Sys_Printf( "Enabling randomized dirtmapping\n" );
2488                         else
2489                                 Sys_Printf( "Enabling ordered dir mapping\n" );
2490                         i++;
2491                 }
2492                 else if( !strcmp( argv[ i ], "-dirtdepth" ) )
2493                 {
2494                         dirtDepth = atof( argv[ i + 1 ] );
2495                         if( dirtDepth <= 0.0f )
2496                                 dirtDepth = 128.0f;
2497                         Sys_Printf( "Dirtmapping depth set to %.1f\n", dirtDepth );
2498                         i++;
2499                 }
2500                 else if( !strcmp( argv[ i ], "-dirtscale" ) )
2501                 {
2502                         dirtScale = atof( argv[ i + 1 ] );
2503                         if( dirtScale <= 0.0f )
2504                                 dirtScale = 1.0f;
2505                         Sys_Printf( "Dirtmapping scale set to %.1f\n", dirtScale );
2506                         i++;
2507                 }
2508                 else if( !strcmp( argv[ i ], "-dirtgain" ) )
2509                 {
2510                         dirtGain = atof( argv[ i + 1 ] );
2511                         if( dirtGain <= 0.0f )
2512                                 dirtGain = 1.0f;
2513                         Sys_Printf( "Dirtmapping gain set to %.1f\n", dirtGain );
2514                         i++;
2515                 }
2516                 else if( !strcmp( argv[ i ], "-trianglecheck" ) )
2517                 {
2518                         lightmapTriangleCheck = qtrue;
2519                 }
2520                 else if( !strcmp( argv[ i ], "-extravisnudge" ) )
2521                 {
2522                         lightmapExtraVisClusterNudge = qtrue;
2523                 }
2524                 /* unhandled args */
2525                 else
2526                 {
2527                         Sys_Printf( "WARNING: Unknown argument \"%s\"\n", argv[ i ] );
2528                 }
2529
2530         }
2531
2532         /* fix up lightmap search power */
2533         if(lightmapMergeSize)
2534         {
2535                 lightmapSearchBlockSize = (lightmapMergeSize / lmCustomSize) * (lightmapMergeSize / lmCustomSize);
2536                 if(lightmapSearchBlockSize < 1)
2537                         lightmapSearchBlockSize = 1;
2538
2539                 Sys_Printf( "Restricted lightmap searching enabled - block size adjusted to %d\n", lightmapSearchBlockSize );
2540         }
2541         
2542         /* clean up map name */
2543         strcpy( source, ExpandArg( argv[ i ] ) );
2544         StripExtension( source );
2545         DefaultExtension( source, ".bsp" );
2546         strcpy( mapSource, ExpandArg( argv[ i ] ) );
2547         StripExtension( mapSource );
2548         DefaultExtension( mapSource, ".map" );
2549         
2550         /* ydnar: set default sample size */
2551         SetDefaultSampleSize( sampleSize );
2552         
2553         /* ydnar: handle shaders */
2554         BeginMapShaderFile( source );
2555         LoadShaderInfo();
2556         
2557         /* note loading */
2558         Sys_Printf( "Loading %s\n", source );
2559         
2560         /* ydnar: load surface file */
2561         LoadSurfaceExtraFile( source );
2562         
2563         /* load bsp file */
2564         LoadBSPFile( source );
2565         
2566         /* parse bsp entities */
2567         ParseEntities();
2568
2569         /* inject command line parameters */
2570         InjectCommandLine(argv, 0, argc - 1);
2571         
2572         /* load map file */
2573         value = ValueForKey( &entities[ 0 ], "_keepLights" );
2574         if( value[ 0 ] != '1' )
2575                 LoadMapFile( mapSource, qtrue );
2576         
2577         /* set the entity/model origins and init yDrawVerts */
2578         SetEntityOrigins();
2579         
2580         /* ydnar: set up optimization */
2581         SetupBrushes();
2582         SetupDirt();
2583         SetupFloodLight();
2584         SetupSurfaceLightmaps();
2585         
2586         /* initialize the surface facet tracing */
2587         SetupTraceNodes();
2588         
2589         /* light the world */
2590         LightWorld();
2591         
2592         /* ydnar: store off lightmaps */
2593         StoreSurfaceLightmaps();
2594         
2595         /* write out the bsp */
2596         UnparseEntities();
2597         Sys_Printf( "Writing %s\n", source );
2598         WriteBSPFile( source );
2599         
2600         /* ydnar: export lightmaps */
2601         if( exportLightmaps && !externalLightmaps )
2602                 ExportLightmaps();
2603         
2604         /* return to sender */
2605         return 0;
2606 }
2607