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, numCon, numStyles;
1276         float                                   d, step;
1277         vec3_t                                  baseOrigin, cheapColor, color, thisdir;
1278         rawGridPoint_t                  *gp;
1279         bspGridPoint_t                  *bgp;
1280         contribution_t                  contributions[ MAX_CONTRIBUTIONS ];
1281         trace_t                                 trace;
1282
1283         /* get grid points */
1284         gp = &rawGridPoints[ num ];
1285         bgp = &bspGridPoints[ num ];
1286
1287         /* get grid origin */
1288         mod = num;
1289         z = mod / (gridBounds[ 0 ] * gridBounds[ 1 ]);
1290         mod -= z * (gridBounds[ 0 ] * gridBounds[ 1 ]);
1291         y = mod / gridBounds[ 0 ];
1292         mod -= y * gridBounds[ 0 ];
1293         x = mod;
1294
1295         trace.origin[ 0 ] = gridMins[ 0 ] + x * gridSize[ 0 ];
1296         trace.origin[ 1 ] = gridMins[ 1 ] + y * gridSize[ 1 ];
1297         trace.origin[ 2 ] = gridMins[ 2 ] + z * gridSize[ 2 ];
1298
1299         /* set inhibit sphere */
1300         if( gridSize[ 0 ] > gridSize[ 1 ] && gridSize[ 0 ] > gridSize[ 2 ] )
1301                 trace.inhibitRadius = gridSize[ 0 ] * 0.5f;
1302         else if( gridSize[ 1 ] > gridSize[ 0 ] && gridSize[ 1 ] > gridSize[ 2 ] )
1303                 trace.inhibitRadius = gridSize[ 1 ] * 0.5f;
1304         else
1305                 trace.inhibitRadius = gridSize[ 2 ] * 0.5f;
1306
1307         /* find point cluster */
1308         trace.cluster = ClusterForPointExt( trace.origin, GRID_EPSILON );
1309         if( trace.cluster < 0 )
1310         {
1311                 /* try to nudge the origin around to find a valid point */
1312                 VectorCopy( trace.origin, baseOrigin );
1313                 for( step = 0; (step += 0.005) <= 1.0; )
1314                 {
1315                         VectorCopy( baseOrigin, trace.origin );
1316                         trace.origin[ 0 ] += step * (Random() - 0.5) * gridSize[0];
1317                         trace.origin[ 1 ] += step * (Random() - 0.5) * gridSize[1];
1318                         trace.origin[ 2 ] += step * (Random() - 0.5) * gridSize[2];
1319
1320                         /* ydnar: changed to find cluster num */
1321                         trace.cluster = ClusterForPointExt( trace.origin, VERTEX_EPSILON );
1322                         if( trace.cluster >= 0 )
1323                                 break;
1324                 }
1325
1326                 /* can't find a valid point at all */
1327                 if( step > 1.0 )
1328                         return;
1329         }
1330
1331         /* setup trace */
1332         trace.testOcclusion = !noTrace;
1333         trace.forceSunlight = qfalse;
1334         trace.recvShadows = WORLDSPAWN_RECV_SHADOWS;
1335         trace.numSurfaces = 0;
1336         trace.surfaces = NULL;
1337         trace.numLights = 0;
1338         trace.lights = NULL;
1339
1340         /* clear */
1341         numCon = 0;
1342         VectorClear( cheapColor );
1343
1344         /* trace to all the lights, find the major light direction, and divide the
1345            total light between that along the direction and the remaining in the ambient */
1346         for( trace.light = lights; trace.light != NULL; trace.light = trace.light->next )
1347         {
1348                 float           addSize;
1349
1350
1351                 /* sample light */
1352                 if( !LightContributionToPoint( &trace ) )
1353                         continue;
1354
1355                 /* handle negative light */
1356                 if( trace.light->flags & LIGHT_NEGATIVE )
1357                         VectorScale( trace.color, -1.0f, trace.color );
1358
1359                 /* add a contribution */
1360                 VectorCopy( trace.color, contributions[ numCon ].color );
1361                 VectorCopy( trace.direction, contributions[ numCon ].dir );
1362                 contributions[ numCon ].style = trace.light->style;
1363                 numCon++;
1364
1365                 /* push average direction around */
1366                 addSize = VectorLength( trace.color );
1367                 VectorMA( gp->dir, addSize, trace.direction, gp->dir );
1368
1369                 /* stop after a while */
1370                 if( numCon >= (MAX_CONTRIBUTIONS - 1) )
1371                         break;
1372
1373                 /* ydnar: cheap mode */
1374                 VectorAdd( cheapColor, trace.color, cheapColor );
1375                 if( cheapgrid && cheapColor[ 0 ] >= 255.0f && cheapColor[ 1 ] >= 255.0f && cheapColor[ 2 ] >= 255.0f )
1376                         break;
1377         }
1378
1379         /////// Floodlighting for point //////////////////
1380         //do our floodlight ambient occlusion loop, and add a single contribution based on the brightest dir
1381         if (floodlighty)
1382         {
1383                 int q;
1384                 float addSize,f;
1385                 vec3_t col,dir;
1386                 col[0]=col[1]=col[2]=floodlightIntensity;
1387                 dir[0]=dir[1]=0;
1388                 dir[2]=1;
1389
1390                 trace.testOcclusion = qtrue;
1391                 trace.forceSunlight = qfalse;
1392                 trace.inhibitRadius = DEFAULT_INHIBIT_RADIUS;
1393                 trace.testAll = qtrue;
1394
1395                 for (q=0;q<2;q++)
1396                 {
1397                         if (q==0) //upper hemisphere
1398                         {
1399                                 trace.normal[0]=0;
1400                                 trace.normal[1]=0;
1401                                 trace.normal[2]=1;
1402                         }
1403                         else //lower hemisphere
1404                         {
1405                                 trace.normal[0]=0;
1406                                 trace.normal[1]=0;
1407                                 trace.normal[2]=-1;
1408                         }
1409
1410                         f = FloodLightForSample(&trace, floodlightDistance, floodlight_lowquality);
1411
1412                         contributions[ numCon ].color[0]=col[0]*f;
1413                         contributions[ numCon ].color[1]=col[1]*f;
1414                         contributions[ numCon ].color[2]=col[2]*f;
1415
1416                         contributions[ numCon ].dir[0]=dir[0];
1417                         contributions[ numCon ].dir[1]=dir[1];
1418                         contributions[ numCon ].dir[2]=dir[2];
1419
1420                         contributions[ numCon ].style = 0;
1421                         numCon++;
1422                         /* push average direction around */
1423                         addSize = VectorLength( col );
1424                         VectorMA( gp->dir, addSize, dir, gp->dir );
1425                 }
1426         }
1427         /////////////////////
1428
1429         /* normalize to get primary light direction */
1430         VectorNormalize( gp->dir, thisdir );
1431
1432         /* now that we have identified the primary light direction,
1433            go back and separate all the light into directed and ambient */
1434
1435         numStyles = 1;
1436         for( i = 0; i < numCon; i++ )
1437         {
1438                 /* get relative directed strength */
1439                 d = DotProduct( contributions[ i ].dir, thisdir );
1440                 /* we map 1 to gridDirectionality, and 0 to gridAmbientDirectionality */
1441                 d = gridAmbientDirectionality + d * (gridDirectionality - gridAmbientDirectionality);
1442                 if( d < 0.0f )
1443                         d = 0.0f;
1444
1445                 /* find appropriate style */
1446                 for( j = 0; j < numStyles; j++ )
1447                 {
1448                         if( gp->styles[ j ] == contributions[ i ].style )
1449                                 break;
1450                 }
1451
1452                 /* style not found? */
1453                 if( j >= numStyles )
1454                 {
1455                         /* add a new style */
1456                         if( numStyles < MAX_LIGHTMAPS )
1457                         {
1458                                 gp->styles[ numStyles ] = contributions[ i ].style;
1459                                 bgp->styles[ numStyles ] = contributions[ i ].style;
1460                                 numStyles++;
1461                                 //%     Sys_Printf( "(%d, %d) ", num, contributions[ i ].style );
1462                         }
1463
1464                         /* fallback */
1465                         else
1466                                 j = 0;
1467                 }
1468
1469                 /* add the directed color */
1470                 VectorMA( gp->directed[ j ], d, contributions[ i ].color, gp->directed[ j ] );
1471
1472                 /* ambient light will be at 1/4 the value of directed light */
1473                 /* (ydnar: nuke this in favor of more dramatic lighting?) */
1474                 /* (PM: how about actually making it work? d=1 when it got here for single lights/sun :P */
1475 //              d = 0.25f;
1476                 /* (Hobbes: always setting it to .25 is hardly any better) */
1477                 d = 0.25f * (1.0f - d);
1478                 VectorMA( gp->ambient[ j ], d, contributions[ i ].color, gp->ambient[ j ] );
1479
1480 /*
1481  * div0:
1482  * the total light average = ambient value + 0.25 * sum of all directional values
1483  * we can also get the total light average as 0.25 * the sum of all contributions
1484  *
1485  * 0.25 * sum(contribution_i) == ambient + 0.25 * sum(d_i contribution_i)
1486  *
1487  * THIS YIELDS:
1488  * ambient == 0.25 * sum((1 - d_i) contribution_i)
1489  *
1490  * So, 0.25f * (1.0f - d) IS RIGHT. If you want to tune it, tune d BEFORE.
1491  */
1492         }
1493
1494
1495         /* store off sample */
1496         for( i = 0; i < MAX_LIGHTMAPS; i++ )
1497         {
1498 #if 0
1499                 /* do some fudging to keep the ambient from being too low (2003-07-05: 0.25 -> 0.125) */
1500                 if( !bouncing )
1501                         VectorMA( gp->ambient[ i ], 0.125f, gp->directed[ i ], gp->ambient[ i ] );
1502 #endif
1503
1504                 /* set minimum light and copy off to bytes */
1505                 VectorCopy( gp->ambient[ i ], color );
1506                 for( j = 0; j < 3; j++ )
1507                         if( color[ j ] < minGridLight[ j ] )
1508                                 color[ j ] = minGridLight[ j ];
1509
1510                 /* vortex: apply gridscale and gridambientscale here */
1511                 ColorToBytes( color, bgp->ambient[ i ], gridScale*gridAmbientScale );
1512                 ColorToBytes( gp->directed[ i ], bgp->directed[ i ], gridScale );
1513         }
1514
1515         /* debug code */
1516         #if 0
1517                 //%     Sys_FPrintf( SYS_VRB, "%10d %10d %10d ", &gp->ambient[ 0 ][ 0 ], &gp->ambient[ 0 ][ 1 ], &gp->ambient[ 0 ][ 2 ] );
1518                 Sys_FPrintf( SYS_VRB, "%9d Amb: (%03.1f %03.1f %03.1f) Dir: (%03.1f %03.1f %03.1f)\n",
1519                         num,
1520                         gp->ambient[ 0 ][ 0 ], gp->ambient[ 0 ][ 1 ], gp->ambient[ 0 ][ 2 ],
1521                         gp->directed[ 0 ][ 0 ], gp->directed[ 0 ][ 1 ], gp->directed[ 0 ][ 2 ] );
1522         #endif
1523
1524         /* store direction */
1525         NormalToLatLong( thisdir, bgp->latLong );
1526 }
1527
1528
1529
1530 /*
1531 SetupGrid()
1532 calculates the size of the lightgrid and allocates memory
1533 */
1534
1535 void SetupGrid( void )
1536 {
1537         int                     i, j;
1538         vec3_t          maxs, oldGridSize;
1539         const char      *value;
1540         char            temp[ 64 ];
1541
1542
1543         /* don't do this if not grid lighting */
1544         if( noGridLighting )
1545                 return;
1546
1547         /* ydnar: set grid size */
1548         value = ValueForKey( &entities[ 0 ], "gridsize" );
1549         if( value[ 0 ] != '\0' )
1550                 sscanf( value, "%f %f %f", &gridSize[ 0 ], &gridSize[ 1 ], &gridSize[ 2 ] );
1551
1552         /* quantize it */
1553         VectorCopy( gridSize, oldGridSize );
1554         for( i = 0; i < 3; i++ )
1555                 gridSize[ i ] = gridSize[ i ] >= 8.0f ? floor( gridSize[ i ] ) : 8.0f;
1556
1557         /* ydnar: increase gridSize until grid count is smaller than max allowed */
1558         numRawGridPoints = MAX_MAP_LIGHTGRID + 1;
1559         j = 0;
1560         while( numRawGridPoints > MAX_MAP_LIGHTGRID )
1561         {
1562                 /* get world bounds */
1563                 for( i = 0; i < 3; i++ )
1564                 {
1565                         gridMins[ i ] = gridSize[ i ] * ceil( bspModels[ 0 ].mins[ i ] / gridSize[ i ] );
1566                         maxs[ i ] = gridSize[ i ] * floor( bspModels[ 0 ].maxs[ i ] / gridSize[ i ] );
1567                         gridBounds[ i ] = (maxs[ i ] - gridMins[ i ]) / gridSize[ i ] + 1;
1568                 }
1569
1570                 /* set grid size */
1571                 numRawGridPoints = gridBounds[ 0 ] * gridBounds[ 1 ] * gridBounds[ 2 ];
1572
1573                 /* increase grid size a bit */
1574                 if( numRawGridPoints > MAX_MAP_LIGHTGRID )
1575                         gridSize[ j++ % 3 ] += 16.0f;
1576         }
1577
1578         /* print it */
1579         Sys_Printf( "Grid size = { %1.0f, %1.0f, %1.0f }\n", gridSize[ 0 ], gridSize[ 1 ], gridSize[ 2 ] );
1580
1581         /* different? */
1582         if( !VectorCompare( gridSize, oldGridSize ) )
1583         {
1584                 sprintf( temp, "%.0f %.0f %.0f", gridSize[ 0 ], gridSize[ 1 ], gridSize[ 2 ] );
1585                 SetKeyValue( &entities[ 0 ], "gridsize", (const char*) temp );
1586                 Sys_FPrintf( SYS_VRB, "Storing adjusted grid size\n" );
1587         }
1588
1589         /* 2nd variable. fixme: is this silly? */
1590         numBSPGridPoints = numRawGridPoints;
1591
1592         /* allocate lightgrid */
1593         rawGridPoints = safe_malloc( numRawGridPoints * sizeof( *rawGridPoints ) );
1594         memset( rawGridPoints, 0, numRawGridPoints * sizeof( *rawGridPoints ) );
1595
1596         if( bspGridPoints != NULL )
1597                 free( bspGridPoints );
1598         bspGridPoints = safe_malloc( numBSPGridPoints * sizeof( *bspGridPoints ) );
1599         memset( bspGridPoints, 0, numBSPGridPoints * sizeof( *bspGridPoints ) );
1600
1601         /* clear lightgrid */
1602         for( i = 0; i < numRawGridPoints; i++ )
1603         {
1604                 VectorCopy( ambientColor, rawGridPoints[ i ].ambient[ j ] );
1605                 rawGridPoints[ i ].styles[ 0 ] = LS_NORMAL;
1606                 bspGridPoints[ i ].styles[ 0 ] = LS_NORMAL;
1607                 for( j = 1; j < MAX_LIGHTMAPS; j++ )
1608                 {
1609                         rawGridPoints[ i ].styles[ j ] = LS_NONE;
1610                         bspGridPoints[ i ].styles[ j ] = LS_NONE;
1611                 }
1612         }
1613
1614         /* note it */
1615         Sys_Printf( "%9d grid points\n", numRawGridPoints );
1616 }
1617
1618
1619
1620 /*
1621 LightWorld()
1622 does what it says...
1623 */
1624
1625 void LightWorld( void )
1626 {
1627         vec3_t          color;
1628         float           f;
1629         int                     b, bt;
1630         qboolean        minVertex, minGrid, ps;
1631         const char      *value;
1632
1633
1634         /* ydnar: smooth normals */
1635         if( shade )
1636         {
1637                 Sys_Printf( "--- SmoothNormals ---\n" );
1638                 SmoothNormals();
1639         }
1640
1641         /* determine the number of grid points */
1642         Sys_Printf( "--- SetupGrid ---\n" );
1643         SetupGrid();
1644
1645         /* find the optional minimum lighting values */
1646         GetVectorForKey( &entities[ 0 ], "_color", color );
1647         if( VectorLength( color ) == 0.0f )
1648                 VectorSet( color, 1.0, 1.0, 1.0 );
1649
1650         /* ambient */
1651         f = FloatForKey( &entities[ 0 ], "_ambient" );
1652         if( f == 0.0f )
1653                 f = FloatForKey( &entities[ 0 ], "ambient" );
1654         VectorScale( color, f, ambientColor );
1655
1656         /* minvertexlight */
1657         minVertex = qfalse;
1658         value = ValueForKey( &entities[ 0 ], "_minvertexlight" );
1659         if( value[ 0 ] != '\0' )
1660         {
1661                 minVertex = qtrue;
1662                 f = atof( value );
1663                 VectorScale( color, f, minVertexLight );
1664         }
1665
1666         /* mingridlight */
1667         minGrid = qfalse;
1668         value = ValueForKey( &entities[ 0 ], "_mingridlight" );
1669         if( value[ 0 ] != '\0' )
1670         {
1671                 minGrid = qtrue;
1672                 f = atof( value );
1673                 VectorScale( color, f, minGridLight );
1674         }
1675
1676         /* minlight */
1677         value = ValueForKey( &entities[ 0 ], "_minlight" );
1678         if( value[ 0 ] != '\0' )
1679         {
1680                 f = atof( value );
1681                 VectorScale( color, f, minLight );
1682                 if( minVertex == qfalse )
1683                         VectorScale( color, f, minVertexLight );
1684                 if( minGrid == qfalse )
1685                         VectorScale( color, f, minGridLight );
1686         }
1687
1688         /* create world lights */
1689         Sys_FPrintf( SYS_VRB, "--- CreateLights ---\n" );
1690         CreateEntityLights();
1691         CreateSurfaceLights();
1692         Sys_Printf( "%9d point lights\n", numPointLights );
1693         Sys_Printf( "%9d spotlights\n", numSpotLights );
1694         Sys_Printf( "%9d diffuse (area) lights\n", numDiffuseLights );
1695         Sys_Printf( "%9d sun/sky lights\n", numSunLights );
1696
1697         /* calculate lightgrid */
1698         if( !noGridLighting )
1699         {
1700                 /* ydnar: set up light envelopes */
1701                 SetupEnvelopes( qtrue, fastgrid );
1702
1703                 Sys_Printf( "--- TraceGrid ---\n" );
1704                 inGrid = qtrue;
1705                 RunThreadsOnIndividual( numRawGridPoints, qtrue, TraceGrid );
1706                 inGrid = qfalse;
1707                 Sys_Printf( "%d x %d x %d = %d grid\n",
1708                         gridBounds[ 0 ], gridBounds[ 1 ], gridBounds[ 2 ], numBSPGridPoints );
1709
1710                 /* ydnar: emit statistics on light culling */
1711                 Sys_FPrintf( SYS_VRB, "%9d grid points envelope culled\n", gridEnvelopeCulled );
1712                 Sys_FPrintf( SYS_VRB, "%9d grid points bounds culled\n", gridBoundsCulled );
1713         }
1714
1715         /* slight optimization to remove a sqrt */
1716         subdivideThreshold *= subdivideThreshold;
1717
1718         /* map the world luxels */
1719         Sys_Printf( "--- MapRawLightmap ---\n" );
1720         RunThreadsOnIndividual( numRawLightmaps, qtrue, MapRawLightmap );
1721         Sys_Printf( "%9d luxels\n", numLuxels );
1722         Sys_Printf( "%9d luxels mapped\n", numLuxelsMapped );
1723         Sys_Printf( "%9d luxels occluded\n", numLuxelsOccluded );
1724
1725         /* dirty them up */
1726         if( dirty )
1727         {
1728                 Sys_Printf( "--- DirtyRawLightmap ---\n" );
1729
1730
1731
1732
1733                 RunThreadsOnIndividual( numRawLightmaps, qtrue, DirtyRawLightmap );
1734         }
1735
1736         /* floodlight pass */
1737         FloodlightRawLightmaps();
1738
1739         /* ydnar: set up light envelopes */
1740         SetupEnvelopes( qfalse, fast );
1741
1742         /* light up my world */
1743         lightsPlaneCulled = 0;
1744         lightsEnvelopeCulled = 0;
1745         lightsBoundsCulled = 0;
1746         lightsClusterCulled = 0;
1747
1748         Sys_Printf( "--- IlluminateRawLightmap ---\n" );
1749         RunThreadsOnIndividual( numRawLightmaps, qtrue, IlluminateRawLightmap );
1750         Sys_Printf( "%9d luxels illuminated\n", numLuxelsIlluminated );
1751
1752         StitchSurfaceLightmaps();
1753
1754         Sys_Printf( "--- IlluminateVertexes ---\n" );
1755         RunThreadsOnIndividual( numBSPDrawSurfaces, qtrue, IlluminateVertexes );
1756         Sys_Printf( "%9d vertexes illuminated\n", numVertsIlluminated );
1757
1758         /* ydnar: emit statistics on light culling */
1759         Sys_FPrintf( SYS_VRB, "%9d lights plane culled\n", lightsPlaneCulled );
1760         Sys_FPrintf( SYS_VRB, "%9d lights envelope culled\n", lightsEnvelopeCulled );
1761         Sys_FPrintf( SYS_VRB, "%9d lights bounds culled\n", lightsBoundsCulled );
1762         Sys_FPrintf( SYS_VRB, "%9d lights cluster culled\n", lightsClusterCulled );
1763
1764         /* radiosity */
1765         b = 1;
1766         bt = bounce;
1767         while( bounce > 0 )
1768         {
1769                 /* store off the bsp between bounces */
1770                 StoreSurfaceLightmaps();
1771                 UnparseEntities();
1772                 Sys_Printf( "Writing %s\n", source );
1773                 WriteBSPFile( source );
1774
1775                 /* note it */
1776                 Sys_Printf( "\n--- Radiosity (bounce %d of %d) ---\n", b, bt );
1777
1778                 /* flag bouncing */
1779                 bouncing = qtrue;
1780                 VectorClear( ambientColor );
1781                 floodlighty = qfalse;
1782
1783                 /* generate diffuse lights */
1784                 RadFreeLights();
1785                 RadCreateDiffuseLights();
1786
1787                 /* setup light envelopes */
1788                 SetupEnvelopes( qfalse, fastbounce );
1789                 if( numLights == 0 )
1790                 {
1791                         Sys_Printf( "No diffuse light to calculate, ending radiosity.\n" );
1792                         break;
1793                 }
1794
1795                 /* add to lightgrid */
1796                 if( bouncegrid )
1797                 {
1798                         gridEnvelopeCulled = 0;
1799                         gridBoundsCulled = 0;
1800
1801                         Sys_Printf( "--- BounceGrid ---\n" );
1802                         inGrid = qtrue;
1803                         RunThreadsOnIndividual( numRawGridPoints, qtrue, TraceGrid );
1804                         inGrid = qfalse;
1805                         Sys_FPrintf( SYS_VRB, "%9d grid points envelope culled\n", gridEnvelopeCulled );
1806                         Sys_FPrintf( SYS_VRB, "%9d grid points bounds culled\n", gridBoundsCulled );
1807                 }
1808
1809                 /* light up my world */
1810                 lightsPlaneCulled = 0;
1811                 lightsEnvelopeCulled = 0;
1812                 lightsBoundsCulled = 0;
1813                 lightsClusterCulled = 0;
1814
1815                 Sys_Printf( "--- IlluminateRawLightmap ---\n" );
1816                 RunThreadsOnIndividual( numRawLightmaps, qtrue, IlluminateRawLightmap );
1817                 Sys_Printf( "%9d luxels illuminated\n", numLuxelsIlluminated );
1818                 Sys_Printf( "%9d vertexes illuminated\n", numVertsIlluminated );
1819
1820                 StitchSurfaceLightmaps();
1821
1822                 Sys_Printf( "--- IlluminateVertexes ---\n" );
1823                 RunThreadsOnIndividual( numBSPDrawSurfaces, qtrue, IlluminateVertexes );
1824                 Sys_Printf( "%9d vertexes illuminated\n", numVertsIlluminated );
1825
1826                 /* ydnar: emit statistics on light culling */
1827                 Sys_FPrintf( SYS_VRB, "%9d lights plane culled\n", lightsPlaneCulled );
1828                 Sys_FPrintf( SYS_VRB, "%9d lights envelope culled\n", lightsEnvelopeCulled );
1829                 Sys_FPrintf( SYS_VRB, "%9d lights bounds culled\n", lightsBoundsCulled );
1830                 Sys_FPrintf( SYS_VRB, "%9d lights cluster culled\n", lightsClusterCulled );
1831
1832                 /* interate */
1833                 bounce--;
1834                 b++;
1835         }
1836 }
1837
1838
1839
1840 /*
1841 LightMain()
1842 main routine for light processing
1843 */
1844
1845 int LightMain( int argc, char **argv )
1846 {
1847         int                     i;
1848         float           f;
1849         char            mapSource[ 1024 ];
1850         const char      *value;
1851         int lightmapMergeSize = 0;
1852
1853
1854         /* note it */
1855         Sys_Printf( "--- Light ---\n" );
1856         Sys_Printf( "--- ProcessGameSpecific ---\n" );
1857
1858         /* set standard game flags */
1859         wolfLight = game->wolfLight;
1860         if (wolfLight == qtrue)
1861                 Sys_Printf( " lightning model: wolf\n" );
1862         else
1863                 Sys_Printf( " lightning model: quake3\n" );
1864
1865         lmCustomSize = game->lightmapSize;
1866         Sys_Printf( " lightmap size: %d x %d pixels\n", lmCustomSize, lmCustomSize );
1867
1868         lightmapGamma = game->lightmapGamma;
1869         Sys_Printf( " lightning gamma: %f\n", lightmapGamma );
1870
1871         lightmapCompensate = game->lightmapCompensate;
1872         Sys_Printf( " lightning compensation: %f\n", lightmapCompensate );
1873
1874         lightmapExposure = game->lightmapExposure;
1875         Sys_Printf( " lightning exposure: %f\n", lightmapExposure );
1876
1877         gridScale = game->gridScale;
1878         Sys_Printf( " lightgrid scale: %f\n", gridScale );
1879
1880         gridAmbientScale = game->gridAmbientScale;
1881         Sys_Printf( " lightgrid ambient scale: %f\n", gridAmbientScale );
1882
1883         noStyles = game->noStyles;
1884         if (noStyles == qtrue)
1885                 Sys_Printf( " shader lightstyles hack: disabled\n" );
1886         else
1887                 Sys_Printf( " shader lightstyles hack: enabled\n" );
1888
1889         keepLights = game->keepLights;
1890         if (keepLights == qtrue)
1891                 Sys_Printf( " keep lights: enabled\n" );
1892         else
1893                 Sys_Printf( " keep lights: disabled\n" );
1894
1895         patchShadows = game->patchShadows;
1896         if (patchShadows == qtrue)
1897                 Sys_Printf( " patch shadows: enabled\n" );
1898         else
1899                 Sys_Printf( " patch shadows: disabled\n" );
1900
1901         deluxemap = game->deluxeMap;
1902         deluxemode = game->deluxeMode;
1903         if (deluxemap == qtrue)
1904         {
1905                 if (deluxemode)
1906                         Sys_Printf( " deluxemapping: enabled with tangentspace deluxemaps\n" );
1907                 else
1908                         Sys_Printf( " deluxemapping: enabled with modelspace deluxemaps\n" );
1909         }
1910         else
1911                 Sys_Printf( " deluxemapping: disabled\n" );
1912
1913         Sys_Printf( "--- ProcessCommandLine ---\n" );
1914
1915         /* process commandline arguments */
1916         for( i = 1; i < (argc - 1); i++ )
1917         {
1918                 /* lightsource scaling */
1919                 if( !strcmp( argv[ i ], "-point" ) || !strcmp( argv[ i ], "-pointscale" ) )
1920                 {
1921                         f = atof( argv[ i + 1 ] );
1922                         pointScale *= f;
1923                         Sys_Printf( "Point (entity) light scaled by %f to %f\n", f, pointScale );
1924                         i++;
1925                 }
1926
1927                 else if( !strcmp( argv[ i ], "-area" ) || !strcmp( argv[ i ], "-areascale" ) )
1928                 {
1929                         f = atof( argv[ i + 1 ] );
1930                         areaScale *= f;
1931                         Sys_Printf( "Area (shader) light scaled by %f to %f\n", f, areaScale );
1932                         i++;
1933                 }
1934
1935                 else if( !strcmp( argv[ i ], "-sky" ) || !strcmp( argv[ i ], "-skyscale" ) )
1936                 {
1937                         f = atof( argv[ i + 1 ] );
1938                         skyScale *= f;
1939                         Sys_Printf( "Sky/sun light scaled by %f to %f\n", f, skyScale );
1940                         i++;
1941                 }
1942
1943                 else if( !strcmp( argv[ i ], "-bouncescale" ) )
1944                 {
1945                         f = atof( argv[ i + 1 ] );
1946                         bounceScale *= f;
1947                         Sys_Printf( "Bounce (radiosity) light scaled by %f to %f\n", f, bounceScale );
1948                         i++;
1949                 }
1950
1951                 else if( !strcmp( argv[ i ], "-scale" ) )
1952                 {
1953                         f = atof( argv[ i + 1 ] );
1954                         pointScale *= f;
1955                         areaScale *= f;
1956                         skyScale *= f;
1957                         bounceScale *= f;
1958                         Sys_Printf( "All light scaled by %f\n", f );
1959                         i++;
1960                 }
1961
1962                 else if( !strcmp( argv[ i ], "-gridscale" ) )
1963                 {
1964                         f = atof( argv[ i + 1 ] );
1965                         Sys_Printf( "Grid lightning scaled by %f\n", f );
1966                         gridScale *= f;
1967                         i++;
1968                 }
1969
1970                 else if( !strcmp( argv[ i ], "-gridambientscale" ) )
1971                 {
1972                         f = atof( argv[ i + 1 ] );
1973                         Sys_Printf( "Grid ambient lightning scaled by %f\n", f );
1974                         gridAmbientScale *= f;
1975                         i++;
1976                 }
1977
1978                 else if( !strcmp( argv[ i ], "-griddirectionality" ) )
1979                 {
1980                         f = atof( argv[ i + 1 ] );
1981                         if(f < 0) f = 0;
1982                         if(f > gridAmbientDirectionality) f = gridAmbientDirectionality;
1983                         Sys_Printf( "Grid directionality is %f\n", f );
1984                         gridDirectionality *= f;
1985                         i++;
1986                 }
1987
1988                 else if( !strcmp( argv[ i ], "-gridambientdirectionality" ) )
1989                 {
1990                         f = atof( argv[ i + 1 ] );
1991                         if(f > gridDirectionality) f = gridDirectionality;
1992                         if(f > 1) f = 1;
1993                         Sys_Printf( "Grid ambient directionality is %f\n", f );
1994                         gridAmbientDirectionality *= f;
1995                         i++;
1996                 }
1997
1998                 else if( !strcmp( argv[ i ], "-gamma" ) )
1999                 {
2000                         f = atof( argv[ i + 1 ] );
2001                         lightmapGamma = f;
2002                         Sys_Printf( "Lighting gamma set to %f\n", lightmapGamma );
2003                         i++;
2004                 }
2005
2006                 else if( !strcmp( argv[ i ], "-exposure" ) )
2007                 {
2008                         f = atof( argv[ i + 1 ] );
2009                         lightmapExposure = f;
2010                         Sys_Printf( "Lighting exposure set to %f\n", lightmapExposure );
2011                         i++;
2012                 }
2013
2014                 else if( !strcmp( argv[ i ], "-compensate" ) )
2015                 {
2016                         f = atof( argv[ i + 1 ] );
2017                         if( f <= 0.0f )
2018                                 f = 1.0f;
2019                         lightmapCompensate = f;
2020                         Sys_Printf( "Lighting compensation set to 1/%f\n", lightmapCompensate );
2021                         i++;
2022                 }
2023
2024                 /* ydnar switches */
2025                 else if( !strcmp( argv[ i ], "-bounce" ) )
2026                 {
2027                         bounce = atoi( argv[ i + 1 ] );
2028                         if( bounce < 0 )
2029                                 bounce = 0;
2030                         else if( bounce > 0 )
2031                                 Sys_Printf( "Radiosity enabled with %d bounce(s)\n", bounce );
2032                         i++;
2033                 }
2034
2035                 else if( !strcmp( argv[ i ], "-supersample" ) || !strcmp( argv[ i ], "-super" ) )
2036                 {
2037                         superSample = atoi( argv[ i + 1 ] );
2038                         if( superSample < 1 )
2039                                 superSample = 1;
2040                         else if( superSample > 1 )
2041                                 Sys_Printf( "Ordered-grid supersampling enabled with %d sample(s) per lightmap texel\n", (superSample * superSample) );
2042                         i++;
2043                 }
2044
2045                 else if( !strcmp( argv[ i ], "-samples" ) )
2046                 {
2047                         lightSamples = atoi( argv[ i + 1 ] );
2048                         if( lightSamples < 1 )
2049                                 lightSamples = 1;
2050                         else if( lightSamples > 1 )
2051                                 Sys_Printf( "Adaptive supersampling enabled with %d sample(s) per lightmap texel\n", lightSamples );
2052                         i++;
2053                 }
2054
2055                 else if( !strcmp( argv[ i ], "-filter" ) )
2056                 {
2057                         filter = qtrue;
2058                         Sys_Printf( "Lightmap filtering enabled\n" );
2059                 }
2060
2061                 else if( !strcmp( argv[ i ], "-dark" ) )
2062                 {
2063                         dark = qtrue;
2064                         Sys_Printf( "Dark lightmap seams enabled\n" );
2065                 }
2066
2067                 else if( !strcmp( argv[ i ], "-shadeangle" ) )
2068                 {
2069                         shadeAngleDegrees = atof( argv[ i + 1 ] );
2070                         if( shadeAngleDegrees < 0.0f )
2071                                 shadeAngleDegrees = 0.0f;
2072                         else if( shadeAngleDegrees > 0.0f )
2073                         {
2074                                 shade = qtrue;
2075                                 Sys_Printf( "Phong shading enabled with a breaking angle of %f degrees\n", shadeAngleDegrees );
2076                         }
2077                         i++;
2078                 }
2079
2080                 else if( !strcmp( argv[ i ], "-thresh" ) )
2081                 {
2082                         subdivideThreshold = atof( argv[ i + 1 ] );
2083                         if( subdivideThreshold < 0 )
2084                                 subdivideThreshold = DEFAULT_SUBDIVIDE_THRESHOLD;
2085                         else
2086                                 Sys_Printf( "Subdivision threshold set at %.3f\n", subdivideThreshold );
2087                         i++;
2088                 }
2089
2090                 else if( !strcmp( argv[ i ], "-approx" ) )
2091                 {
2092                         approximateTolerance = atoi( argv[ i + 1 ] );
2093                         if( approximateTolerance < 0 )
2094                                 approximateTolerance = 0;
2095                         else if( approximateTolerance > 0 )
2096                                 Sys_Printf( "Approximating lightmaps within a byte tolerance of %d\n", approximateTolerance );
2097                         i++;
2098                 }
2099                 else if( !strcmp( argv[ i ], "-deluxe" ) || !strcmp( argv[ i ], "-deluxemap" ) )
2100                 {
2101                         deluxemap = qtrue;
2102                         Sys_Printf( "Generating deluxemaps for average light direction\n" );
2103                 }
2104                 else if( !strcmp( argv[ i ], "-deluxemode" ))
2105                 {
2106                         deluxemode = atoi( argv[ i + 1 ] );
2107                         if (deluxemode == 0 || deluxemode > 1 || deluxemode < 0)
2108                         {
2109                                 Sys_Printf( "Generating modelspace deluxemaps\n" );
2110                                 deluxemode = 0;
2111                         }
2112                         else
2113                                 Sys_Printf( "Generating tangentspace deluxemaps\n" );
2114                         i++;
2115                 }
2116                 else if( !strcmp( argv[ i ], "-nodeluxe" ) || !strcmp( argv[ i ], "-nodeluxemap" ) )
2117                 {
2118                         deluxemap = qfalse;
2119                         Sys_Printf( "Disabling generating of deluxemaps for average light direction\n" );
2120                 }
2121                 else if( !strcmp( argv[ i ], "-external" ) )
2122                 {
2123                         externalLightmaps = qtrue;
2124                         Sys_Printf( "Storing all lightmaps externally\n" );
2125                 }
2126
2127                 else if( !strcmp( argv[ i ], "-lightmapsize" ) )
2128                 {
2129                         lmCustomSize = atoi( argv[ i + 1 ] );
2130
2131                         /* must be a power of 2 and greater than 2 */
2132                         if( ((lmCustomSize - 1) & lmCustomSize) || lmCustomSize < 2 )
2133                         {
2134                                 Sys_Printf( "WARNING: Lightmap size must be a power of 2, greater or equal to 2 pixels.\n" );
2135                                 lmCustomSize = game->lightmapSize;
2136                         }
2137                         i++;
2138                         Sys_Printf( "Default lightmap size set to %d x %d pixels\n", lmCustomSize, lmCustomSize );
2139
2140                         /* enable external lightmaps */
2141                         if( lmCustomSize != game->lightmapSize )
2142                         {
2143                                 externalLightmaps = qtrue;
2144                                 Sys_Printf( "Storing all lightmaps externally\n" );
2145                         }
2146                 }
2147
2148                 else if( !strcmp( argv[ i ], "-rawlightmapsizelimit" ) )
2149                 {
2150                         lmLimitSize = atoi( argv[ i + 1 ] );
2151
2152                         i++;
2153                         Sys_Printf( "Raw lightmap size limit set to %d x %d pixels\n", lmLimitSize, lmLimitSize );
2154                 }
2155
2156                 else if( !strcmp( argv[ i ], "-lightmapdir" ) )
2157                 {
2158                         lmCustomDir = argv[i + 1];
2159                         i++;
2160                         Sys_Printf( "Lightmap directory set to %s\n", lmCustomDir );
2161                         externalLightmaps = qtrue;
2162                         Sys_Printf( "Storing all lightmaps externally\n" );
2163                 }
2164
2165                 /* ydnar: add this to suppress warnings */
2166                 else if( !strcmp( argv[ i ],  "-custinfoparms") )
2167                 {
2168                         Sys_Printf( "Custom info parms enabled\n" );
2169                         useCustomInfoParms = qtrue;
2170                 }
2171
2172                 else if( !strcmp( argv[ i ], "-wolf" ) )
2173                 {
2174                         /* -game should already be set */
2175                         wolfLight = qtrue;
2176                         Sys_Printf( "Enabling Wolf lighting model (linear default)\n" );
2177                 }
2178
2179                 else if( !strcmp( argv[ i ], "-q3" ) )
2180                 {
2181                         /* -game should already be set */
2182                         wolfLight = qfalse;
2183                         Sys_Printf( "Enabling Quake 3 lighting model (nonlinear default)\n" );
2184                 }
2185
2186                 else if( !strcmp( argv[ i ], "-sunonly" ) )
2187                 {
2188                         sunOnly = qtrue;
2189                         Sys_Printf( "Only computing sunlight\n" );
2190                 }
2191
2192                 else if( !strcmp( argv[ i ], "-bounceonly" ) )
2193                 {
2194                         bounceOnly = qtrue;
2195                         Sys_Printf( "Storing bounced light (radiosity) only\n" );
2196                 }
2197
2198                 else if( !strcmp( argv[ i ], "-nocollapse" ) )
2199                 {
2200                         noCollapse = qtrue;
2201                         Sys_Printf( "Identical lightmap collapsing disabled\n" );
2202                 }
2203
2204                 else if( !strcmp( argv[ i ], "-nolightmapsearch" ) )
2205                 {
2206                         lightmapSearchBlockSize = 1;
2207                         Sys_Printf( "No lightmap searching - all lightmaps will be sequential\n" );
2208                 }
2209
2210                 else if( !strcmp( argv[ i ], "-lightmapsearchpower" ) )
2211                 {
2212                         lightmapMergeSize = (game->lightmapSize << atoi(argv[i+1]));
2213                         ++i;
2214                         Sys_Printf( "Restricted lightmap searching enabled - optimize for lightmap merge power %d (size %d)\n", atoi(argv[i]), lightmapMergeSize );
2215                 }
2216
2217                 else if( !strcmp( argv[ i ], "-lightmapsearchblocksize" ) )
2218                 {
2219                         lightmapSearchBlockSize = atoi(argv[i+1]);
2220                         ++i;
2221                         Sys_Printf( "Restricted lightmap searching enabled - block size set to %d\n", lightmapSearchBlockSize );
2222                 }
2223
2224                 else if( !strcmp( argv[ i ], "-shade" ) )
2225                 {
2226                         shade = qtrue;
2227                         Sys_Printf( "Phong shading enabled\n" );
2228                 }
2229
2230                 else if( !strcmp( argv[ i ], "-bouncegrid") )
2231                 {
2232                         bouncegrid = qtrue;
2233                         if( bounce > 0 )
2234                                 Sys_Printf( "Grid lighting with radiosity enabled\n" );
2235                 }
2236
2237                 else if( !strcmp( argv[ i ], "-smooth" ) )
2238                 {
2239                         lightSamples = EXTRA_SCALE;
2240                         Sys_Printf( "The -smooth argument is deprecated, use \"-samples 2\" instead\n" );
2241                 }
2242
2243                 else if( !strcmp( argv[ i ], "-fast" ) )
2244                 {
2245                         fast = qtrue;
2246                         fastgrid = qtrue;
2247                         fastbounce = qtrue;
2248                         Sys_Printf( "Fast mode enabled\n" );
2249                 }
2250
2251                 else if( !strcmp( argv[ i ], "-faster" ) )
2252                 {
2253                         faster = qtrue;
2254                         fast = qtrue;
2255                         fastgrid = qtrue;
2256                         fastbounce = qtrue;
2257                         Sys_Printf( "Faster mode enabled\n" );
2258                 }
2259
2260                 else if( !strcmp( argv[ i ], "-fastgrid" ) )
2261                 {
2262                         fastgrid = qtrue;
2263                         Sys_Printf( "Fast grid lighting enabled\n" );
2264                 }
2265
2266                 else if( !strcmp( argv[ i ], "-fastbounce" ) )
2267                 {
2268                         fastbounce = qtrue;
2269                         Sys_Printf( "Fast bounce mode enabled\n" );
2270                 }
2271
2272                 else if( !strcmp( argv[ i ], "-cheap" ) )
2273                 {
2274                         cheap = qtrue;
2275                         cheapgrid = qtrue;
2276                         Sys_Printf( "Cheap mode enabled\n" );
2277                 }
2278
2279                 else if( !strcmp( argv[ i ], "-cheapgrid" ) )
2280                 {
2281                         cheapgrid = qtrue;
2282                         Sys_Printf( "Cheap grid mode enabled\n" );
2283                 }
2284
2285                 else if( !strcmp( argv[ i ], "-normalmap" ) )
2286                 {
2287                         normalmap = qtrue;
2288                         Sys_Printf( "Storing normal map instead of lightmap\n" );
2289                 }
2290
2291                 else if( !strcmp( argv[ i ], "-trisoup" ) )
2292                 {
2293                         trisoup = qtrue;
2294                         Sys_Printf( "Converting brush faces to triangle soup\n" );
2295                 }
2296
2297                 else if( !strcmp( argv[ i ], "-debug" ) )
2298                 {
2299                         debug = qtrue;
2300                         Sys_Printf( "Lightmap debugging enabled\n" );
2301                 }
2302
2303                 else if( !strcmp( argv[ i ], "-debugsurfaces" ) || !strcmp( argv[ i ], "-debugsurface" ) )
2304                 {
2305                         debugSurfaces = qtrue;
2306                         Sys_Printf( "Lightmap surface debugging enabled\n" );
2307                 }
2308
2309                 else if( !strcmp( argv[ i ], "-debugunused" ) )
2310                 {
2311                         debugUnused = qtrue;
2312                         Sys_Printf( "Unused luxel debugging enabled\n" );
2313                 }
2314
2315                 else if( !strcmp( argv[ i ], "-debugaxis" ) )
2316                 {
2317                         debugAxis = qtrue;
2318                         Sys_Printf( "Lightmap axis debugging enabled\n" );
2319                 }
2320
2321                 else if( !strcmp( argv[ i ], "-debugcluster" ) )
2322                 {
2323                         debugCluster = qtrue;
2324                         Sys_Printf( "Luxel cluster debugging enabled\n" );
2325                 }
2326
2327                 else if( !strcmp( argv[ i ], "-debugorigin" ) )
2328                 {
2329                         debugOrigin = qtrue;
2330                         Sys_Printf( "Luxel origin debugging enabled\n" );
2331                 }
2332
2333                 else if( !strcmp( argv[ i ], "-debugdeluxe" ) )
2334                 {
2335                         deluxemap = qtrue;
2336                         debugDeluxemap = qtrue;
2337                         Sys_Printf( "Deluxemap debugging enabled\n" );
2338                 }
2339
2340                 else if( !strcmp( argv[ i ], "-export" ) )
2341                 {
2342                         exportLightmaps = qtrue;
2343                         Sys_Printf( "Exporting lightmaps\n" );
2344                 }
2345
2346                 else if( !strcmp(argv[ i ], "-notrace" ))
2347                 {
2348                         noTrace = qtrue;
2349                         Sys_Printf( "Shadow occlusion disabled\n" );
2350                 }
2351                 else if( !strcmp(argv[ i ], "-patchshadows" ) )
2352                 {
2353                         patchShadows = qtrue;
2354                         Sys_Printf( "Patch shadow casting enabled\n" );
2355                 }
2356                 else if( !strcmp( argv[ i ], "-extra" ) )
2357                 {
2358                         superSample = EXTRA_SCALE;              /* ydnar */
2359                         Sys_Printf( "The -extra argument is deprecated, use \"-super 2\" instead\n" );
2360                 }
2361                 else if( !strcmp( argv[ i ], "-extrawide" ) )
2362                 {
2363                         superSample = EXTRAWIDE_SCALE;  /* ydnar */
2364                         filter = qtrue;                                 /* ydnar */
2365                         Sys_Printf( "The -extrawide argument is deprecated, use \"-filter [-super 2]\" instead\n");
2366                 }
2367                 else if( !strcmp( argv[ i ], "-samplesize" ) )
2368                 {
2369                         sampleSize = atoi( argv[ i + 1 ] );
2370                         if( sampleSize < 1 )
2371                                 sampleSize = 1;
2372                         i++;
2373                         Sys_Printf( "Default lightmap sample size set to %dx%d units\n", sampleSize, sampleSize );
2374                 }
2375                 else if( !strcmp( argv[ i ], "-minsamplesize" ) )
2376                 {
2377                         minSampleSize = atoi( argv[ i + 1 ] );
2378                         if( minSampleSize < 1 )
2379                                 minSampleSize = 1;
2380                         i++;
2381                         Sys_Printf( "Minimum lightmap sample size set to %dx%d units\n", minSampleSize, minSampleSize );
2382                 }
2383                 else if( !strcmp( argv[ i ],  "-samplescale" ) )
2384                 {
2385                         sampleScale = atoi( argv[ i + 1 ] );
2386                         i++;
2387                         Sys_Printf( "Lightmaps sample scale set to %d\n", sampleScale);
2388                 }
2389                 else if( !strcmp( argv[ i ], "-novertex" ) )
2390                 {
2391                         noVertexLighting = qtrue;
2392                         Sys_Printf( "Disabling vertex lighting\n" );
2393                 }
2394                 else if( !strcmp( argv[ i ], "-nogrid" ) )
2395                 {
2396                         noGridLighting = qtrue;
2397                         Sys_Printf( "Disabling grid lighting\n" );
2398                 }
2399                 else if( !strcmp( argv[ i ], "-border" ) )
2400                 {
2401                         lightmapBorder = qtrue;
2402                         Sys_Printf( "Adding debug border to lightmaps\n" );
2403                 }
2404                 else if( !strcmp( argv[ i ], "-nosurf" ) )
2405                 {
2406                         noSurfaces = qtrue;
2407                         Sys_Printf( "Not tracing against surfaces\n" );
2408                 }
2409                 else if( !strcmp( argv[ i ], "-dump" ) )
2410                 {
2411                         dump = qtrue;
2412                         Sys_Printf( "Dumping radiosity lights into numbered prefabs\n" );
2413                 }
2414                 else if( !strcmp( argv[ i ], "-lomem" ) )
2415                 {
2416                         loMem = qtrue;
2417                         Sys_Printf( "Enabling low-memory (potentially slower) lighting mode\n" );
2418                 }
2419                 else if( !strcmp( argv[ i ], "-nostyle" ) || !strcmp( argv[ i ], "-nostyles" ) )
2420                 {
2421                         noStyles = qtrue;
2422                         Sys_Printf( "Disabling lightstyles\n" );
2423                 }
2424                 else if( !strcmp( argv[ i ], "-style" ) || !strcmp( argv[ i ], "-styles" ) )
2425                 {
2426                         noStyles = qfalse;
2427                         Sys_Printf( "Enabling lightstyles\n" );
2428                 }
2429                 else if( !strcmp( argv[ i ], "-keeplights" ))
2430                 {
2431                         keepLights = qtrue;
2432                         Sys_Printf( "Leaving light entities on map after compile\n" );
2433                 }
2434                 else if( !strcmp( argv[ i ], "-cpma" ) )
2435                 {
2436                         cpmaHack = qtrue;
2437                         Sys_Printf( "Enabling Challenge Pro Mode Asstacular Vertex Lighting Mode (tm)\n" );
2438                 }
2439                 else if( !strcmp( argv[ i ], "-floodlight" ) )
2440                 {
2441                         floodlighty = qtrue;
2442                         Sys_Printf( "FloodLighting enabled\n" );
2443                 }
2444                 else if( !strcmp( argv[ i ], "-debugnormals" ) )
2445                 {
2446                         debugnormals = qtrue;
2447                         Sys_Printf( "DebugNormals enabled\n" );
2448                 }
2449                 else if( !strcmp( argv[ i ], "-lowquality" ) )
2450                 {
2451                         floodlight_lowquality = qtrue;
2452                         Sys_Printf( "Low Quality FloodLighting enabled\n" );
2453                 }
2454
2455                 /* r7: dirtmapping */
2456                 else if( !strcmp( argv[ i ], "-dirty" ) )
2457                 {
2458                         dirty = qtrue;
2459                         Sys_Printf( "Dirtmapping enabled\n" );
2460                 }
2461                 else if( !strcmp( argv[ i ], "-dirtdebug" ) || !strcmp( argv[ i ], "-debugdirt" ) )
2462                 {
2463                         dirtDebug = qtrue;
2464                         Sys_Printf( "Dirtmap debugging enabled\n" );
2465                 }
2466                 else if( !strcmp( argv[ i ], "-dirtmode" ) )
2467                 {
2468                         dirtMode = atoi( argv[ i + 1 ] );
2469                         if( dirtMode != 0 && dirtMode != 1 )
2470                                 dirtMode = 0;
2471                         if( dirtMode == 1 )
2472                                 Sys_Printf( "Enabling randomized dirtmapping\n" );
2473                         else
2474                                 Sys_Printf( "Enabling ordered dir mapping\n" );
2475                         i++;
2476                 }
2477                 else if( !strcmp( argv[ i ], "-dirtdepth" ) )
2478                 {
2479                         dirtDepth = atof( argv[ i + 1 ] );
2480                         if( dirtDepth <= 0.0f )
2481                                 dirtDepth = 128.0f;
2482                         Sys_Printf( "Dirtmapping depth set to %.1f\n", dirtDepth );
2483                         i++;
2484                 }
2485                 else if( !strcmp( argv[ i ], "-dirtscale" ) )
2486                 {
2487                         dirtScale = atof( argv[ i + 1 ] );
2488                         if( dirtScale <= 0.0f )
2489                                 dirtScale = 1.0f;
2490                         Sys_Printf( "Dirtmapping scale set to %.1f\n", dirtScale );
2491                         i++;
2492                 }
2493                 else if( !strcmp( argv[ i ], "-dirtgain" ) )
2494                 {
2495                         dirtGain = atof( argv[ i + 1 ] );
2496                         if( dirtGain <= 0.0f )
2497                                 dirtGain = 1.0f;
2498                         Sys_Printf( "Dirtmapping gain set to %.1f\n", dirtGain );
2499                         i++;
2500                 }
2501                 else if( !strcmp( argv[ i ], "-trianglecheck" ) )
2502                 {
2503                         lightmapTriangleCheck = qtrue;
2504                 }
2505                 else if( !strcmp( argv[ i ], "-extravisnudge" ) )
2506                 {
2507                         lightmapExtraVisClusterNudge = qtrue;
2508                 }
2509                 /* unhandled args */
2510                 else
2511                 {
2512                         Sys_Printf( "WARNING: Unknown argument \"%s\"\n", argv[ i ] );
2513                 }
2514
2515         }
2516
2517         /* fix up lightmap search power */
2518         if(lightmapMergeSize)
2519         {
2520                 lightmapSearchBlockSize = (lightmapMergeSize / lmCustomSize) * (lightmapMergeSize / lmCustomSize);
2521                 if(lightmapSearchBlockSize < 1)
2522                         lightmapSearchBlockSize = 1;
2523
2524                 Sys_Printf( "Restricted lightmap searching enabled - block size adjusted to %d\n", lightmapSearchBlockSize );
2525         }
2526
2527         /* clean up map name */
2528         strcpy( source, ExpandArg( argv[ i ] ) );
2529         StripExtension( source );
2530         DefaultExtension( source, ".bsp" );
2531         strcpy( mapSource, ExpandArg( argv[ i ] ) );
2532         StripExtension( mapSource );
2533         DefaultExtension( mapSource, ".map" );
2534
2535         /* ydnar: set default sample size */
2536         SetDefaultSampleSize( sampleSize );
2537
2538         /* ydnar: handle shaders */
2539         BeginMapShaderFile( source );
2540         LoadShaderInfo();
2541
2542         /* note loading */
2543         Sys_Printf( "Loading %s\n", source );
2544
2545         /* ydnar: load surface file */
2546         LoadSurfaceExtraFile( source );
2547
2548         /* load bsp file */
2549         LoadBSPFile( source );
2550
2551         /* parse bsp entities */
2552         ParseEntities();
2553
2554         /* inject command line parameters */
2555         InjectCommandLine(argv, 0, argc - 1);
2556
2557         /* load map file */
2558         value = ValueForKey( &entities[ 0 ], "_keepLights" );
2559         if( value[ 0 ] != '1' )
2560                 LoadMapFile( mapSource, qtrue );
2561
2562         /* set the entity/model origins and init yDrawVerts */
2563         SetEntityOrigins();
2564
2565         /* ydnar: set up optimization */
2566         SetupBrushes();
2567         SetupDirt();
2568         SetupFloodLight();
2569         SetupSurfaceLightmaps();
2570
2571         /* initialize the surface facet tracing */
2572         SetupTraceNodes();
2573
2574         /* light the world */
2575         LightWorld();
2576
2577         /* ydnar: store off lightmaps */
2578         StoreSurfaceLightmaps();
2579
2580         /* write out the bsp */
2581         UnparseEntities();
2582         Sys_Printf( "Writing %s\n", source );
2583         WriteBSPFile( source );
2584
2585         /* ydnar: export lightmaps */
2586         if( exportLightmaps && !externalLightmaps )
2587                 ExportLightmaps();
2588
2589         /* return to sender */
2590         return 0;
2591 }
2592