misc/source/netradiant-src/tools/quake3/q3map2/light_bounce.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_BOUNCE_C
  33
  34
  35
  36 /* dependencies */
  37 #include "q3map2.h"
  38
  39
  40
  41 /* functions */
  42
  43 /*
  44 RadFreeLights()
  45 deletes any existing lights, freeing up memory for the next bounce
  46 */
  47
  48 void RadFreeLights( void )
  49 {
  50         light_t         *light, *next;
  51
  52
  53         /* delete lights */
  54         for( light = lights; light; light = next )
  55         {
  56                 next = light->next;
  57                 if( light->w != NULL )
  58                         FreeWinding( light->w );
  59                 free( light );
  60         }
  61         numLights = 0;
  62         lights = NULL;
  63 }
  64
  65
  66
  67 /*
  68 RadClipWindingEpsilon()
  69 clips a rad winding by a plane
  70 based off the regular clip winding code
  71 */
  72
  73 static void RadClipWindingEpsilon( radWinding_t *in, vec3_t normal, vec_t dist,
  74         vec_t epsilon, radWinding_t *front, radWinding_t *back, clipWork_t *cw )
  75 {
  76         vec_t                   *dists;
  77         int                             *sides;
  78         int                             counts[ 3 ];
  79         vec_t                   dot;            /* ydnar: changed from static b/c of threading */ /* VC 4.2 optimizer bug if not static? */
  80         int                             i, j, k;
  81         radVert_t               *v1, *v2, mid;
  82         int                             maxPoints;
  83
  84
  85         /* crutch */
  86         dists = cw->dists;
  87         sides = cw->sides;
  88
  89         /* clear counts */
  90         counts[ 0 ] = counts[ 1 ] = counts[ 2 ] = 0;
  91
  92         /* determine sides for each point */
  93         for( i = 0; i < in->numVerts; i++ )
  94         {
  95                 dot = DotProduct( in->verts[ i ].xyz, normal );
  96                 dot -= dist;
  97                 dists[ i ] = dot;
  98                 if( dot > epsilon )
  99                         sides[ i ] = SIDE_FRONT;
 100                 else if( dot < -epsilon )
 101                         sides[ i ] = SIDE_BACK;
 102                 else
 103                         sides[ i ] = SIDE_ON;
 104                 counts[ sides[ i ] ]++;
 105         }
 106         sides[ i ] = sides[ 0 ];
 107         dists[ i ] = dists[ 0 ];
 108
 109         /* clear front and back */
 110         front->numVerts = back->numVerts = 0;
 111
 112         /* handle all on one side cases */
 113         if( counts[ 0 ] == 0 )
 114         {
 115                 memcpy( back, in, sizeof( radWinding_t ) );
 116                 return;
 117         }
 118         if( counts[ 1 ] == 0 )
 119         {
 120                 memcpy( front, in, sizeof( radWinding_t ) );
 121                 return;
 122         }
 123
 124         /* setup windings */
 125         maxPoints = in->numVerts + 4;
 126
 127         /* do individual verts */
 128         for( i = 0; i < in->numVerts; i++ )
 129         {
 130                 /* do simple vertex copies first */
 131                 v1 = &in->verts[ i ];
 132
 133                 if( sides[ i ] == SIDE_ON )
 134                 {
 135                         memcpy( &front->verts[ front->numVerts++ ], v1, sizeof( radVert_t ) );
 136                         memcpy( &back->verts[ back->numVerts++ ], v1, sizeof( radVert_t ) );
 137                         continue;
 138                 }
 139
 140                 if( sides[ i ] == SIDE_FRONT )
 141                         memcpy( &front->verts[ front->numVerts++ ], v1, sizeof( radVert_t ) );
 142
 143                 if( sides[ i ] == SIDE_BACK )
 144                         memcpy( &back->verts[ back->numVerts++ ], v1, sizeof( radVert_t ) );
 145
 146                 if( sides[ i + 1 ] == SIDE_ON || sides[ i + 1 ] == sides[ i ] )
 147                         continue;
 148
 149                 /* generate a split vertex */
 150                 v2 = &in->verts[ (i + 1) % in->numVerts ];
 151
 152                 dot = dists[ i ] / (dists[ i ] - dists[ i + 1 ]);
 153
 154                 /* average vertex values */
 155                 for( j = 0; j < 4; j++ )
 156                 {
 157                         /* color */
 158                         if( j < 4 )
 159                         {
 160                                 for( k = 0; k < MAX_LIGHTMAPS; k++ )
 161                                         mid.color[ k ][ j ] = v1->color[ k ][ j ] + dot * (v2->color[ k ][ j ] - v1->color[ k ][ j ]);
 162                         }
 163
 164                         /* xyz, normal */
 165                         if( j < 3 )
 166                         {
 167                                 mid.xyz[ j ] = v1->xyz[ j ] + dot * (v2->xyz[ j ] - v1->xyz[ j ]);
 168                                 mid.normal[ j ] = v1->normal[ j ] + dot * (v2->normal[ j ] - v1->normal[ j ]);
 169                         }
 170
 171                         /* st, lightmap */
 172                         if( j < 2 )
 173                         {
 174                                 mid.st[ j ] = v1->st[ j ] + dot * (v2->st[ j ] - v1->st[ j ]);
 175                                 for( k = 0; k < MAX_LIGHTMAPS; k++ )
 176                                         mid.lightmap[ k ][ j ] = v1->lightmap[ k ][ j ] + dot * (v2->lightmap[ k ][ j ] - v1->lightmap[ k ][ j ]);
 177                         }
 178                 }
 179
 180                 /* normalize the averaged normal */
 181                 VectorNormalize( mid.normal, mid.normal );
 182
 183                 /* copy the midpoint to both windings */
 184                 memcpy( &front->verts[ front->numVerts++ ], &mid, sizeof( radVert_t ) );
 185                 memcpy( &back->verts[ back->numVerts++ ], &mid, sizeof( radVert_t ) );
 186         }
 187
 188         /* error check */
 189         if( front->numVerts > maxPoints || front->numVerts > maxPoints )
 190                 Error( "RadClipWindingEpsilon: points exceeded estimate" );
 191         if( front->numVerts > MAX_POINTS_ON_WINDING || front->numVerts > MAX_POINTS_ON_WINDING )
 192                 Error( "RadClipWindingEpsilon: MAX_POINTS_ON_WINDING" );
 193 }
 194
 195
 196
 197
 198
 199 /*
 200 RadSampleImage()
 201 samples a texture image for a given color
 202 returns qfalse if pixels are bad
 203 */
 204
 205 qboolean RadSampleImage( byte *pixels, int width, int height, float st[ 2 ], float color[ 4 ] )
 206 {
 207         float   sto[ 2 ];
 208         int             x, y;
 209
 210
 211         /* clear color first */
 212         color[ 0 ] = color[ 1 ] = color[ 2 ] = color[ 3 ] = 255;
 213
 214         /* dummy check */
 215         if( pixels == NULL || width < 1 || height < 1 )
 216                 return qfalse;
 217
 218         /* bias st */
 219         sto[ 0 ] = st[ 0 ];
 220         while( sto[ 0 ] < 0.0f )
 221                 sto[ 0 ] += 1.0f;
 222         sto[ 1 ] = st[ 1 ];
 223         while( sto[ 1 ] < 0.0f )
 224                 sto[ 1 ] += 1.0f;
 225
 226         /* get offsets */
 227         x = ((float) width * sto[ 0 ]) + 0.5f;
 228         x %= width;
 229         y = ((float) height * sto[ 1 ])  + 0.5f;
 230         y %= height;
 231
 232         /* get pixel */
 233         pixels += (y * width * 4) + (x * 4);
 234         VectorCopy( pixels, color );
 235         color[ 3 ] = pixels[ 3 ];
 236         return qtrue;
 237 }
 238
 239
 240
 241 /*
 242 RadSample()
 243 samples a fragment's lightmap or vertex color and returns an
 244 average color and a color gradient for the sample
 245 */
 246
 247 #define MAX_SAMPLES                     150
 248 #define SAMPLE_GRANULARITY      6
 249
 250 static void RadSample( int lightmapNum, bspDrawSurface_t *ds, rawLightmap_t *lm, shaderInfo_t *si, radWinding_t *rw, vec3_t average, vec3_t gradient, int *style )
 251 {
 252         int                     i, j, k, l, v, x, y, samples;
 253         vec3_t          color, mins, maxs;
 254         vec4_t          textureColor;
 255         float           alpha, alphaI, bf;
 256         vec3_t          blend;
 257         float           st[ 2 ], lightmap[ 2 ], *radLuxel;
 258         radVert_t       *rv[ 3 ];
 259
 260
 261         /* initial setup */
 262         ClearBounds( mins, maxs );
 263         VectorClear( average );
 264         VectorClear( gradient );
 265         alpha = 0;
 266
 267         /* dummy check */
 268         if( rw == NULL || rw->numVerts < 3 )
 269                 return;
 270
 271         /* start sampling */
 272         samples = 0;
 273
 274         /* sample vertex colors if no lightmap or this is the initial pass */
 275         if( lm == NULL || lm->radLuxels[ lightmapNum ] == NULL || bouncing == qfalse )
 276         {
 277                 for( samples = 0; samples < rw->numVerts; samples++ )
 278                 {
 279                         /* multiply by texture color */
 280                         if( !RadSampleImage( si->lightImage->pixels, si->lightImage->width, si->lightImage->height, rw->verts[ samples ].st, textureColor ) )
 281                         {
 282                                 VectorCopy( si->averageColor, textureColor );
 283                                 textureColor[ 4 ] = 255.0f;
 284                         }
 285                         for( i = 0; i < 3; i++ )
 286                                 color[ i ] = (textureColor[ i ] / 255) * (rw->verts[ samples ].color[ lightmapNum ][ i ] / 255.0f);
 287
 288                         AddPointToBounds( color, mins, maxs );
 289                         VectorAdd( average, color, average );
 290
 291                         /* get alpha */
 292                         alpha += (textureColor[ 3 ] / 255.0f) * (rw->verts[ samples ].color[ lightmapNum ][ 3 ] / 255.0f);
 293                 }
 294
 295                 /* set style */
 296                 *style = ds->vertexStyles[ lightmapNum ];
 297         }
 298
 299         /* sample lightmap */
 300         else
 301         {
 302                 /* fracture the winding into a fan (including degenerate tris) */
 303                 for( v = 1; v < (rw->numVerts - 1) && samples < MAX_SAMPLES; v++ )
 304                 {
 305                         /* get a triangle */
 306                         rv[ 0 ] = &rw->verts[ 0 ];
 307                         rv[ 1 ] = &rw->verts[ v ];
 308                         rv[ 2 ] = &rw->verts[ v + 1 ];
 309
 310                         /* this code is embarassing (really should just rasterize the triangle) */
 311                         for( i = 1; i < SAMPLE_GRANULARITY && samples < MAX_SAMPLES; i++ )
 312                         {
 313                                 for( j = 1; j < SAMPLE_GRANULARITY && samples < MAX_SAMPLES; j++ )
 314                                 {
 315                                         for( k = 1; k < SAMPLE_GRANULARITY && samples < MAX_SAMPLES; k++ )
 316                                         {
 317                                                 /* create a blend vector (barycentric coordinates) */
 318                                                 blend[ 0 ] = i;
 319                                                 blend[ 1 ] = j;
 320                                                 blend[ 2 ] = k;
 321                                                 bf = (1.0 / (blend[ 0 ] + blend[ 1 ] + blend[ 2 ]));
 322                                                 VectorScale( blend, bf, blend );
 323
 324                                                 /* create a blended sample */
 325                                                 st[ 0 ] = st[ 1 ] = 0.0f;
 326                                                 lightmap[ 0 ] = lightmap[ 1 ] = 0.0f;
 327                                                 alphaI = 0.0f;
 328                                                 for( l = 0; l < 3; l++ )
 329                                                 {
 330                                                         st[ 0 ] += (rv[ l ]->st[ 0 ] * blend[ l ]);
 331                                                         st[ 1 ] += (rv[ l ]->st[ 1 ] * blend[ l ]);
 332                                                         lightmap[ 0 ] += (rv[ l ]->lightmap[ lightmapNum ][ 0 ] * blend[ l ]);
 333                                                         lightmap[ 1 ] += (rv[ l ]->lightmap[ lightmapNum ][ 1 ] * blend[ l ]);
 334                                                         alphaI += (rv[ l ]->color[ lightmapNum ][ 3 ] * blend[ l ]);
 335                                                 }
 336
 337                                                 /* get lightmap xy coords */
 338                                                 x = lightmap[ 0 ] / (float) superSample;
 339                                                 y = lightmap[ 1 ] / (float) superSample;
 340                                                 if( x < 0 )
 341                                                         x = 0;
 342                                                 else if ( x >= lm->w )
 343                                                         x = lm->w - 1;
 344                                                 if( y < 0 )
 345                                                         y = 0;
 346                                                 else if ( y >= lm->h )
 347                                                         y = lm->h - 1;
 348
 349                                                 /* get radiosity luxel */
 350                                                 radLuxel = RAD_LUXEL( lightmapNum, x, y );
 351
 352                                                 /* ignore unlit/unused luxels */
 353                                                 if( radLuxel[ 0 ] < 0.0f )
 354                                                         continue;
 355
 356                                                 /* inc samples */
 357                                                 samples++;
 358
 359                                                 /* multiply by texture color */
 360                                                 if( !RadSampleImage( si->lightImage->pixels, si->lightImage->width, si->lightImage->height, st, textureColor ) )
 361                                                 {
 362                                                         VectorCopy( si->averageColor, textureColor );
 363                                                         textureColor[ 4 ] = 255;
 364                                                 }
 365                                                 for( i = 0; i < 3; i++ )
 366                                                         color[ i ] = (textureColor[ i ] / 255) * (radLuxel[ i ] / 255);
 367
 368                                                 AddPointToBounds( color, mins, maxs );
 369                                                 VectorAdd( average, color, average );
 370
 371                                                 /* get alpha */
 372                                                 alpha += (textureColor[ 3 ] / 255) * (alphaI / 255);
 373                                         }
 374                                 }
 375                         }
 376                 }
 377
 378                 /* set style */
 379                 *style = ds->lightmapStyles[ lightmapNum ];
 380         }
 381
 382         /* any samples? */
 383         if( samples <= 0 )
 384                 return;
 385
 386         /* average the color */
 387         VectorScale( average, (1.0 / samples), average );
 388
 389         /* create the color gradient */
 390         //%     VectorSubtract( maxs, mins, delta );
 391
 392         /* new: color gradient will always be 0-1.0, expressed as the range of light relative to overall light */
 393         //%     gradient[ 0 ] = maxs[ 0 ] > 0.0f ? (maxs[ 0 ] - mins[ 0 ]) / maxs[ 0 ] : 0.0f;
 394         //%     gradient[ 1 ] = maxs[ 1 ] > 0.0f ? (maxs[ 1 ] - mins[ 1 ]) / maxs[ 1 ] : 0.0f;
 395         //%     gradient[ 2 ] = maxs[ 2 ] > 0.0f ? (maxs[ 2 ] - mins[ 2 ]) / maxs[ 2 ] : 0.0f;
 396
 397         /* newer: another contrast function */
 398         for( i = 0; i < 3; i++ )
 399                 gradient[ i ] = (maxs[ i ] - mins[ i ]) * maxs[ i ];
 400 }
 401
 402
 403
 404 /*
 405 RadSubdivideDiffuseLight()
 406 subdivides a radiosity winding until it is smaller than subdivide, then generates an area light
 407 */
 408
 409 #define RADIOSITY_MAX_GRADIENT          0.75f   //%     0.25f
 410 #define RADIOSITY_VALUE                         500.0f
 411 #define RADIOSITY_MIN                           0.0001f
 412 #define RADIOSITY_CLIP_EPSILON          0.125f
 413
 414 static void RadSubdivideDiffuseLight( int lightmapNum, bspDrawSurface_t *ds, rawLightmap_t *lm, shaderInfo_t *si,
 415         float scale, float subdivide, qboolean original, radWinding_t *rw, clipWork_t *cw )
 416 {
 417         int                             i, style = 0;
 418         float                   dist, area, value;
 419         vec3_t                  mins, maxs, normal, d1, d2, cross, color, gradient;
 420         light_t                 *light, *splash;
 421         winding_t               *w;
 422
 423
 424         /* dummy check */
 425         if( rw == NULL || rw->numVerts < 3 )
 426                 return;
 427
 428         /* get bounds for winding */
 429         ClearBounds( mins, maxs );
 430         for( i = 0; i < rw->numVerts; i++ )
 431                 AddPointToBounds( rw->verts[ i ].xyz, mins, maxs );
 432
 433         /* subdivide if necessary */
 434         for( i = 0; i < 3; i++ )
 435         {
 436                 if( maxs[ i ] - mins[ i ] > subdivide )
 437                 {
 438                         radWinding_t    front, back;
 439
 440
 441                         /* make axial plane */
 442                         VectorClear( normal );
 443                         normal[ i ] = 1;
 444                         dist = (maxs[ i ] + mins[ i ]) * 0.5f;
 445
 446                         /* clip the winding */
 447                         RadClipWindingEpsilon( rw, normal, dist, RADIOSITY_CLIP_EPSILON, &front, &back, cw );
 448
 449                         /* recurse */
 450                         RadSubdivideDiffuseLight( lightmapNum, ds, lm, si, scale, subdivide, qfalse, &front, cw );
 451                         RadSubdivideDiffuseLight( lightmapNum, ds, lm, si, scale, subdivide, qfalse, &back, cw );
 452                         return;
 453                 }
 454         }
 455
 456         /* check area */
 457         area = 0.0f;
 458         for( i = 2; i < rw->numVerts; i++ )
 459         {
 460                 VectorSubtract( rw->verts[ i - 1 ].xyz, rw->verts[ 0 ].xyz, d1 );
 461                 VectorSubtract( rw->verts[ i ].xyz, rw->verts[ 0 ].xyz, d2 );
 462                 CrossProduct( d1, d2, cross );
 463                 area += 0.5f * VectorLength( cross );
 464         }
 465         if( area < 1.0f || area > 20000000.0f )
 466                 return;
 467
 468         /* more subdivision may be necessary */
 469         if( bouncing )
 470         {
 471                 /* get color sample for the surface fragment */
 472                 RadSample( lightmapNum, ds, lm, si, rw, color, gradient, &style );
 473
 474                 /* if color gradient is too high, subdivide again */
 475                 if( subdivide > minDiffuseSubdivide &&
 476                         (gradient[ 0 ] > RADIOSITY_MAX_GRADIENT || gradient[ 1 ] > RADIOSITY_MAX_GRADIENT || gradient[ 2 ] > RADIOSITY_MAX_GRADIENT) )
 477                 {
 478                         RadSubdivideDiffuseLight( lightmapNum, ds, lm, si, scale, (subdivide / 2.0f), qfalse, rw, cw );
 479                         return;
 480                 }
 481         }
 482
 483         /* create a regular winding and an average normal */
 484         w = AllocWinding( rw->numVerts );
 485         w->numpoints = rw->numVerts;
 486         VectorClear( normal );
 487         for( i = 0; i < rw->numVerts; i++ )
 488         {
 489                 VectorCopy( rw->verts[ i ].xyz, w->p[ i ] );
 490                 VectorAdd( normal, rw->verts[ i ].normal, normal );
 491         }
 492         VectorScale( normal, (1.0f / rw->numVerts), normal );
 493         if( VectorNormalize( normal, normal ) == 0.0f )
 494                 return;
 495
 496         /* early out? */
 497         if( bouncing && VectorLength( color ) < RADIOSITY_MIN )
 498                 return;
 499
 500         /* debug code */
 501         //%     Sys_Printf( "Size: %d %d %d\n", (int) (maxs[ 0 ] - mins[ 0 ]), (int) (maxs[ 1 ] - mins[ 1 ]), (int) (maxs[ 2 ] - mins[ 2 ]) );
 502         //%     Sys_Printf( "Grad: %f %f %f\n", gradient[ 0 ], gradient[ 1 ], gradient[ 2 ] );
 503
 504         /* increment counts */
 505         numDiffuseLights++;
 506         switch( ds->surfaceType )
 507         {
 508                 case MST_PLANAR:
 509                         numBrushDiffuseLights++;
 510                         break;
 511
 512                 case MST_TRIANGLE_SOUP:
 513                         numTriangleDiffuseLights++;
 514                         break;
 515
 516                 case MST_PATCH:
 517                         numPatchDiffuseLights++;
 518                         break;
 519         }
 520
 521         /* create a light */
 522         light = safe_malloc( sizeof( *light ) );
 523         memset( light, 0, sizeof( *light ) );
 524
 525         /* attach it */
 526         ThreadLock();
 527         light->next = lights;
 528         lights = light;
 529         ThreadUnlock();
 530
 531         /* initialize the light */
 532         light->flags = LIGHT_AREA_DEFAULT;
 533         light->type = EMIT_AREA;
 534         light->si = si;
 535         light->fade = 1.0f;
 536         light->w = w;
 537
 538         /* set falloff threshold */
 539         light->falloffTolerance = falloffTolerance;
 540
 541         /* bouncing light? */
 542         if( !bouncing )
 543         {
 544                 /* handle first-pass lights in normal q3a style */
 545                 value = si->value;
 546                 light->photons = value * area * areaScale;
 547                 light->add = value * formFactorValueScale * areaScale;
 548                 VectorCopy( si->color, light->color );
 549                 VectorScale( light->color, light->add, light->emitColor );
 550                 light->style = noStyles ? LS_NORMAL : si->lightStyle;
 551                 if( light->style < LS_NORMAL || light->style >= LS_NONE )
 552                         light->style = LS_NORMAL;
 553
 554                 /* set origin */
 555                 VectorAdd( mins, maxs, light->origin );
 556                 VectorScale( light->origin, 0.5f, light->origin );
 557
 558                 /* nudge it off the plane a bit */
 559                 VectorCopy( normal, light->normal );
 560                 VectorMA( light->origin, 1.0f, light->normal, light->origin );
 561                 light->dist = DotProduct( light->origin, normal );
 562
 563                 /* optionally create a point splashsplash light for first pass */
 564                 if( original && si->backsplashFraction > 0 )
 565                 {
 566                         /* allocate a new point light */
 567                         splash = safe_malloc( sizeof( *splash ) );
 568                         memset( splash, 0, sizeof( *splash ) );
 569                         splash->next = lights;
 570                         lights = splash;
 571
 572                         /* set it up */
 573                         splash->flags = LIGHT_Q3A_DEFAULT;
 574                         splash->type = EMIT_POINT;
 575                         splash->photons = light->photons * si->backsplashFraction;
 576                         splash->fade = 1.0f;
 577                         splash->si = si;
 578                         VectorMA( light->origin, si->backsplashDistance, normal, splash->origin );
 579                         VectorCopy( si->color, splash->color );
 580                         splash->falloffTolerance = falloffTolerance;
 581                         splash->style = noStyles ? LS_NORMAL : light->style;
 582
 583                         /* add to counts */
 584                         numPointLights++;
 585                 }
 586         }
 587         else
 588         {
 589                 /* handle bounced light (radiosity) a little differently */
 590                 value = RADIOSITY_VALUE * si->bounceScale * 0.375f;
 591                 light->photons = value * area * bounceScale;
 592                 light->add = value * formFactorValueScale * bounceScale;
 593                 VectorCopy( color, light->color );
 594                 VectorScale( light->color, light->add, light->emitColor );
 595                 light->style = noStyles ? LS_NORMAL : style;
 596                 if( light->style < LS_NORMAL || light->style >= LS_NONE )
 597                         light->style = LS_NORMAL;
 598
 599                 /* set origin */
 600                 WindingCenter( w, light->origin );
 601
 602                 /* nudge it off the plane a bit */
 603                 VectorCopy( normal, light->normal );
 604                 VectorMA( light->origin, 1.0f, light->normal, light->origin );
 605                 light->dist = DotProduct( light->origin, normal );
 606         }
 607
 608         /* emit light from both sides? */
 609         if( si->compileFlags & C_FOG || si->twoSided )
 610                 light->flags |= LIGHT_TWOSIDED;
 611
 612         //%     Sys_Printf( "\nAL: C: (%6f, %6f, %6f) [%6f] N: (%6f, %6f, %6f) %s\n",
 613         //%             light->color[ 0 ], light->color[ 1 ], light->color[ 2 ], light->add,
 614         //%             light->normal[ 0 ], light->normal[ 1 ], light->normal[ 2 ],
 615         //%             light->si->shader );
 616 }
 617
 618
 619
 620 /*
 621 RadLightForTriangles()
 622 creates unbounced diffuse lights for triangle soup (misc_models, etc)
 623 */
 624
 625 void RadLightForTriangles( int num, int lightmapNum, rawLightmap_t *lm, shaderInfo_t *si, float scale, float subdivide, clipWork_t *cw )
 626 {
 627         int                                     i, j, k, v;
 628         bspDrawSurface_t        *ds;
 629         surfaceInfo_t           *info;
 630         float                           *radVertexLuxel;
 631         radWinding_t            rw;
 632
 633
 634         /* get surface */
 635         ds = &bspDrawSurfaces[ num ];
 636         info = &surfaceInfos[ num ];
 637
 638         /* each triangle is a potential emitter */
 639         rw.numVerts = 3;
 640         for( i = 0; i < ds->numIndexes; i += 3 )
 641         {
 642                 /* copy each vert */
 643                 for( j = 0; j < 3; j++ )
 644                 {
 645                         /* get vertex index and rad vertex luxel */
 646                         v = ds->firstVert + bspDrawIndexes[ ds->firstIndex + i + j ];
 647
 648                         /* get most everything */
 649                         memcpy( &rw.verts[ j ], &yDrawVerts[ v ], sizeof( bspDrawVert_t ) );
 650
 651                         /* fix colors */
 652                         for( k = 0; k < MAX_LIGHTMAPS; k++ )
 653                         {
 654                                 radVertexLuxel = RAD_VERTEX_LUXEL( k, ds->firstVert + bspDrawIndexes[ ds->firstIndex + i + j ] );
 655                                 VectorCopy( radVertexLuxel, rw.verts[ j ].color[ k ] );
 656                                 rw.verts[ j ].color[ k ][ 3 ] = yDrawVerts[ v ].color[ k ][ 3 ];
 657                         }
 658                 }
 659
 660                 /* subdivide into area lights */
 661                 RadSubdivideDiffuseLight( lightmapNum, ds, lm, si, scale, subdivide, qtrue, &rw, cw );
 662         }
 663 }
 664
 665
 666
 667 /*
 668 RadLightForPatch()
 669 creates unbounced diffuse lights for patches
 670 */
 671
 672 #define PLANAR_EPSILON  0.1f
 673
 674 void RadLightForPatch( int num, int lightmapNum, rawLightmap_t *lm, shaderInfo_t *si, float scale, float subdivide, clipWork_t *cw )
 675 {
 676         int                                     i, x, y, v, t, pw[ 5 ], r;
 677         bspDrawSurface_t        *ds;
 678         surfaceInfo_t           *info;
 679         bspDrawVert_t           *bogus;
 680         bspDrawVert_t           *dv[ 4 ];
 681         mesh_t                          src, *subdivided, *mesh;
 682         float                           *radVertexLuxel;
 683         float                           dist;
 684         vec4_t                          plane;
 685         qboolean                        planar;
 686         radWinding_t            rw;
 687
 688
 689         /* get surface */
 690         ds = &bspDrawSurfaces[ num ];
 691         info = &surfaceInfos[ num ];
 692
 693         /* construct a bogus vert list with color index stuffed into color[ 0 ] */
 694         bogus = safe_malloc( ds->numVerts * sizeof( bspDrawVert_t ) );
 695         memcpy( bogus, &yDrawVerts[ ds->firstVert ], ds->numVerts * sizeof( bspDrawVert_t ) );
 696         for( i = 0; i < ds->numVerts; i++ )
 697                 bogus[ i ].color[ 0 ][ 0 ] = i;
 698
 699         /* build a subdivided mesh identical to shadow facets for this patch */
 700         /* this MUST MATCH FacetsForPatch() identically! */
 701         src.width = ds->patchWidth;
 702         src.height = ds->patchHeight;
 703         src.verts = bogus;
 704         //%     subdivided = SubdivideMesh( src, 8, 512 );
 705         subdivided = SubdivideMesh2( src, info->patchIterations );
 706         PutMeshOnCurve( *subdivided );
 707         //%     MakeMeshNormals( *subdivided );
 708         mesh = RemoveLinearMeshColumnsRows( subdivided );
 709         FreeMesh( subdivided );
 710         free( bogus );
 711
 712         /* FIXME: build interpolation table into color[ 1 ] */
 713
 714         /* fix up color indexes */
 715         for( i = 0; i < (mesh->width * mesh->height); i++ )
 716         {
 717                 dv[ 0 ] = &mesh->verts[ i ];
 718                 if( dv[ 0 ]->color[ 0 ][ 0 ] >= ds->numVerts )
 719                         dv[ 0 ]->color[ 0 ][ 0 ] = ds->numVerts - 1;
 720         }
 721
 722         /* iterate through the mesh quads */
 723         for( y = 0; y < (mesh->height - 1); y++ )
 724         {
 725                 for( x = 0; x < (mesh->width - 1); x++ )
 726                 {
 727                         /* set indexes */
 728                         pw[ 0 ] = x + (y * mesh->width);
 729                         pw[ 1 ] = x + ((y + 1) * mesh->width);
 730                         pw[ 2 ] = x + 1 + ((y + 1) * mesh->width);
 731                         pw[ 3 ] = x + 1 + (y * mesh->width);
 732                         pw[ 4 ] = x + (y * mesh->width);        /* same as pw[ 0 ] */
 733
 734                         /* set radix */
 735                         r = (x + y) & 1;
 736
 737                         /* get drawverts */
 738                         dv[ 0 ] = &mesh->verts[ pw[ r + 0 ] ];
 739                         dv[ 1 ] = &mesh->verts[ pw[ r + 1 ] ];
 740                         dv[ 2 ] = &mesh->verts[ pw[ r + 2 ] ];
 741                         dv[ 3 ] = &mesh->verts[ pw[ r + 3 ] ];
 742
 743                         /* planar? */
 744                         planar = PlaneFromPoints( plane, dv[ 0 ]->xyz, dv[ 1 ]->xyz, dv[ 2 ]->xyz );
 745                         if( planar )
 746                         {
 747                                 dist = DotProduct( dv[ 1 ]->xyz, plane ) - plane[ 3 ];
 748                                 if( fabs( dist ) > PLANAR_EPSILON )
 749                                         planar = qfalse;
 750                         }
 751
 752                         /* generate a quad */
 753                         if( planar )
 754                         {
 755                                 rw.numVerts = 4;
 756                                 for( v = 0; v < 4; v++ )
 757                                 {
 758                                         /* get most everything */
 759                                         memcpy( &rw.verts[ v ], dv[ v ], sizeof( bspDrawVert_t ) );
 760
 761                                         /* fix colors */
 762                                         for( i = 0; i < MAX_LIGHTMAPS; i++ )
 763                                         {
 764                                                 radVertexLuxel = RAD_VERTEX_LUXEL( i, ds->firstVert + dv[ v ]->color[ 0 ][ 0 ] );
 765                                                 VectorCopy( radVertexLuxel, rw.verts[ v ].color[ i ] );
 766                                                 rw.verts[ v ].color[ i ][ 3 ] = dv[ v ]->color[ i ][ 3 ];
 767                                         }
 768                                 }
 769
 770                                 /* subdivide into area lights */
 771                                 RadSubdivideDiffuseLight( lightmapNum, ds, lm, si, scale, subdivide, qtrue, &rw, cw );
 772                         }
 773
 774                         /* generate 2 tris */
 775                         else
 776                         {
 777                                 rw.numVerts = 3;
 778                                 for( t = 0; t < 2; t++ )
 779                                 {
 780                                         for( v = 0; v < 3 + t; v++ )
 781                                         {
 782                                                 /* get "other" triangle (stupid hacky logic, but whatevah) */
 783                                                 if( v == 1 && t == 1 )
 784                                                         v++;
 785
 786                                                 /* get most everything */
 787                                                 memcpy( &rw.verts[ v ], dv[ v ], sizeof( bspDrawVert_t ) );
 788
 789                                                 /* fix colors */
 790                                                 for( i = 0; i < MAX_LIGHTMAPS; i++ )
 791                                                 {
 792                                                         radVertexLuxel = RAD_VERTEX_LUXEL( i, ds->firstVert + dv[ v ]->color[ 0 ][ 0 ] );
 793                                                         VectorCopy( radVertexLuxel, rw.verts[ v ].color[ i ] );
 794                                                         rw.verts[ v ].color[ i ][ 3 ] = dv[ v ]->color[ i ][ 3 ];
 795                                                 }
 796                                         }
 797
 798                                         /* subdivide into area lights */
 799                                         RadSubdivideDiffuseLight( lightmapNum, ds, lm, si, scale, subdivide, qtrue, &rw, cw );
 800                                 }
 801                         }
 802                 }
 803         }
 804
 805         /* free the mesh */
 806         FreeMesh( mesh );
 807 }
 808
 809
 810
 811
 812 /*
 813 RadLight()
 814 creates unbounced diffuse lights for a given surface
 815 */
 816
 817 void RadLight( int num )
 818 {
 819         int                                     lightmapNum;
 820         float                           scale, subdivide;
 821         int                                     contentFlags, surfaceFlags, compileFlags;
 822         bspDrawSurface_t        *ds;
 823         surfaceInfo_t           *info;
 824         rawLightmap_t           *lm;
 825         shaderInfo_t            *si;
 826         clipWork_t                      cw;
 827
 828
 829         /* get drawsurface, lightmap, and shader info */
 830         ds = &bspDrawSurfaces[ num ];
 831         info = &surfaceInfos[ num ];
 832         lm = info->lm;
 833         si = info->si;
 834         scale = si->bounceScale;
 835
 836         /* find nodraw bit */
 837         contentFlags = surfaceFlags = compileFlags = 0;
 838         ApplySurfaceParm( "nodraw", &contentFlags, &surfaceFlags, &compileFlags );
 839
 840         // jal : avoid bouncing on trans surfaces
 841         ApplySurfaceParm( "trans", &contentFlags, &surfaceFlags, &compileFlags );
 842
 843         /* early outs? */
 844         if( scale <= 0.0f || (si->compileFlags & C_SKY) || si->autosprite ||
 845                 (bspShaders[ ds->shaderNum ].contentFlags & contentFlags) || (bspShaders[ ds->shaderNum ].surfaceFlags & surfaceFlags) ||
 846                 (si->compileFlags & compileFlags) )
 847                 return;
 848
 849         /* determine how much we need to chop up the surface */
 850         if( si->lightSubdivide )
 851                 subdivide = si->lightSubdivide;
 852         else
 853                 subdivide = diffuseSubdivide;
 854
 855         /* inc counts */
 856         numDiffuseSurfaces++;
 857
 858         /* iterate through styles (this could be more efficient, yes) */
 859         for( lightmapNum = 0; lightmapNum < MAX_LIGHTMAPS; lightmapNum++ )
 860         {
 861                 /* switch on type */
 862                 if( ds->lightmapStyles[ lightmapNum ] != LS_NONE && ds->lightmapStyles[ lightmapNum ] != LS_UNUSED )
 863                 {
 864                         switch( ds->surfaceType )
 865                         {
 866                                 case MST_PLANAR:
 867                                 case MST_TRIANGLE_SOUP:
 868                                         RadLightForTriangles( num, lightmapNum, lm, si, scale, subdivide, &cw );
 869                                         break;
 870
 871                                 case MST_PATCH:
 872                                         RadLightForPatch( num, lightmapNum, lm, si, scale, subdivide, &cw );
 873                                         break;
 874
 875                                 default:
 876                                         break;
 877                         }
 878                 }
 879         }
 880 }
 881
 882
 883
 884 /*
 885 RadCreateDiffuseLights()
 886 creates lights for unbounced light on surfaces in the bsp
 887 */
 888
 889 int     iterations = 0;
 890
 891 void RadCreateDiffuseLights( void )
 892 {
 893         /* startup */
 894         Sys_FPrintf( SYS_VRB, "--- RadCreateDiffuseLights ---\n" );
 895         numDiffuseSurfaces = 0;
 896         numDiffuseLights = 0;
 897         numBrushDiffuseLights = 0;
 898         numTriangleDiffuseLights = 0;
 899         numPatchDiffuseLights = 0;
 900         numAreaLights = 0;
 901
 902         /* hit every surface (threaded) */
 903         RunThreadsOnIndividual( numBSPDrawSurfaces, qtrue, RadLight );
 904
 905         /* dump the lights generated to a file */
 906         if( dump )
 907         {
 908                 char    dumpName[ 1024 ], ext[ 64 ];
 909                 FILE    *file;
 910                 light_t *light;
 911
 912                 strcpy( dumpName, source );
 913                 StripExtension( dumpName );
 914                 sprintf( ext, "_bounce_%03d.map", iterations );
 915                 strcat( dumpName, ext );
 916                 file = fopen( dumpName, "wb" );
 917                 Sys_Printf( "Writing %s...\n", dumpName );
 918                 if( file )
 919                 {
 920                         for( light = lights; light; light = light->next )
 921                         {
 922                                 fprintf( file,
 923                                         "{\n"
 924                                         "\"classname\" \"light\"\n"
 925                                         "\"light\" \"%d\"\n"
 926                                         "\"origin\" \"%.0f %.0f %.0f\"\n"
 927                                         "\"_color\" \"%.3f %.3f %.3f\"\n"
 928                                         "}\n",
 929
 930                                         (int) light->add,
 931
 932                                         light->origin[ 0 ],
 933                                         light->origin[ 1 ],
 934                                         light->origin[ 2 ],
 935
 936                                         light->color[ 0 ],
 937                                         light->color[ 1 ],
 938                                         light->color[ 2 ] );
 939                         }
 940                         fclose( file );
 941                 }
 942         }
 943
 944         /* increment */
 945         iterations++;
 946
 947         /* print counts */
 948         Sys_Printf( "%8d diffuse surfaces\n", numDiffuseSurfaces );
 949         Sys_FPrintf( SYS_VRB, "%8d total diffuse lights\n", numDiffuseLights );
 950         Sys_FPrintf( SYS_VRB, "%8d brush diffuse lights\n", numBrushDiffuseLights );
 951         Sys_FPrintf( SYS_VRB, "%8d patch diffuse lights\n", numPatchDiffuseLights );
 952         Sys_FPrintf( SYS_VRB, "%8d triangle diffuse lights\n", numTriangleDiffuseLights );
 953 }
 954
 955
 956
 957
 958
 959