tools/quake3/q3map2/light_ydnar.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_YDNAR_C
  33
  34
  35
  36 /* dependencies */
  37 #include "q3map2.h"
  38
  39
  40
  41
  42 /*
  43 ColorToBytes()
  44 ydnar: moved to here 2001-02-04
  45 */
  46
  47 void ColorToBytes( const float *color, byte *colorBytes, float scale )
  48 {
  49         int             i;
  50         float   max, gamma;
  51         vec3_t  sample;
  52         float   inv, dif;
  53
  54
  55         /* ydnar: scaling necessary for simulating r_overbrightBits on external lightmaps */
  56         if( scale <= 0.0f )
  57                 scale = 1.0f;
  58
  59         /* make a local copy */
  60         VectorScale( color, scale, sample );
  61
  62         /* muck with it */
  63         gamma = 1.0f / lightmapGamma;
  64         for( i = 0; i < 3; i++ )
  65         {
  66                 /* handle negative light */
  67                 if( sample[ i ] < 0.0f )
  68                 {
  69                         sample[ i ] = 0.0f;
  70                         continue;
  71                 }
  72
  73                 /* gamma */
  74                 sample[ i ] = pow( sample[ i ] / 255.0f, gamma ) * 255.0f;
  75         }
  76
  77         if (lightmapExposure == 1)
  78         {
  79                 /* clamp with color normalization */
  80                 max = sample[ 0 ];
  81                 if( sample[ 1 ] > max )
  82                         max = sample[ 1 ];
  83                 if( sample[ 2 ] > max )
  84                         max = sample[ 2 ];
  85                 if( max > 255.0f )
  86                         VectorScale( sample, (255.0f / max), sample );
  87         }
  88         else
  89         {
  90                 if (lightmapExposure==0)
  91                 {
  92                         lightmapExposure=1.0f;
  93                 }
  94                 inv=1.f/lightmapExposure;
  95                 //Exposure
  96
  97                 max = sample[ 0 ];
  98                 if( sample[ 1 ] > max )
  99                         max = sample[ 1 ];
 100                 if( sample[ 2 ] > max )
 101                         max = sample[ 2 ];
 102
 103                 dif = (1-  exp(-max * inv) )  *  255;
 104
 105                 if (max >0)
 106                 {
 107                         dif = dif / max;
 108                 }
 109                 else
 110                 {
 111                         dif = 0;
 112                 }
 113
 114                 for (i=0;i<3;i++)
 115                 {
 116                         sample[i]*=dif;
 117                 }
 118         }
 119
 120
 121         /* compensate for ingame overbrighting/bitshifting */
 122         VectorScale( sample, (1.0f / lightmapCompensate), sample );
 123
 124         /* store it off */
 125         colorBytes[ 0 ] = sample[ 0 ];
 126         colorBytes[ 1 ] = sample[ 1 ];
 127         colorBytes[ 2 ] = sample[ 2 ];
 128 }
 129
 130
 131
 132 /* -------------------------------------------------------------------------------
 133
 134 this section deals with phong shading (normal interpolation across brush faces)
 135
 136 ------------------------------------------------------------------------------- */
 137
 138 /*
 139 SmoothNormals()
 140 smooths together coincident vertex normals across the bsp
 141 */
 142
 143 #define MAX_SAMPLES                             256
 144 #define THETA_EPSILON                   0.000001
 145 #define EQUAL_NORMAL_EPSILON    0.01
 146
 147 void SmoothNormals( void )
 148 {
 149         int                                     i, j, k, f, cs, numVerts, numVotes, fOld, start;
 150         float                           shadeAngle, defaultShadeAngle, maxShadeAngle, dot, testAngle;
 151         bspDrawSurface_t        *ds;
 152         shaderInfo_t            *si;
 153         float                           *shadeAngles;
 154         byte                            *smoothed;
 155         vec3_t                          average, diff;
 156         int                                     indexes[ MAX_SAMPLES ];
 157         vec3_t                          votes[ MAX_SAMPLES ];
 158
 159
 160         /* allocate shade angle table */
 161         shadeAngles = safe_malloc( numBSPDrawVerts * sizeof( float ) );
 162         memset( shadeAngles, 0, numBSPDrawVerts * sizeof( float ) );
 163
 164         /* allocate smoothed table */
 165         cs = (numBSPDrawVerts / 8) + 1;
 166         smoothed = safe_malloc( cs );
 167         memset( smoothed, 0, cs );
 168
 169         /* set default shade angle */
 170         defaultShadeAngle = DEG2RAD( shadeAngleDegrees );
 171         maxShadeAngle = 0;
 172
 173         /* run through every surface and flag verts belonging to non-lightmapped surfaces
 174            and set per-vertex smoothing angle */
 175         for( i = 0; i < numBSPDrawSurfaces; i++ )
 176         {
 177                 /* get drawsurf */
 178                 ds = &bspDrawSurfaces[ i ];
 179
 180                 /* get shader for shade angle */
 181                 si = surfaceInfos[ i ].si;
 182                 if( si->shadeAngleDegrees )
 183                         shadeAngle = DEG2RAD( si->shadeAngleDegrees );
 184                 else
 185                         shadeAngle = defaultShadeAngle;
 186                 if( shadeAngle > maxShadeAngle )
 187                         maxShadeAngle = shadeAngle;
 188
 189                 /* flag its verts */
 190                 for( j = 0; j < ds->numVerts; j++ )
 191                 {
 192                         f = ds->firstVert + j;
 193                         shadeAngles[ f ] = shadeAngle;
 194                         if( ds->surfaceType == MST_TRIANGLE_SOUP )
 195                                 smoothed[ f >> 3 ] |= (1 << (f & 7));
 196                 }
 197
 198                 /* ydnar: optional force-to-trisoup */
 199                 if( trisoup && ds->surfaceType == MST_PLANAR )
 200                 {
 201                         ds->surfaceType = MST_TRIANGLE_SOUP;
 202                         ds->lightmapNum[ 0 ] = -3;
 203                 }
 204         }
 205
 206         /* bail if no surfaces have a shade angle */
 207         if( maxShadeAngle == 0 )
 208         {
 209                 free( shadeAngles );
 210                 free( smoothed );
 211                 return;
 212         }
 213
 214         /* init pacifier */
 215         fOld = -1;
 216         start = I_FloatTime();
 217
 218         /* go through the list of vertexes */
 219         for( i = 0; i < numBSPDrawVerts; i++ )
 220         {
 221                 /* print pacifier */
 222                 f = 10 * i / numBSPDrawVerts;
 223                 if( f != fOld )
 224                 {
 225                         fOld = f;
 226                         Sys_Printf( "%i...", f );
 227                 }
 228
 229                 /* already smoothed? */
 230                 if( smoothed[ i >> 3 ] & (1 << (i & 7)) )
 231                         continue;
 232
 233                 /* clear */
 234                 VectorClear( average );
 235                 numVerts = 0;
 236                 numVotes = 0;
 237
 238                 /* build a table of coincident vertexes */
 239                 for( j = i; j < numBSPDrawVerts && numVerts < MAX_SAMPLES; j++ )
 240                 {
 241                         /* already smoothed? */
 242                         if( smoothed[ j >> 3 ] & (1 << (j & 7)) )
 243                                 continue;
 244
 245                         /* test vertexes */
 246                         if( VectorCompare( yDrawVerts[ i ].xyz, yDrawVerts[ j ].xyz ) == qfalse )
 247                                 continue;
 248
 249                         /* use smallest shade angle */
 250                         shadeAngle = (shadeAngles[ i ] < shadeAngles[ j ] ? shadeAngles[ i ] : shadeAngles[ j ]);
 251
 252                         /* check shade angle */
 253                         dot = DotProduct( bspDrawVerts[ i ].normal, bspDrawVerts[ j ].normal );
 254                         if( dot > 1.0 )
 255                                 dot = 1.0;
 256                         else if( dot < -1.0 )
 257                                 dot = -1.0;
 258                         testAngle = acos( dot ) + THETA_EPSILON;
 259                         if( testAngle >= shadeAngle )
 260                         {
 261                                 //Sys_Printf( "F(%3.3f >= %3.3f) ", RAD2DEG( testAngle ), RAD2DEG( shadeAngle ) );
 262                                 continue;
 263                         }
 264                         //Sys_Printf( "P(%3.3f < %3.3f) ", RAD2DEG( testAngle ), RAD2DEG( shadeAngle ) );
 265
 266                         /* add to the list */
 267                         indexes[ numVerts++ ] = j;
 268
 269                         /* flag vertex */
 270                         smoothed[ j >> 3 ] |= (1 << (j & 7));
 271
 272                         /* see if this normal has already been voted */
 273                         for( k = 0; k < numVotes; k++ )
 274                         {
 275                                 VectorSubtract( bspDrawVerts[ j ].normal, votes[ k ], diff );
 276                                 if( fabs( diff[ 0 ] ) < EQUAL_NORMAL_EPSILON &&
 277                                         fabs( diff[ 1 ] ) < EQUAL_NORMAL_EPSILON &&
 278                                         fabs( diff[ 2 ] ) < EQUAL_NORMAL_EPSILON )
 279                                         break;
 280                         }
 281
 282                         /* add a new vote? */
 283                         if( k == numVotes && numVotes < MAX_SAMPLES )
 284                         {
 285                                 VectorAdd( average, bspDrawVerts[ j ].normal, average );
 286                                 VectorCopy( bspDrawVerts[ j ].normal, votes[ numVotes ] );
 287                                 numVotes++;
 288                         }
 289                 }
 290
 291                 /* don't average for less than 2 verts */
 292                 if( numVerts < 2 )
 293                         continue;
 294
 295                 /* average normal */
 296                 if( VectorNormalize( average, average ) > 0 )
 297                 {
 298                         /* smooth */
 299                         for( j = 0; j < numVerts; j++ )
 300                                 VectorCopy( average, yDrawVerts[ indexes[ j ] ].normal );
 301                 }
 302         }
 303
 304         /* free the tables */
 305         free( shadeAngles );
 306         free( smoothed );
 307
 308         /* print time */
 309         Sys_Printf( " (%i)\n", (int) (I_FloatTime() - start) );
 310 }
 311
 312
 313
 314 /* -------------------------------------------------------------------------------
 315
 316 this section deals with phong shaded lightmap tracing
 317
 318 ------------------------------------------------------------------------------- */
 319
 320 /* 9th rewrite (recursive subdivision of a lightmap triangle) */
 321
 322 /*
 323 CalcTangentVectors()
 324 calculates the st tangent vectors for normalmapping
 325 */
 326
 327 static qboolean CalcTangentVectors( int numVerts, bspDrawVert_t **dv, vec3_t *stv, vec3_t *ttv )
 328 {
 329         int                     i;
 330         float           bb, s, t;
 331         vec3_t          bary;
 332
 333
 334         /* calculate barycentric basis for the triangle */
 335         bb = (dv[ 1 ]->st[ 0 ] - dv[ 0 ]->st[ 0 ]) * (dv[ 2 ]->st[ 1 ] - dv[ 0 ]->st[ 1 ]) - (dv[ 2 ]->st[ 0 ] - dv[ 0 ]->st[ 0 ]) * (dv[ 1 ]->st[ 1 ] - dv[ 0 ]->st[ 1 ]);
 336         if( fabs( bb ) < 0.00000001f )
 337                 return qfalse;
 338
 339         /* do each vertex */
 340         for( i = 0; i < numVerts; i++ )
 341         {
 342                 /* calculate s tangent vector */
 343                 s = dv[ i ]->st[ 0 ] + 10.0f;
 344                 t = dv[ i ]->st[ 1 ];
 345                 bary[ 0 ] = ((dv[ 1 ]->st[ 0 ] - s) * (dv[ 2 ]->st[ 1 ] - t) - (dv[ 2 ]->st[ 0 ] - s) * (dv[ 1 ]->st[ 1 ] - t)) / bb;
 346                 bary[ 1 ] = ((dv[ 2 ]->st[ 0 ] - s) * (dv[ 0 ]->st[ 1 ] - t) - (dv[ 0 ]->st[ 0 ] - s) * (dv[ 2 ]->st[ 1 ] - t)) / bb;
 347                 bary[ 2 ] = ((dv[ 0 ]->st[ 0 ] - s) * (dv[ 1 ]->st[ 1 ] - t) - (dv[ 1 ]->st[ 0 ] - s) * (dv[ 0 ]->st[ 1 ] - t)) / bb;
 348
 349                 stv[ i ][ 0 ] = bary[ 0 ] * dv[ 0 ]->xyz[ 0 ] + bary[ 1 ] * dv[ 1 ]->xyz[ 0 ] + bary[ 2 ] * dv[ 2 ]->xyz[ 0 ];
 350                 stv[ i ][ 1 ] = bary[ 0 ] * dv[ 0 ]->xyz[ 1 ] + bary[ 1 ] * dv[ 1 ]->xyz[ 1 ] + bary[ 2 ] * dv[ 2 ]->xyz[ 1 ];
 351                 stv[ i ][ 2 ] = bary[ 0 ] * dv[ 0 ]->xyz[ 2 ] + bary[ 1 ] * dv[ 1 ]->xyz[ 2 ] + bary[ 2 ] * dv[ 2 ]->xyz[ 2 ];
 352
 353                 VectorSubtract( stv[ i ], dv[ i ]->xyz, stv[ i ] );
 354                 VectorNormalize( stv[ i ], stv[ i ] );
 355
 356                 /* calculate t tangent vector */
 357                 s = dv[ i ]->st[ 0 ];
 358                 t = dv[ i ]->st[ 1 ] + 10.0f;
 359                 bary[ 0 ] = ((dv[ 1 ]->st[ 0 ] - s) * (dv[ 2 ]->st[ 1 ] - t) - (dv[ 2 ]->st[ 0 ] - s) * (dv[ 1 ]->st[ 1 ] - t)) / bb;
 360                 bary[ 1 ] = ((dv[ 2 ]->st[ 0 ] - s) * (dv[ 0 ]->st[ 1 ] - t) - (dv[ 0 ]->st[ 0 ] - s) * (dv[ 2 ]->st[ 1 ] - t)) / bb;
 361                 bary[ 2 ] = ((dv[ 0 ]->st[ 0 ] - s) * (dv[ 1 ]->st[ 1 ] - t) - (dv[ 1 ]->st[ 0 ] - s) * (dv[ 0 ]->st[ 1 ] - t)) / bb;
 362
 363                 ttv[ i ][ 0 ] = bary[ 0 ] * dv[ 0 ]->xyz[ 0 ] + bary[ 1 ] * dv[ 1 ]->xyz[ 0 ] + bary[ 2 ] * dv[ 2 ]->xyz[ 0 ];
 364                 ttv[ i ][ 1 ] = bary[ 0 ] * dv[ 0 ]->xyz[ 1 ] + bary[ 1 ] * dv[ 1 ]->xyz[ 1 ] + bary[ 2 ] * dv[ 2 ]->xyz[ 1 ];
 365                 ttv[ i ][ 2 ] = bary[ 0 ] * dv[ 0 ]->xyz[ 2 ] + bary[ 1 ] * dv[ 1 ]->xyz[ 2 ] + bary[ 2 ] * dv[ 2 ]->xyz[ 2 ];
 366
 367                 VectorSubtract( ttv[ i ], dv[ i ]->xyz, ttv[ i ] );
 368                 VectorNormalize( ttv[ i ], ttv[ i ] );
 369
 370                 /* debug code */
 371                 //%     Sys_FPrintf( SYS_VRB, "%d S: (%f %f %f) T: (%f %f %f)\n", i,
 372                 //%             stv[ i ][ 0 ], stv[ i ][ 1 ], stv[ i ][ 2 ], ttv[ i ][ 0 ], ttv[ i ][ 1 ], ttv[ i ][ 2 ] );
 373         }
 374
 375         /* return to caller */
 376         return qtrue;
 377 }
 378
 379
 380
 381
 382 /*
 383 PerturbNormal()
 384 perterbs the normal by the shader's normalmap in tangent space
 385 */
 386
 387 static void PerturbNormal( bspDrawVert_t *dv, shaderInfo_t *si, vec3_t pNormal, vec3_t stv[ 3 ], vec3_t ttv[ 3 ] )
 388 {
 389         int                     i;
 390         vec4_t          bump;
 391
 392
 393         /* passthrough */
 394         VectorCopy( dv->normal, pNormal );
 395
 396         /* sample normalmap */
 397         if( RadSampleImage( si->normalImage->pixels, si->normalImage->width, si->normalImage->height, dv->st, bump ) == qfalse )
 398                 return;
 399
 400         /* remap sampled normal from [0,255] to [-1,-1] */
 401         for( i = 0; i < 3; i++ )
 402                 bump[ i ] = (bump[ i ] - 127.0f) * (1.0f / 127.5f);
 403
 404         /* scale tangent vectors and add to original normal */
 405         VectorMA( dv->normal, bump[ 0 ], stv[ 0 ], pNormal );
 406         VectorMA( pNormal, bump[ 1 ], ttv[ 0 ], pNormal );
 407         VectorMA( pNormal, bump[ 2 ], dv->normal, pNormal );
 408
 409         /* renormalize and return */
 410         VectorNormalize( pNormal, pNormal );
 411 }
 412
 413
 414
 415 /*
 416 MapSingleLuxel()
 417 maps a luxel for triangle bv at
 418 */
 419
 420 #define NUDGE                   0.5f
 421 #define BOGUS_NUDGE             -99999.0f
 422
 423 static int MapSingleLuxel( rawLightmap_t *lm, surfaceInfo_t *info, bspDrawVert_t *dv, vec4_t plane, float pass, vec3_t stv[ 3 ], vec3_t ttv[ 3 ], vec3_t worldverts[ 3 ] )
 424 {
 425         int                             i, x, y, numClusters, *clusters, pointCluster, *cluster;
 426         float                   *luxel, *origin, *normal, d, lightmapSampleOffset;
 427         shaderInfo_t    *si;
 428         vec3_t                  pNormal;
 429         vec3_t                  vecs[ 3 ];
 430         vec3_t                  nudged;
 431         vec3_t                  cverts[ 3 ];
 432         vec3_t                  temp;
 433         vec4_t                  sideplane, hostplane;
 434         vec3_t                  origintwo;
 435         int                             j, next;
 436         float                   e;
 437         float                   *nudge;
 438         static float    nudges[][ 2 ] =
 439                                         {
 440                                                 //%{ 0, 0 },            /* try center first */
 441                                                 { -NUDGE, 0 },          /* left */
 442                                                 { NUDGE, 0 },           /* right */
 443                                                 { 0, NUDGE },           /* up */
 444                                                 { 0, -NUDGE },          /* down */
 445                                                 { -NUDGE, NUDGE },      /* left/up */
 446                                                 { NUDGE, -NUDGE },      /* right/down */
 447                                                 { NUDGE, NUDGE },       /* right/up */
 448                                                 { -NUDGE, -NUDGE },     /* left/down */
 449                                                 { BOGUS_NUDGE, BOGUS_NUDGE }
 450                                         };
 451
 452
 453         /* find luxel xy coords (fixme: subtract 0.5?) */
 454         x = dv->lightmap[ 0 ][ 0 ];
 455         y = dv->lightmap[ 0 ][ 1 ];
 456         if( x < 0 )
 457                 x = 0;
 458         else if( x >= lm->sw )
 459                 x = lm->sw - 1;
 460         if( y < 0 )
 461                 y = 0;
 462         else if( y >= lm->sh )
 463                 y = lm->sh - 1;
 464
 465         /* set shader and cluster list */
 466         if( info != NULL )
 467         {
 468                 si = info->si;
 469                 numClusters = info->numSurfaceClusters;
 470                 clusters = &surfaceClusters[ info->firstSurfaceCluster ];
 471         }
 472         else
 473         {
 474                 si = NULL;
 475                 numClusters = 0;
 476                 clusters = NULL;
 477         }
 478
 479         /* get luxel, origin, cluster, and normal */
 480         luxel = SUPER_LUXEL( 0, x, y );
 481         origin = SUPER_ORIGIN( x, y );
 482         normal = SUPER_NORMAL( x, y );
 483         cluster = SUPER_CLUSTER( x, y );
 484
 485         /* don't attempt to remap occluded luxels for planar surfaces */
 486         if( (*cluster) == CLUSTER_OCCLUDED && lm->plane != NULL )
 487                 return (*cluster);
 488
 489         /* only average the normal for premapped luxels */
 490         else if( (*cluster) >= 0 )
 491         {
 492                 /* do bumpmap calculations */
 493                 if( stv != NULL )
 494                         PerturbNormal( dv, si, pNormal, stv, ttv );
 495                 else
 496                         VectorCopy( dv->normal, pNormal );
 497
 498                 /* add the additional normal data */
 499                 VectorAdd( normal, pNormal, normal );
 500                 luxel[ 3 ] += 1.0f;
 501                 return (*cluster);
 502         }
 503
 504         /* otherwise, unmapped luxels (*cluster == CLUSTER_UNMAPPED) will have their full attributes calculated */
 505
 506         /* get origin */
 507
 508         /* axial lightmap projection */
 509         if( lm->vecs != NULL )
 510         {
 511                 /* calculate an origin for the sample from the lightmap vectors */
 512                 VectorCopy( lm->origin, origin );
 513                 for( i = 0; i < 3; i++ )
 514                 {
 515                         /* add unless it's the axis, which is taken care of later */
 516                         if( i == lm->axisNum )
 517                                 continue;
 518                         origin[ i ] += (x * lm->vecs[ 0 ][ i ]) + (y * lm->vecs[ 1 ][ i ]);
 519                 }
 520
 521                 /* project the origin onto the plane */
 522                 d = DotProduct( origin, plane ) - plane[ 3 ];
 523                 d /= plane[ lm->axisNum ];
 524                 origin[ lm->axisNum ] -= d;
 525         }
 526
 527         /* non axial lightmap projection (explicit xyz) */
 528         else
 529                 VectorCopy( dv->xyz, origin );
 530
 531         //////////////////////
 532         //27's test to make sure samples stay within the triangle boundaries
 533         //1) Test the sample origin to see if it lays on the wrong side of any edge (x/y)
 534         //2) if it does, nudge it onto the correct side.
 535
 536         if (worldverts!=NULL && lightmapTriangleCheck)
 537         {
 538                 for (j=0;j<3;j++)
 539                 {
 540                         VectorCopy(worldverts[j],cverts[j]);
 541                 }
 542                 PlaneFromPoints(hostplane,cverts[0],cverts[1],cverts[2]);
 543
 544                 for (j=0;j<3;j++)
 545                 {
 546                         for (i=0;i<3;i++)
 547                         {
 548                                 //build plane using 2 edges and a normal
 549                                 next=(i+1)%3;
 550
 551                                 VectorCopy(cverts[next],temp);
 552                                 VectorAdd(temp,hostplane,temp);
 553                                 PlaneFromPoints(sideplane,cverts[i],cverts[ next ], temp);
 554
 555                                 //planetest sample point
 556                                 e=DotProduct(origin,sideplane);
 557                                 e=e-sideplane[3];
 558                                 if (e>0)
 559                                 {
 560                                         //we're bad.
 561                                         //VectorClear(origin);
 562                                         //Move the sample point back inside triangle bounds
 563                                         origin[0]-=sideplane[0]*(e+1);
 564                                         origin[1]-=sideplane[1]*(e+1);
 565                                         origin[2]-=sideplane[2]*(e+1);
 566 #ifdef DEBUG_27_1
 567                                         VectorClear(origin);
 568 #endif
 569                                 }
 570                         }
 571                 }
 572         }
 573
 574         ////////////////////////
 575
 576         /* planar surfaces have precalculated lightmap vectors for nudging */
 577         if( lm->plane != NULL )
 578         {
 579                 VectorCopy( lm->vecs[ 0 ], vecs[ 0 ] );
 580                 VectorCopy( lm->vecs[ 1 ], vecs[ 1 ] );
 581                 VectorCopy( lm->plane, vecs[ 2 ] );
 582         }
 583
 584         /* non-planar surfaces must calculate them */
 585         else
 586         {
 587                 if( plane != NULL )
 588                         VectorCopy( plane, vecs[ 2 ] );
 589                 else
 590                         VectorCopy( dv->normal, vecs[ 2 ] );
 591                 MakeNormalVectors( vecs[ 2 ], vecs[ 0 ], vecs[ 1 ] );
 592         }
 593
 594         /* push the origin off the surface a bit */
 595         if( si != NULL )
 596                 lightmapSampleOffset = si->lightmapSampleOffset;
 597         else
 598                 lightmapSampleOffset = DEFAULT_LIGHTMAP_SAMPLE_OFFSET;
 599         if( lm->axisNum < 0 )
 600                 VectorMA( origin, lightmapSampleOffset, vecs[ 2 ], origin );
 601         else if( vecs[ 2 ][ lm->axisNum ] < 0.0f )
 602                 origin[ lm->axisNum ] -= lightmapSampleOffset;
 603         else
 604                 origin[ lm->axisNum ] += lightmapSampleOffset;
 605
 606         VectorCopy(origin,origintwo);
 607         if(lightmapExtraVisClusterNudge)
 608         {
 609                 origintwo[0]+=vecs[2][0];
 610                 origintwo[1]+=vecs[2][1];
 611                 origintwo[2]+=vecs[2][2];
 612         }
 613
 614         /* get cluster */
 615         pointCluster = ClusterForPointExtFilter( origintwo, LUXEL_EPSILON, numClusters, clusters );
 616
 617         /* another retarded hack, storing nudge count in luxel[ 1 ] */
 618         luxel[ 1 ] = 0.0f;
 619
 620         /* point in solid? (except in dark mode) */
 621         if( pointCluster < 0 && dark == qfalse )
 622         {
 623                 /* nudge the the location around */
 624                 nudge = nudges[ 0 ];
 625                 while( nudge[ 0 ] > BOGUS_NUDGE && pointCluster < 0 )
 626                 {
 627                         /* nudge the vector around a bit */
 628                         for( i = 0; i < 3; i++ )
 629                         {
 630                                 /* set nudged point*/
 631                                 nudged[ i ] = origintwo[ i ] + (nudge[ 0 ] * vecs[ 0 ][ i ]) + (nudge[ 1 ] * vecs[ 1 ][ i ]);
 632                         }
 633                         nudge += 2;
 634
 635                         /* get pvs cluster */
 636                         pointCluster = ClusterForPointExtFilter( nudged, LUXEL_EPSILON, numClusters, clusters ); //% + 0.625 );
 637                         if( pointCluster >= 0 )
 638                                 VectorCopy( nudged, origin );
 639                         luxel[ 1 ] += 1.0f;
 640                 }
 641         }
 642
 643         /* as a last resort, if still in solid, try drawvert origin offset by normal (except in dark mode) */
 644         if( pointCluster < 0 && si != NULL && dark == qfalse )
 645         {
 646                 VectorMA( dv->xyz, lightmapSampleOffset, dv->normal, nudged );
 647                 pointCluster = ClusterForPointExtFilter( nudged, LUXEL_EPSILON, numClusters, clusters );
 648                 if( pointCluster >= 0 )
 649                         VectorCopy( nudged, origin );
 650                 luxel[ 1 ] += 1.0f;
 651         }
 652
 653         /* valid? */
 654         if( pointCluster < 0 )
 655         {
 656                 (*cluster) = CLUSTER_OCCLUDED;
 657                 VectorClear( origin );
 658                 VectorClear( normal );
 659                 numLuxelsOccluded++;
 660                 return (*cluster);
 661         }
 662
 663         /* debug code */
 664         //%     Sys_Printf( "%f %f %f\n", origin[ 0 ], origin[ 1 ], origin[ 2 ] );
 665
 666         /* do bumpmap calculations */
 667         if( stv )
 668                 PerturbNormal( dv, si, pNormal, stv, ttv );
 669         else
 670                 VectorCopy( dv->normal, pNormal );
 671
 672         /* store the cluster and normal */
 673         (*cluster) = pointCluster;
 674         VectorCopy( pNormal, normal );
 675
 676         /* store explicit mapping pass and implicit mapping pass */
 677         luxel[ 0 ] = pass;
 678         luxel[ 3 ] = 1.0f;
 679
 680         /* add to count */
 681         numLuxelsMapped++;
 682
 683         /* return ok */
 684         return (*cluster);
 685 }
 686
 687
 688
 689 /*
 690 MapTriangle_r()
 691 recursively subdivides a triangle until its edges are shorter
 692 than the distance between two luxels (thanks jc :)
 693 */
 694
 695 static void MapTriangle_r( rawLightmap_t *lm, surfaceInfo_t *info, bspDrawVert_t *dv[ 3 ], vec4_t plane, vec3_t stv[ 3 ], vec3_t ttv[ 3 ], vec3_t worldverts[ 3 ] )
 696 {
 697         bspDrawVert_t   mid, *dv2[ 3 ];
 698         int                             max;
 699
 700
 701         /* map the vertexes */
 702         #if 0
 703         MapSingleLuxel( lm, info, dv[ 0 ], plane, 1, stv, ttv );
 704         MapSingleLuxel( lm, info, dv[ 1 ], plane, 1, stv, ttv );
 705         MapSingleLuxel( lm, info, dv[ 2 ], plane, 1, stv, ttv );
 706         #endif
 707
 708         /* subdivide calc */
 709         {
 710                 int                     i;
 711                 float           *a, *b, dx, dy, dist, maxDist;
 712
 713
 714                 /* find the longest edge and split it */
 715                 max = -1;
 716                 maxDist = 0;
 717                 for( i = 0; i < 3; i++ )
 718                 {
 719                         /* get verts */
 720                         a = dv[ i ]->lightmap[ 0 ];
 721                         b = dv[ (i + 1) % 3 ]->lightmap[ 0 ];
 722
 723                         /* get dists */
 724                         dx = a[ 0 ] - b[ 0 ];
 725                         dy = a[ 1 ] - b[ 1 ];
 726                         dist = (dx * dx) + (dy * dy);   //% sqrt( (dx * dx) + (dy * dy) );
 727
 728                         /* longer? */
 729                         if( dist > maxDist )
 730                         {
 731                                 maxDist = dist;
 732                                 max = i;
 733                         }
 734                 }
 735
 736                 /* try to early out */
 737                 if( max < 0 || maxDist <= subdivideThreshold )  /* ydnar: was i < 0 instead of max < 0 (?) */
 738                         return;
 739         }
 740
 741         /* split the longest edge and map it */
 742         LerpDrawVert( dv[ max ], dv[ (max + 1) % 3 ], &mid );
 743         MapSingleLuxel( lm, info, &mid, plane, 1, stv, ttv, worldverts );
 744
 745         /* push the point up a little bit to account for fp creep (fixme: revisit this) */
 746         //%     VectorMA( mid.xyz, 2.0f, mid.normal, mid.xyz );
 747
 748         /* recurse to first triangle */
 749         VectorCopy( dv, dv2 );
 750         dv2[ max ] = &mid;
 751         MapTriangle_r( lm, info, dv2, plane, stv, ttv, worldverts );
 752
 753         /* recurse to second triangle */
 754         VectorCopy( dv, dv2 );
 755         dv2[ (max + 1) % 3 ] = &mid;
 756         MapTriangle_r( lm, info, dv2, plane, stv, ttv, worldverts );
 757 }
 758
 759
 760
 761 /*
 762 MapTriangle()
 763 seed function for MapTriangle_r()
 764 requires a cw ordered triangle
 765 */
 766
 767 static qboolean MapTriangle( rawLightmap_t *lm, surfaceInfo_t *info, bspDrawVert_t *dv[ 3 ], qboolean mapNonAxial )
 768 {
 769         int                             i;
 770         vec4_t                  plane;
 771         vec3_t                  *stv, *ttv, stvStatic[ 3 ], ttvStatic[ 3 ];
 772         vec3_t                  worldverts[ 3 ];
 773
 774
 775         /* get plane if possible */
 776         if( lm->plane != NULL )
 777         {
 778                 VectorCopy( lm->plane, plane );
 779                 plane[ 3 ] = lm->plane[ 3 ];
 780         }
 781
 782         /* otherwise make one from the points */
 783         else if( PlaneFromPoints( plane, dv[ 0 ]->xyz, dv[ 1 ]->xyz, dv[ 2 ]->xyz ) == qfalse )
 784                 return qfalse;
 785
 786         /* check to see if we need to calculate texture->world tangent vectors */
 787         if( info->si->normalImage != NULL && CalcTangentVectors( 3, dv, stvStatic, ttvStatic ) )
 788         {
 789                 stv = stvStatic;
 790                 ttv = ttvStatic;
 791         }
 792         else
 793         {
 794                 stv = NULL;
 795                 ttv = NULL;
 796         }
 797
 798         VectorCopy( dv[ 0 ]->xyz, worldverts[ 0 ] );
 799         VectorCopy( dv[ 1 ]->xyz, worldverts[ 1 ] );
 800         VectorCopy( dv[ 2 ]->xyz, worldverts[ 2 ] );
 801
 802         /* map the vertexes */
 803         MapSingleLuxel( lm, info, dv[ 0 ], plane, 1, stv, ttv, worldverts );
 804         MapSingleLuxel( lm, info, dv[ 1 ], plane, 1, stv, ttv, worldverts );
 805         MapSingleLuxel( lm, info, dv[ 2 ], plane, 1, stv, ttv, worldverts );
 806
 807         /* 2002-11-20: prefer axial triangle edges */
 808         if( mapNonAxial )
 809         {
 810                 /* subdivide the triangle */
 811                 MapTriangle_r( lm, info, dv, plane, stv, ttv, worldverts );
 812                 return qtrue;
 813         }
 814
 815         for( i = 0; i < 3; i++ )
 816         {
 817                 float                   *a, *b;
 818                 bspDrawVert_t   *dv2[ 3 ];
 819
 820
 821                 /* get verts */
 822                 a = dv[ i ]->lightmap[ 0 ];
 823                 b = dv[ (i + 1) % 3 ]->lightmap[ 0 ];
 824
 825                 /* make degenerate triangles for mapping edges */
 826                 if( fabs( a[ 0 ] - b[ 0 ] ) < 0.01f || fabs( a[ 1 ] - b[ 1 ] ) < 0.01f )
 827                 {
 828                         dv2[ 0 ] = dv[ i ];
 829                         dv2[ 1 ] = dv[ (i + 1) % 3 ];
 830                         dv2[ 2 ] = dv[ (i + 1) % 3 ];
 831
 832                         /* map the degenerate triangle */
 833                         MapTriangle_r( lm, info, dv2, plane, stv, ttv, worldverts );
 834                 }
 835         }
 836
 837         return qtrue;
 838 }
 839
 840
 841
 842 /*
 843 MapQuad_r()
 844 recursively subdivides a quad until its edges are shorter
 845 than the distance between two luxels
 846 */
 847
 848 static void MapQuad_r( rawLightmap_t *lm, surfaceInfo_t *info, bspDrawVert_t *dv[ 4 ], vec4_t plane, vec3_t stv[ 4 ], vec3_t ttv[ 4 ] )
 849 {
 850         bspDrawVert_t   mid[ 2 ], *dv2[ 4 ];
 851         int                             max;
 852
 853
 854         /* subdivide calc */
 855         {
 856                 int                     i;
 857                 float           *a, *b, dx, dy, dist, maxDist;
 858
 859
 860                 /* find the longest edge and split it */
 861                 max = -1;
 862                 maxDist = 0;
 863                 for( i = 0; i < 4; i++ )
 864                 {
 865                         /* get verts */
 866                         a = dv[ i ]->lightmap[ 0 ];
 867                         b = dv[ (i + 1) % 4 ]->lightmap[ 0 ];
 868
 869                         /* get dists */
 870                         dx = a[ 0 ] - b[ 0 ];
 871                         dy = a[ 1 ] - b[ 1 ];
 872                         dist = (dx * dx) + (dy * dy);   //% sqrt( (dx * dx) + (dy * dy) );
 873
 874                         /* longer? */
 875                         if( dist > maxDist )
 876                         {
 877                                 maxDist = dist;
 878                                 max = i;
 879                         }
 880                 }
 881
 882                 /* try to early out */
 883                 if( max < 0 || maxDist <= subdivideThreshold )
 884                         return;
 885         }
 886
 887         /* we only care about even/odd edges */
 888         max &= 1;
 889
 890         /* split the longest edges */
 891         LerpDrawVert( dv[ max ], dv[ (max + 1) % 4 ], &mid[ 0 ] );
 892         LerpDrawVert( dv[ max + 2 ], dv[ (max + 3) % 4 ], &mid[ 1 ] );
 893
 894         /* map the vertexes */
 895         MapSingleLuxel( lm, info, &mid[ 0 ], plane, 1, stv, ttv, NULL );
 896         MapSingleLuxel( lm, info, &mid[ 1 ], plane, 1, stv, ttv, NULL );
 897
 898         /* 0 and 2 */
 899         if( max == 0 )
 900         {
 901                 /* recurse to first quad */
 902                 dv2[ 0 ] = dv[ 0 ];
 903                 dv2[ 1 ] = &mid[ 0 ];
 904                 dv2[ 2 ] = &mid[ 1 ];
 905                 dv2[ 3 ] = dv[ 3 ];
 906                 MapQuad_r( lm, info, dv2, plane, stv, ttv );
 907
 908                 /* recurse to second quad */
 909                 dv2[ 0 ] = &mid[ 0 ];
 910                 dv2[ 1 ] = dv[ 1 ];
 911                 dv2[ 2 ] = dv[ 2 ];
 912                 dv2[ 3 ] = &mid[ 1 ];
 913                 MapQuad_r( lm, info, dv2, plane, stv, ttv );
 914         }
 915
 916         /* 1 and 3 */
 917         else
 918         {
 919                 /* recurse to first quad */
 920                 dv2[ 0 ] = dv[ 0 ];
 921                 dv2[ 1 ] = dv[ 1 ];
 922                 dv2[ 2 ] = &mid[ 0 ];
 923                 dv2[ 3 ] = &mid[ 1 ];
 924                 MapQuad_r( lm, info, dv2, plane, stv, ttv );
 925
 926                 /* recurse to second quad */
 927                 dv2[ 0 ] = &mid[ 1 ];
 928                 dv2[ 1 ] = &mid[ 0 ];
 929                 dv2[ 2 ] = dv[ 2 ];
 930                 dv2[ 3 ] = dv[ 3 ];
 931                 MapQuad_r( lm, info, dv2, plane, stv, ttv );
 932         }
 933 }
 934
 935
 936
 937 /*
 938 MapQuad()
 939 seed function for MapQuad_r()
 940 requires a cw ordered triangle quad
 941 */
 942
 943 #define QUAD_PLANAR_EPSILON             0.5f
 944
 945 static qboolean MapQuad( rawLightmap_t *lm, surfaceInfo_t *info, bspDrawVert_t *dv[ 4 ] )
 946 {
 947         float                   dist;
 948         vec4_t                  plane;
 949         vec3_t                  *stv, *ttv, stvStatic[ 4 ], ttvStatic[ 4 ];
 950
 951
 952         /* get plane if possible */
 953         if( lm->plane != NULL )
 954         {
 955                 VectorCopy( lm->plane, plane );
 956                 plane[ 3 ] = lm->plane[ 3 ];
 957         }
 958
 959         /* otherwise make one from the points */
 960         else if( PlaneFromPoints( plane, dv[ 0 ]->xyz, dv[ 1 ]->xyz, dv[ 2 ]->xyz ) == qfalse )
 961                 return qfalse;
 962
 963         /* 4th point must fall on the plane */
 964         dist = DotProduct( plane, dv[ 3 ]->xyz ) - plane[ 3 ];
 965         if( fabs( dist ) > QUAD_PLANAR_EPSILON )
 966                 return qfalse;
 967
 968         /* check to see if we need to calculate texture->world tangent vectors */
 969         if( info->si->normalImage != NULL && CalcTangentVectors( 4, dv, stvStatic, ttvStatic ) )
 970         {
 971                 stv = stvStatic;
 972                 ttv = ttvStatic;
 973         }
 974         else
 975         {
 976                 stv = NULL;
 977                 ttv = NULL;
 978         }
 979
 980         /* map the vertexes */
 981         MapSingleLuxel( lm, info, dv[ 0 ], plane, 1, stv, ttv, NULL );
 982         MapSingleLuxel( lm, info, dv[ 1 ], plane, 1, stv, ttv, NULL );
 983         MapSingleLuxel( lm, info, dv[ 2 ], plane, 1, stv, ttv, NULL );
 984         MapSingleLuxel( lm, info, dv[ 3 ], plane, 1, stv, ttv, NULL );
 985
 986         /* subdivide the quad */
 987         MapQuad_r( lm, info, dv, plane, stv, ttv );
 988         return qtrue;
 989 }
 990
 991
 992
 993 /*
 994 MapRawLightmap()
 995 maps the locations, normals, and pvs clusters for a raw lightmap
 996 */
 997
 998 #define VectorDivide( in, d, out )      VectorScale( in, (1.0f / (d)), out )    //%     (out)[ 0 ] = (in)[ 0 ] / (d), (out)[ 1 ] = (in)[ 1 ] / (d), (out)[ 2 ] = (in)[ 2 ] / (d)
 999
1000 void MapRawLightmap( int rawLightmapNum )
1001 {
1002         int                                     n, num, i, x, y, sx, sy, pw[ 5 ], r, *cluster, mapNonAxial;
1003         float                           *luxel, *origin, *normal, samples, radius, pass;
1004         rawLightmap_t           *lm;
1005         bspDrawSurface_t        *ds;
1006         surfaceInfo_t           *info;
1007         mesh_t                          src, *subdivided, *mesh;
1008         bspDrawVert_t           *verts, *dv[ 4 ], fake;
1009
1010
1011         /* bail if this number exceeds the number of raw lightmaps */
1012         if( rawLightmapNum >= numRawLightmaps )
1013                 return;
1014
1015         /* get lightmap */
1016         lm = &rawLightmaps[ rawLightmapNum ];
1017
1018         /* -----------------------------------------------------------------
1019            map referenced surfaces onto the raw lightmap
1020            ----------------------------------------------------------------- */
1021
1022         /* walk the list of surfaces on this raw lightmap */
1023         for( n = 0; n < lm->numLightSurfaces; n++ )
1024         {
1025                 /* with > 1 surface per raw lightmap, clear occluded */
1026                 if( n > 0 )
1027                 {
1028                         for( y = 0; y < lm->sh; y++ )
1029                         {
1030                                 for( x = 0; x < lm->sw; x++ )
1031                                 {
1032                                         /* get cluster */
1033                                         cluster = SUPER_CLUSTER( x, y );
1034                                         if( *cluster < 0 )
1035                                                 *cluster = CLUSTER_UNMAPPED;
1036                                 }
1037                         }
1038                 }
1039
1040                 /* get surface */
1041                 num = lightSurfaces[ lm->firstLightSurface + n ];
1042                 ds = &bspDrawSurfaces[ num ];
1043                 info = &surfaceInfos[ num ];
1044
1045                 /* bail if no lightmap to calculate */
1046                 if( info->lm != lm )
1047                 {
1048                         Sys_Printf( "!" );
1049                         continue;
1050                 }
1051
1052                 /* map the surface onto the lightmap origin/cluster/normal buffers */
1053                 switch( ds->surfaceType )
1054                 {
1055                         case MST_PLANAR:
1056                                 /* get verts */
1057                                 verts = yDrawVerts + ds->firstVert;
1058
1059                                 /* map the triangles */
1060                                 for( mapNonAxial = 0; mapNonAxial < 2; mapNonAxial++ )
1061                                 {
1062                                         for( i = 0; i < ds->numIndexes; i += 3 )
1063                                         {
1064                                                 dv[ 0 ] = &verts[ bspDrawIndexes[ ds->firstIndex + i ] ];
1065                                                 dv[ 1 ] = &verts[ bspDrawIndexes[ ds->firstIndex + i + 1 ] ];
1066                                                 dv[ 2 ] = &verts[ bspDrawIndexes[ ds->firstIndex + i + 2 ] ];
1067                                                 MapTriangle( lm, info, dv, mapNonAxial );
1068                                         }
1069                                 }
1070                                 break;
1071
1072                         case MST_PATCH:
1073                                 /* make a mesh from the drawsurf */
1074                                 src.width = ds->patchWidth;
1075                                 src.height = ds->patchHeight;
1076                                 src.verts = &yDrawVerts[ ds->firstVert ];
1077                                 //%     subdivided = SubdivideMesh( src, 8, 512 );
1078                                 subdivided = SubdivideMesh2( src, info->patchIterations );
1079
1080                                 /* fit it to the curve and remove colinear verts on rows/columns */
1081                                 PutMeshOnCurve( *subdivided );
1082                                 mesh = RemoveLinearMeshColumnsRows( subdivided );
1083                                 FreeMesh( subdivided );
1084
1085                                 /* get verts */
1086                                 verts = mesh->verts;
1087
1088                                 /* debug code */
1089                                 #if 0
1090                                         if( lm->plane )
1091                                         {
1092                                                 Sys_Printf( "Planar patch: [%1.3f %1.3f %1.3f] [%1.3f %1.3f %1.3f] [%1.3f %1.3f %1.3f]\n",
1093                                                         lm->plane[ 0 ], lm->plane[ 1 ], lm->plane[ 2 ],
1094                                                         lm->vecs[ 0 ][ 0 ], lm->vecs[ 0 ][ 1 ], lm->vecs[ 0 ][ 2 ],
1095                                                         lm->vecs[ 1 ][ 0 ], lm->vecs[ 1 ][ 1 ], lm->vecs[ 1 ][ 2 ] );
1096                                         }
1097                                 #endif
1098
1099                                 /* map the mesh quads */
1100                                 #if 0
1101
1102                                 for( mapNonAxial = 0; mapNonAxial < 2; mapNonAxial++ )
1103                                 {
1104                                         for( y = 0; y < (mesh->height - 1); y++ )
1105                                         {
1106                                                 for( x = 0; x < (mesh->width - 1); x++ )
1107                                                 {
1108                                                         /* set indexes */
1109                                                         pw[ 0 ] = x + (y * mesh->width);
1110                                                         pw[ 1 ] = x + ((y + 1) * mesh->width);
1111                                                         pw[ 2 ] = x + 1 + ((y + 1) * mesh->width);
1112                                                         pw[ 3 ] = x + 1 + (y * mesh->width);
1113                                                         pw[ 4 ] = x + (y * mesh->width);        /* same as pw[ 0 ] */
1114
1115                                                         /* set radix */
1116                                                         r = (x + y) & 1;
1117
1118                                                         /* get drawverts and map first triangle */
1119                                                         dv[ 0 ] = &verts[ pw[ r + 0 ] ];
1120                                                         dv[ 1 ] = &verts[ pw[ r + 1 ] ];
1121                                                         dv[ 2 ] = &verts[ pw[ r + 2 ] ];
1122                                                         MapTriangle( lm, info, dv, mapNonAxial );
1123
1124                                                         /* get drawverts and map second triangle */
1125                                                         dv[ 0 ] = &verts[ pw[ r + 0 ] ];
1126                                                         dv[ 1 ] = &verts[ pw[ r + 2 ] ];
1127                                                         dv[ 2 ] = &verts[ pw[ r + 3 ] ];
1128                                                         MapTriangle( lm, info, dv, mapNonAxial );
1129                                                 }
1130                                         }
1131                                 }
1132
1133                                 #else
1134
1135                                 for( y = 0; y < (mesh->height - 1); y++ )
1136                                 {
1137                                         for( x = 0; x < (mesh->width - 1); x++ )
1138                                         {
1139                                                 /* set indexes */
1140                                                 pw[ 0 ] = x + (y * mesh->width);
1141                                                 pw[ 1 ] = x + ((y + 1) * mesh->width);
1142                                                 pw[ 2 ] = x + 1 + ((y + 1) * mesh->width);
1143                                                 pw[ 3 ] = x + 1 + (y * mesh->width);
1144                                                 pw[ 4 ] = pw[ 0 ];
1145
1146                                                 /* set radix */
1147                                                 r = (x + y) & 1;
1148
1149                                                 /* attempt to map quad first */
1150                                                 dv[ 0 ] = &verts[ pw[ r + 0 ] ];
1151                                                 dv[ 1 ] = &verts[ pw[ r + 1 ] ];
1152                                                 dv[ 2 ] = &verts[ pw[ r + 2 ] ];
1153                                                 dv[ 3 ] = &verts[ pw[ r + 3 ] ];
1154                                                 if( MapQuad( lm, info, dv ) )
1155                                                         continue;
1156
1157                                                 /* get drawverts and map first triangle */
1158                                                 MapTriangle( lm, info, dv, mapNonAxial );
1159
1160                                                 /* get drawverts and map second triangle */
1161                                                 dv[ 1 ] = &verts[ pw[ r + 2 ] ];
1162                                                 dv[ 2 ] = &verts[ pw[ r + 3 ] ];
1163                                                 MapTriangle( lm, info, dv, mapNonAxial );
1164                                         }
1165                                 }
1166
1167                                 #endif
1168
1169                                 /* free the mesh */
1170                                 FreeMesh( mesh );
1171                                 break;
1172
1173                         default:
1174                                 break;
1175                 }
1176         }
1177
1178         /* -----------------------------------------------------------------
1179            average and clean up luxel normals
1180            ----------------------------------------------------------------- */
1181
1182         /* walk the luxels */
1183         for( y = 0; y < lm->sh; y++ )
1184         {
1185                 for( x = 0; x < lm->sw; x++ )
1186                 {
1187                         /* get luxel */
1188                         luxel = SUPER_LUXEL( 0, x, y );
1189                         normal = SUPER_NORMAL( x, y );
1190                         cluster = SUPER_CLUSTER( x, y );
1191
1192                         /* only look at mapped luxels */
1193                         if( *cluster < 0 )
1194                                 continue;
1195
1196                         /* the normal data could be the sum of multiple samples */
1197                         if( luxel[ 3 ] > 1.0f )
1198                                 VectorNormalize( normal, normal );
1199
1200                         /* mark this luxel as having only one normal */
1201                         luxel[ 3 ] = 1.0f;
1202                 }
1203         }
1204
1205         /* non-planar surfaces stop here */
1206         if( lm->plane == NULL )
1207                 return;
1208
1209         /* -----------------------------------------------------------------
1210            map occluded or unuxed luxels
1211            ----------------------------------------------------------------- */
1212
1213         /* walk the luxels */
1214         radius = floor( superSample / 2 );
1215         radius = radius > 0 ? radius : 1.0f;
1216         radius += 1.0f;
1217         for( pass = 2.0f; pass <= radius; pass += 1.0f )
1218         {
1219                 for( y = 0; y < lm->sh; y++ )
1220                 {
1221                         for( x = 0; x < lm->sw; x++ )
1222                         {
1223                                 /* get luxel */
1224                                 luxel = SUPER_LUXEL( 0, x, y );
1225                                 normal = SUPER_NORMAL( x, y );
1226                                 cluster = SUPER_CLUSTER( x, y );
1227
1228                                 /* only look at unmapped luxels */
1229                                 if( *cluster != CLUSTER_UNMAPPED )
1230                                         continue;
1231
1232                                 /* divine a normal and origin from neighboring luxels */
1233                                 VectorClear( fake.xyz );
1234                                 VectorClear( fake.normal );
1235                                 fake.lightmap[ 0 ][ 0 ] = x;    //% 0.0001 + x;
1236                                 fake.lightmap[ 0 ][ 1 ] = y;    //% 0.0001 + y;
1237                                 samples = 0.0f;
1238                                 for( sy = (y - 1); sy <= (y + 1); sy++ )
1239                                 {
1240                                         if( sy < 0 || sy >= lm->sh )
1241                                                 continue;
1242
1243                                         for( sx = (x - 1); sx <= (x + 1); sx++ )
1244                                         {
1245                                                 if( sx < 0 || sx >= lm->sw || (sx == x && sy == y) )
1246                                                         continue;
1247
1248                                                 /* get neighboring luxel */
1249                                                 luxel = SUPER_LUXEL( 0, sx, sy );
1250                                                 origin = SUPER_ORIGIN( sx, sy );
1251                                                 normal = SUPER_NORMAL( sx, sy );
1252                                                 cluster = SUPER_CLUSTER( sx, sy );
1253
1254                                                 /* only consider luxels mapped in previous passes */
1255                                                 if( *cluster < 0 || luxel[ 0 ] >= pass )
1256                                                         continue;
1257
1258                                                 /* add its distinctiveness to our own */
1259                                                 VectorAdd( fake.xyz, origin, fake.xyz );
1260                                                 VectorAdd( fake.normal, normal, fake.normal );
1261                                                 samples += luxel[ 3 ];
1262                                         }
1263                                 }
1264
1265                                 /* any samples? */
1266                                 if( samples == 0.0f )
1267                                         continue;
1268
1269                                 /* average */
1270                                 VectorDivide( fake.xyz, samples, fake.xyz );
1271                                 //%     VectorDivide( fake.normal, samples, fake.normal );
1272                                 if( VectorNormalize( fake.normal, fake.normal ) == 0.0f )
1273                                         continue;
1274
1275                                 /* map the fake vert */
1276                                 MapSingleLuxel( lm, NULL, &fake, lm->plane, pass, NULL, NULL, NULL );
1277                         }
1278                 }
1279         }
1280
1281         /* -----------------------------------------------------------------
1282            average and clean up luxel normals
1283            ----------------------------------------------------------------- */
1284
1285         /* walk the luxels */
1286         for( y = 0; y < lm->sh; y++ )
1287         {
1288                 for( x = 0; x < lm->sw; x++ )
1289                 {
1290                         /* get luxel */
1291                         luxel = SUPER_LUXEL( 0, x, y );
1292                         normal = SUPER_NORMAL( x, y );
1293                         cluster = SUPER_CLUSTER( x, y );
1294
1295                         /* only look at mapped luxels */
1296                         if( *cluster < 0 )
1297                                 continue;
1298
1299                         /* the normal data could be the sum of multiple samples */
1300                         if( luxel[ 3 ] > 1.0f )
1301                                 VectorNormalize( normal, normal );
1302
1303                         /* mark this luxel as having only one normal */
1304                         luxel[ 3 ] = 1.0f;
1305                 }
1306         }
1307
1308         /* debug code */
1309         #if 0
1310                 Sys_Printf( "\n" );
1311                 for( y = 0; y < lm->sh; y++ )
1312                 {
1313                         for( x = 0; x < lm->sw; x++ )
1314                         {
1315                                 vec3_t  mins, maxs;
1316
1317
1318                                 cluster = SUPER_CLUSTER( x, y );
1319                                 origin = SUPER_ORIGIN( x, y );
1320                                 normal = SUPER_NORMAL( x, y );
1321                                 luxel = SUPER_LUXEL( x, y );
1322
1323                                 if( *cluster < 0 )
1324                                         continue;
1325
1326                                 /* check if within the bounding boxes of all surfaces referenced */
1327                                 ClearBounds( mins, maxs );
1328                                 for( n = 0; n < lm->numLightSurfaces; n++ )
1329                                 {
1330                                         int TOL;
1331                                         info = &surfaceInfos[ lightSurfaces[ lm->firstLightSurface + n ] ];
1332                                         TOL = info->sampleSize + 2;
1333                                         AddPointToBounds( info->mins, mins, maxs );
1334                                         AddPointToBounds( info->maxs, mins, maxs );
1335                                         if( origin[ 0 ] > (info->mins[ 0 ] - TOL) && origin[ 0 ] < (info->maxs[ 0 ] + TOL) &&
1336                                                 origin[ 1 ] > (info->mins[ 1 ] - TOL) && origin[ 1 ] < (info->maxs[ 1 ] + TOL) &&
1337                                                 origin[ 2 ] > (info->mins[ 2 ] - TOL) && origin[ 2 ] < (info->maxs[ 2 ] + TOL) )
1338                                                 break;
1339                                 }
1340
1341                                 /* inside? */
1342                                 if( n < lm->numLightSurfaces )
1343                                         continue;
1344
1345                                 /* report bogus origin */
1346                                 Sys_Printf( "%6d [%2d,%2d] (%4d): XYZ(%+4.1f %+4.1f %+4.1f) LO(%+4.1f %+4.1f %+4.1f) HI(%+4.1f %+4.1f %+4.1f) <%3.0f>\n",
1347                                         rawLightmapNum, x, y, *cluster,
1348                                         origin[ 0 ], origin[ 1 ], origin[ 2 ],
1349                                         mins[ 0 ], mins[ 1 ], mins[ 2 ],
1350                                         maxs[ 0 ], maxs[ 1 ], maxs[ 2 ],
1351                                         luxel[ 3 ] );
1352                         }
1353                 }
1354         #endif
1355 }
1356
1357
1358
1359 /*
1360 SetupDirt()
1361 sets up dirtmap (ambient occlusion)
1362 */
1363
1364 #define DIRT_CONE_ANGLE                         88      /* degrees */
1365 #define DIRT_NUM_ANGLE_STEPS            16
1366 #define DIRT_NUM_ELEVATION_STEPS        3
1367 #define DIRT_NUM_VECTORS                        (DIRT_NUM_ANGLE_STEPS * DIRT_NUM_ELEVATION_STEPS)
1368
1369 static vec3_t           dirtVectors[ DIRT_NUM_VECTORS ];
1370 static int                      numDirtVectors = 0;
1371
1372 void SetupDirt( void )
1373 {
1374         int             i, j;
1375         float   angle, elevation, angleStep, elevationStep;
1376
1377
1378         /* note it */
1379         Sys_FPrintf( SYS_VRB, "--- SetupDirt ---\n" );
1380
1381         /* calculate angular steps */
1382         angleStep = DEG2RAD( 360.0f / DIRT_NUM_ANGLE_STEPS );
1383         elevationStep = DEG2RAD( DIRT_CONE_ANGLE / DIRT_NUM_ELEVATION_STEPS );
1384
1385         /* iterate angle */
1386         angle = 0.0f;
1387         for( i = 0, angle = 0.0f; i < DIRT_NUM_ANGLE_STEPS; i++, angle += angleStep )
1388         {
1389                 /* iterate elevation */
1390                 for( j = 0, elevation = elevationStep * 0.5f; j < DIRT_NUM_ELEVATION_STEPS; j++, elevation += elevationStep )
1391                 {
1392                         dirtVectors[ numDirtVectors ][ 0 ] = sin( elevation ) * cos( angle );
1393                         dirtVectors[ numDirtVectors ][ 1 ] = sin( elevation ) * sin( angle );
1394                         dirtVectors[ numDirtVectors ][ 2 ] = cos( elevation );
1395                         numDirtVectors++;
1396                 }
1397         }
1398
1399         /* emit some statistics */
1400         Sys_FPrintf( SYS_VRB, "%9d dirtmap vectors\n", numDirtVectors );
1401 }
1402
1403
1404 /*
1405 DirtForSample()
1406 calculates dirt value for a given sample
1407 */
1408
1409 float DirtForSample( trace_t *trace )
1410 {
1411         int             i;
1412         float   gatherDirt, outDirt, angle, elevation, ooDepth;
1413         vec3_t  normal, worldUp, myUp, myRt, temp, direction, displacement;
1414
1415
1416         /* dummy check */
1417         if( !dirty )
1418                 return 1.0f;
1419         if( trace == NULL || trace->cluster < 0 )
1420                 return 0.0f;
1421
1422         /* setup */
1423         gatherDirt = 0.0f;
1424         ooDepth = 1.0f / dirtDepth;
1425         VectorCopy( trace->normal, normal );
1426
1427         /* check if the normal is aligned to the world-up */
1428         if( normal[ 0 ] == 0.0f && normal[ 1 ] == 0.0f )
1429         {
1430                 if( normal[ 2 ] == 1.0f )
1431                 {
1432                         VectorSet( myRt, 1.0f, 0.0f, 0.0f );
1433                         VectorSet( myUp, 0.0f, 1.0f, 0.0f );
1434                 }
1435                 else if( normal[ 2 ] == -1.0f )
1436                 {
1437                         VectorSet( myRt, -1.0f, 0.0f, 0.0f );
1438                         VectorSet( myUp,  0.0f, 1.0f, 0.0f );
1439                 }
1440         }
1441         else
1442         {
1443                 VectorSet( worldUp, 0.0f, 0.0f, 1.0f );
1444                 CrossProduct( normal, worldUp, myRt );
1445                 VectorNormalize( myRt, myRt );
1446                 CrossProduct( myRt, normal, myUp );
1447                 VectorNormalize( myUp, myUp );
1448         }
1449
1450         /* 1 = random mode, 0 (well everything else) = non-random mode */
1451         if( dirtMode == 1 )
1452         {
1453                 /* iterate */
1454                 for( i = 0; i < numDirtVectors; i++ )
1455                 {
1456                         /* get random vector */
1457                         angle = Random() * DEG2RAD( 360.0f );
1458                         elevation = Random() * DEG2RAD( DIRT_CONE_ANGLE );
1459                         temp[ 0 ] = cos( angle ) * sin( elevation );
1460                         temp[ 1 ] = sin( angle ) * sin( elevation );
1461                         temp[ 2 ] = cos( elevation );
1462
1463                         /* transform into tangent space */
1464                         direction[ 0 ] = myRt[ 0 ] * temp[ 0 ] + myUp[ 0 ] * temp[ 1 ] + normal[ 0 ] * temp[ 2 ];
1465                         direction[ 1 ] = myRt[ 1 ] * temp[ 0 ] + myUp[ 1 ] * temp[ 1 ] + normal[ 1 ] * temp[ 2 ];
1466                         direction[ 2 ] = myRt[ 2 ] * temp[ 0 ] + myUp[ 2 ] * temp[ 1 ] + normal[ 2 ] * temp[ 2 ];
1467
1468                         /* set endpoint */
1469                         VectorMA( trace->origin, dirtDepth, direction, trace->end );
1470                         SetupTrace( trace );
1471
1472                         /* trace */
1473                         TraceLine( trace );
1474                         if( trace->opaque )
1475                         {
1476                                 VectorSubtract( trace->hit, trace->origin, displacement );
1477                                 gatherDirt += 1.0f - ooDepth * VectorLength( displacement );
1478                         }
1479                 }
1480         }
1481         else
1482         {
1483                 /* iterate through ordered vectors */
1484                 for( i = 0; i < numDirtVectors; i++ )
1485                 {
1486                         /* transform vector into tangent space */
1487                         direction[ 0 ] = myRt[ 0 ] * dirtVectors[ i ][ 0 ] + myUp[ 0 ] * dirtVectors[ i ][ 1 ] + normal[ 0 ] * dirtVectors[ i ][ 2 ];
1488                         direction[ 1 ] = myRt[ 1 ] * dirtVectors[ i ][ 0 ] + myUp[ 1 ] * dirtVectors[ i ][ 1 ] + normal[ 1 ] * dirtVectors[ i ][ 2 ];
1489                         direction[ 2 ] = myRt[ 2 ] * dirtVectors[ i ][ 0 ] + myUp[ 2 ] * dirtVectors[ i ][ 1 ] + normal[ 2 ] * dirtVectors[ i ][ 2 ];
1490
1491                         /* set endpoint */
1492                         VectorMA( trace->origin, dirtDepth, direction, trace->end );
1493                         SetupTrace( trace );
1494
1495                         /* trace */
1496                         TraceLine( trace );
1497                         if( trace->opaque )
1498                         {
1499                                 VectorSubtract( trace->hit, trace->origin, displacement );
1500                                 gatherDirt += 1.0f - ooDepth * VectorLength( displacement );
1501                         }
1502                 }
1503         }
1504
1505         /* direct ray */
1506         VectorMA( trace->origin, dirtDepth, normal, trace->end );
1507         SetupTrace( trace );
1508
1509         /* trace */
1510         TraceLine( trace );
1511         if( trace->opaque )
1512         {
1513                 VectorSubtract( trace->hit, trace->origin, displacement );
1514                 gatherDirt += 1.0f - ooDepth * VectorLength( displacement );
1515         }
1516
1517         /* early out */
1518         if( gatherDirt <= 0.0f )
1519                 return 1.0f;
1520
1521         /* apply gain (does this even do much? heh) */
1522         outDirt = pow( gatherDirt / (numDirtVectors + 1), dirtGain );
1523         if( outDirt > 1.0f )
1524                 outDirt = 1.0f;
1525
1526         /* apply scale */
1527         outDirt *= dirtScale;
1528         if( outDirt > 1.0f )
1529                 outDirt = 1.0f;
1530
1531         /* return to sender */
1532         return 1.0f - outDirt;
1533 }
1534
1535
1536
1537 /*
1538 DirtyRawLightmap()
1539 calculates dirty fraction for each luxel
1540 */
1541
1542 void DirtyRawLightmap( int rawLightmapNum )
1543 {
1544         int                                     i, x, y, sx, sy, *cluster;
1545         float                           *origin, *normal, *dirt, *dirt2, average, samples;
1546         rawLightmap_t           *lm;
1547         surfaceInfo_t           *info;
1548         trace_t                         trace;
1549
1550
1551         /* bail if this number exceeds the number of raw lightmaps */
1552         if( rawLightmapNum >= numRawLightmaps )
1553                 return;
1554
1555         /* get lightmap */
1556         lm = &rawLightmaps[ rawLightmapNum ];
1557
1558         /* setup trace */
1559         trace.testOcclusion = qtrue;
1560         trace.forceSunlight = qfalse;
1561         trace.recvShadows = lm->recvShadows;
1562         trace.numSurfaces = lm->numLightSurfaces;
1563         trace.surfaces = &lightSurfaces[ lm->firstLightSurface ];
1564         trace.inhibitRadius = DEFAULT_INHIBIT_RADIUS;
1565         trace.testAll = qtrue;
1566
1567         /* twosided lighting (may or may not be a good idea for lightmapped stuff) */
1568         trace.twoSided = qfalse;
1569         for( i = 0; i < trace.numSurfaces; i++ )
1570         {
1571                 /* get surface */
1572                 info = &surfaceInfos[ trace.surfaces[ i ] ];
1573
1574                 /* check twosidedness */
1575                 if( info->si->twoSided )
1576                 {
1577                         trace.twoSided = qtrue;
1578                         break;
1579                 }
1580         }
1581
1582         /* gather dirt */
1583         for( y = 0; y < lm->sh; y++ )
1584         {
1585                 for( x = 0; x < lm->sw; x++ )
1586                 {
1587                         /* get luxel */
1588                         cluster = SUPER_CLUSTER( x, y );
1589                         origin = SUPER_ORIGIN( x, y );
1590                         normal = SUPER_NORMAL( x, y );
1591                         dirt = SUPER_DIRT( x, y );
1592
1593                         /* set default dirt */
1594                         *dirt = 0.0f;
1595
1596                         /* only look at mapped luxels */
1597                         if( *cluster < 0 )
1598                                 continue;
1599
1600                         /* copy to trace */
1601                         trace.cluster = *cluster;
1602                         VectorCopy( origin, trace.origin );
1603                         VectorCopy( normal, trace.normal );
1604
1605                         /* get dirt */
1606                         *dirt = DirtForSample( &trace );
1607                 }
1608         }
1609
1610         /* testing no filtering */
1611         //%     return;
1612
1613         /* filter dirt */
1614         for( y = 0; y < lm->sh; y++ )
1615         {
1616                 for( x = 0; x < lm->sw; x++ )
1617                 {
1618                         /* get luxel */
1619                         cluster = SUPER_CLUSTER( x, y );
1620                         dirt = SUPER_DIRT( x, y );
1621
1622                         /* filter dirt by adjacency to unmapped luxels */
1623                         average = *dirt;
1624                         samples = 1.0f;
1625                         for( sy = (y - 1); sy <= (y + 1); sy++ )
1626                         {
1627                                 if( sy < 0 || sy >= lm->sh )
1628                                         continue;
1629
1630                                 for( sx = (x - 1); sx <= (x + 1); sx++ )
1631                                 {
1632                                         if( sx < 0 || sx >= lm->sw || (sx == x && sy == y) )
1633                                                 continue;
1634
1635                                         /* get neighboring luxel */
1636                                         cluster = SUPER_CLUSTER( sx, sy );
1637                                         dirt2 = SUPER_DIRT( sx, sy );
1638                                         if( *cluster < 0 || *dirt2 <= 0.0f )
1639                                                 continue;
1640
1641                                         /* add it */
1642                                         average += *dirt2;
1643                                         samples += 1.0f;
1644                                 }
1645
1646                                 /* bail */
1647                                 if( samples <= 0.0f )
1648                                         break;
1649                         }
1650
1651                         /* bail */
1652                         if( samples <= 0.0f )
1653                                 continue;
1654
1655                         /* scale dirt */
1656                         *dirt = average / samples;
1657                 }
1658         }
1659 }
1660
1661
1662
1663 /*
1664 SubmapRawLuxel()
1665 calculates the pvs cluster, origin, normal of a sub-luxel
1666 */
1667
1668 static qboolean SubmapRawLuxel( rawLightmap_t *lm, int x, int y, float bx, float by, int *sampleCluster, vec3_t sampleOrigin, vec3_t sampleNormal )
1669 {
1670         int                     i, *cluster, *cluster2;
1671         float           *origin, *origin2, *normal;     //%     , *normal2;
1672         vec3_t          originVecs[ 2 ];                        //%     , normalVecs[ 2 ];
1673
1674
1675         /* calulate x vector */
1676         if( (x < (lm->sw - 1) && bx >= 0.0f) || (x == 0 && bx <= 0.0f) )
1677         {
1678                 cluster = SUPER_CLUSTER( x, y );
1679                 origin = SUPER_ORIGIN( x, y );
1680                 //%     normal = SUPER_NORMAL( x, y );
1681                 cluster2 = SUPER_CLUSTER( x + 1, y );
1682                 origin2 = *cluster2 < 0 ? SUPER_ORIGIN( x, y ) : SUPER_ORIGIN( x + 1, y );
1683                 //%     normal2 = *cluster2 < 0 ? SUPER_NORMAL( x, y ) : SUPER_NORMAL( x + 1, y );
1684         }
1685         else if( (x > 0 && bx <= 0.0f) || (x == (lm->sw - 1) && bx >= 0.0f) )
1686         {
1687                 cluster = SUPER_CLUSTER( x - 1, y );
1688                 origin = *cluster < 0 ? SUPER_ORIGIN( x, y ) : SUPER_ORIGIN( x - 1, y );
1689                 //%     normal = *cluster < 0 ? SUPER_NORMAL( x, y ) : SUPER_NORMAL( x - 1, y );
1690                 cluster2 = SUPER_CLUSTER( x, y );
1691                 origin2 = SUPER_ORIGIN( x, y );
1692                 //%     normal2 = SUPER_NORMAL( x, y );
1693         }
1694         else
1695                 Sys_Printf( "WARNING: Spurious lightmap S vector\n" );
1696
1697         VectorSubtract( origin2, origin, originVecs[ 0 ] );
1698         //%     VectorSubtract( normal2, normal, normalVecs[ 0 ] );
1699
1700         /* calulate y vector */
1701         if( (y < (lm->sh - 1) && bx >= 0.0f) || (y == 0 && bx <= 0.0f) )
1702         {
1703                 cluster = SUPER_CLUSTER( x, y );
1704                 origin = SUPER_ORIGIN( x, y );
1705                 //%     normal = SUPER_NORMAL( x, y );
1706                 cluster2 = SUPER_CLUSTER( x, y + 1 );
1707                 origin2 = *cluster2 < 0 ? SUPER_ORIGIN( x, y ) : SUPER_ORIGIN( x, y + 1 );
1708                 //%     normal2 = *cluster2 < 0 ? SUPER_NORMAL( x, y ) : SUPER_NORMAL( x, y + 1 );
1709         }
1710         else if( (y > 0 && bx <= 0.0f) || (y == (lm->sh - 1) && bx >= 0.0f) )
1711         {
1712                 cluster = SUPER_CLUSTER( x, y - 1 );
1713                 origin = *cluster < 0 ? SUPER_ORIGIN( x, y ) : SUPER_ORIGIN( x, y - 1 );
1714                 //%     normal = *cluster < 0 ? SUPER_NORMAL( x, y ) : SUPER_NORMAL( x, y - 1 );
1715                 cluster2 = SUPER_CLUSTER( x, y );
1716                 origin2 = SUPER_ORIGIN( x, y );
1717                 //%     normal2 = SUPER_NORMAL( x, y );
1718         }
1719         else
1720                 Sys_Printf( "WARNING: Spurious lightmap T vector\n" );
1721
1722         VectorSubtract( origin2, origin, originVecs[ 1 ] );
1723         //%     VectorSubtract( normal2, normal, normalVecs[ 1 ] );
1724
1725         /* calculate new origin */
1726         //%     VectorMA( origin, bx, originVecs[ 0 ], sampleOrigin );
1727         //%     VectorMA( sampleOrigin, by, originVecs[ 1 ], sampleOrigin );
1728         for( i = 0; i < 3; i++ )
1729                 sampleOrigin[ i ] = sampleOrigin[ i ] + (bx * originVecs[ 0 ][ i ]) + (by * originVecs[ 1 ][ i ]);
1730
1731         /* get cluster */
1732         *sampleCluster = ClusterForPointExtFilter( sampleOrigin, (LUXEL_EPSILON * 2), lm->numLightClusters, lm->lightClusters );
1733         if( *sampleCluster < 0 )
1734                 return qfalse;
1735
1736         /* calculate new normal */
1737         //%     VectorMA( normal, bx, normalVecs[ 0 ], sampleNormal );
1738         //%     VectorMA( sampleNormal, by, normalVecs[ 1 ], sampleNormal );
1739         //%     if( VectorNormalize( sampleNormal, sampleNormal ) <= 0.0f )
1740         //%             return qfalse;
1741         normal = SUPER_NORMAL( x, y );
1742         VectorCopy( normal, sampleNormal );
1743
1744         /* return ok */
1745         return qtrue;
1746 }
1747
1748
1749 /*
1750 SubsampleRawLuxel_r()
1751 recursively subsamples a luxel until its color gradient is low enough or subsampling limit is reached
1752 */
1753
1754 static void SubsampleRawLuxel_r( rawLightmap_t *lm, trace_t *trace, vec3_t sampleOrigin, int x, int y, float bias, float *lightLuxel )
1755 {
1756         int                     b, samples, mapped, lighted;
1757         int                     cluster[ 4 ];
1758         vec4_t          luxel[ 4 ];
1759         vec3_t          origin[ 4 ], normal[ 4 ];
1760         float           biasDirs[ 4 ][ 2 ] = { { -1.0f, -1.0f }, { 1.0f, -1.0f }, { -1.0f, 1.0f }, { 1.0f, 1.0f } };
1761         vec3_t          color, total;
1762
1763
1764         /* limit check */
1765         if( lightLuxel[ 3 ] >= lightSamples )
1766                 return;
1767
1768         /* setup */
1769         VectorClear( total );
1770         mapped = 0;
1771         lighted = 0;
1772
1773         /* make 2x2 subsample stamp */
1774         for( b = 0; b < 4; b++ )
1775         {
1776                 /* set origin */
1777                 VectorCopy( sampleOrigin, origin[ b ] );
1778
1779                 /* calculate position */
1780                 if( !SubmapRawLuxel( lm, x, y, (bias * biasDirs[ b ][ 0 ]), (bias * biasDirs[ b ][ 1 ]), &cluster[ b ], origin[ b ], normal[ b ] ) )
1781                 {
1782                         cluster[ b ] = -1;
1783                         continue;
1784                 }
1785                 mapped++;
1786
1787                 /* increment sample count */
1788                 luxel[ b ][ 3 ] = lightLuxel[ 3 ] + 1.0f;
1789
1790                 /* setup trace */
1791                 trace->cluster = *cluster;
1792                 VectorCopy( origin[ b ], trace->origin );
1793                 VectorCopy( normal[ b ], trace->normal );
1794
1795                 /* sample light */
1796
1797                 LightContributionToSample( trace );
1798
1799                 /* add to totals (fixme: make contrast function) */
1800                 VectorCopy( trace->color, luxel[ b ] );
1801                 VectorAdd( total, trace->color, total );
1802                 if( (luxel[ b ][ 0 ] + luxel[ b ][ 1 ] + luxel[ b ][ 2 ]) > 0.0f )
1803                         lighted++;
1804         }
1805
1806         /* subsample further? */
1807         if( (lightLuxel[ 3 ] + 1.0f) < lightSamples &&
1808                 (total[ 0 ] > 4.0f || total[ 1 ] > 4.0f || total[ 2 ] > 4.0f) &&
1809                 lighted != 0 && lighted != mapped )
1810         {
1811                 for( b = 0; b < 4; b++ )
1812                 {
1813                         if( cluster[ b ] < 0 )
1814                                 continue;
1815                         SubsampleRawLuxel_r( lm, trace, origin[ b ], x, y, (bias * 0.25f), luxel[ b ] );
1816                 }
1817         }
1818
1819         /* average */
1820         //%     VectorClear( color );
1821         //%     samples = 0;
1822         VectorCopy( lightLuxel, color );
1823         samples = 1;
1824         for( b = 0; b < 4; b++ )
1825         {
1826                 if( cluster[ b ] < 0 )
1827                         continue;
1828                 VectorAdd( color, luxel[ b ], color );
1829                 samples++;
1830         }
1831
1832         /* add to luxel */
1833         if( samples > 0 )
1834         {
1835                 /* average */
1836                 color[ 0 ] /= samples;
1837                 color[ 1 ] /= samples;
1838                 color[ 2 ] /= samples;
1839
1840                 /* add to color */
1841                 VectorCopy( color, lightLuxel );
1842                 lightLuxel[ 3 ] += 1.0f;
1843         }
1844 }
1845
1846
1847
1848 /*
1849 IlluminateRawLightmap()
1850 illuminates the luxels
1851 */
1852
1853 #define STACK_LL_SIZE                   (SUPER_LUXEL_SIZE * 64 * 64)
1854 #define LIGHT_LUXEL( x, y )             (lightLuxels + ((((y) * lm->sw) + (x)) * SUPER_LUXEL_SIZE))
1855
1856 void IlluminateRawLightmap( int rawLightmapNum )
1857 {
1858         int                                     i, t, x, y, sx, sy, size, llSize, luxelFilterRadius, lightmapNum;
1859         int                                     *cluster, *cluster2, mapped, lighted, totalLighted;
1860         rawLightmap_t           *lm;
1861         surfaceInfo_t           *info;
1862         qboolean                        filterColor, filterDir;
1863         float                           brightness;
1864         float                           *origin, *normal, *dirt, *luxel, *luxel2, *deluxel, *deluxel2;
1865         float                           *lightLuxels, *lightLuxel, samples, filterRadius, weight;
1866         vec3_t                          color, averageColor, averageDir, total, temp, temp2;
1867         float                           tests[ 4 ][ 2 ] = { { 0.0f, 0 }, { 1, 0 }, { 0, 1 }, { 1, 1 } };
1868         trace_t                         trace;
1869         float                           stackLightLuxels[ STACK_LL_SIZE ];
1870         vec3_t                          flood;
1871         float                           *floodlight;
1872
1873
1874         /* bail if this number exceeds the number of raw lightmaps */
1875         if( rawLightmapNum >= numRawLightmaps )
1876                 return;
1877
1878         /* get lightmap */
1879         lm = &rawLightmaps[ rawLightmapNum ];
1880
1881         /* setup trace */
1882         trace.testOcclusion = !noTrace;
1883         trace.forceSunlight = qfalse;
1884         trace.recvShadows = lm->recvShadows;
1885         trace.numSurfaces = lm->numLightSurfaces;
1886         trace.surfaces = &lightSurfaces[ lm->firstLightSurface ];
1887         trace.inhibitRadius = DEFAULT_INHIBIT_RADIUS;
1888
1889         /* twosided lighting (may or may not be a good idea for lightmapped stuff) */
1890         trace.twoSided = qfalse;
1891         for( i = 0; i < trace.numSurfaces; i++ )
1892         {
1893                 /* get surface */
1894                 info = &surfaceInfos[ trace.surfaces[ i ] ];
1895
1896                 /* check twosidedness */
1897                 if( info->si->twoSided )
1898                 {
1899                         trace.twoSided = qtrue;
1900                         break;
1901                 }
1902         }
1903
1904         /* create a culled light list for this raw lightmap */
1905         CreateTraceLightsForBounds( lm->mins, lm->maxs, lm->plane, lm->numLightClusters, lm->lightClusters, LIGHT_SURFACES, &trace );
1906
1907         /* -----------------------------------------------------------------
1908            fill pass
1909            ----------------------------------------------------------------- */
1910
1911         /* set counts */
1912         numLuxelsIlluminated += (lm->sw * lm->sh);
1913
1914         /* test debugging state */
1915         if( debugSurfaces || debugAxis || debugCluster || debugOrigin || dirtDebug || normalmap )
1916         {
1917                 /* debug fill the luxels */
1918                 for( y = 0; y < lm->sh; y++ )
1919                 {
1920                         for( x = 0; x < lm->sw; x++ )
1921                         {
1922                                 /* get cluster */
1923                                 cluster = SUPER_CLUSTER( x, y );
1924
1925                                 /* only fill mapped luxels */
1926                                 if( *cluster < 0 )
1927                                         continue;
1928
1929                                 /* get particulars */
1930                                 luxel = SUPER_LUXEL( 0, x, y );
1931                                 origin = SUPER_ORIGIN( x, y );
1932                                 normal = SUPER_NORMAL( x, y );
1933
1934                                 /* color the luxel with raw lightmap num? */
1935                                 if( debugSurfaces )
1936                                         VectorCopy( debugColors[ rawLightmapNum % 12 ], luxel );
1937
1938                                 /* color the luxel with lightmap axis? */
1939                                 else if( debugAxis )
1940                                 {
1941                                         luxel[ 0 ] = (lm->axis[ 0 ] + 1.0f) * 127.5f;
1942                                         luxel[ 1 ] = (lm->axis[ 1 ] + 1.0f) * 127.5f;
1943                                         luxel[ 2 ] = (lm->axis[ 2 ] + 1.0f) * 127.5f;
1944                                 }
1945
1946                                 /* color the luxel with luxel cluster? */
1947                                 else if( debugCluster )
1948                                         VectorCopy( debugColors[ *cluster % 12 ], luxel );
1949
1950                                 /* color the luxel with luxel origin? */
1951                                 else if( debugOrigin )
1952                                 {
1953                                         VectorSubtract( lm->maxs, lm->mins, temp );
1954                                         VectorScale( temp, (1.0f / 255.0f), temp );
1955                                         VectorSubtract( origin, lm->mins, temp2 );
1956                                         luxel[ 0 ] = lm->mins[ 0 ] + (temp[ 0 ] * temp2[ 0 ]);
1957                                         luxel[ 1 ] = lm->mins[ 1 ] + (temp[ 1 ] * temp2[ 1 ]);
1958                                         luxel[ 2 ] = lm->mins[ 2 ] + (temp[ 2 ] * temp2[ 2 ]);
1959                                 }
1960
1961                                 /* color the luxel with the normal */
1962                                 else if( normalmap )
1963                                 {
1964                                         luxel[ 0 ] = (normal[ 0 ] + 1.0f) * 127.5f;
1965                                         luxel[ 1 ] = (normal[ 1 ] + 1.0f) * 127.5f;
1966                                         luxel[ 2 ] = (normal[ 2 ] + 1.0f) * 127.5f;
1967                                 }
1968
1969                                 /* otherwise clear it */
1970                                 else
1971                                         VectorClear( luxel );
1972
1973                                 /* add to counts */
1974                                 luxel[ 3 ] = 1.0f;
1975                         }
1976                 }
1977         }
1978         else
1979         {
1980                 /* allocate temporary per-light luxel storage */
1981                 llSize = lm->sw * lm->sh * SUPER_LUXEL_SIZE * sizeof( float );
1982                 if( llSize <= (STACK_LL_SIZE * sizeof( float )) )
1983                         lightLuxels = stackLightLuxels;
1984                 else
1985                         lightLuxels = safe_malloc( llSize );
1986
1987                 /* clear luxels */
1988                 //%     memset( lm->superLuxels[ 0 ], 0, llSize );
1989
1990                 /* set ambient color */
1991                 for( y = 0; y < lm->sh; y++ )
1992                 {
1993                         for( x = 0; x < lm->sw; x++ )
1994                         {
1995                                 /* get cluster */
1996                                 cluster = SUPER_CLUSTER( x, y );
1997                                 luxel = SUPER_LUXEL( 0, x, y );
1998                                 normal = SUPER_NORMAL( x, y );
1999                                 deluxel = SUPER_DELUXEL( x, y );
2000
2001                                 /* blacken unmapped clusters */
2002                                 if( *cluster < 0 )
2003                                         VectorClear( luxel );
2004
2005                                 /* set ambient */
2006                                 else
2007                                 {
2008                                         VectorCopy( ambientColor, luxel );
2009                                         if( deluxemap )
2010                                         {
2011                                                 brightness = ambientColor[ 0 ] * 0.3f + ambientColor[ 1 ] * 0.59f + ambientColor[ 2 ] * 0.11f;
2012                                                 brightness *= (1.0 / 255.0);
2013                                                 // use AT LEAST this amount of contribution from ambient for the deluxemap, fixes points that receive ZERO light
2014                                                 if(brightness < 0.00390625f)
2015                                                         brightness = 0.00390625f;
2016                                                 VectorScale( normal, brightness, deluxel );
2017                                         }
2018                                         luxel[ 3 ] = 1.0f;
2019                                 }
2020                         }
2021                 }
2022
2023                 /* clear styled lightmaps */
2024                 size = lm->sw * lm->sh * SUPER_LUXEL_SIZE * sizeof( float );
2025                 for( lightmapNum = 1; lightmapNum < MAX_LIGHTMAPS; lightmapNum++ )
2026                 {
2027                         if( lm->superLuxels[ lightmapNum ] != NULL )
2028                                 memset( lm->superLuxels[ lightmapNum ], 0, size );
2029                 }
2030
2031                 /* debugging code */
2032                 //%     if( trace.numLights <= 0 )
2033                 //%             Sys_Printf( "Lightmap %9d: 0 lights, axis: %.2f, %.2f, %.2f\n", rawLightmapNum, lm->axis[ 0 ], lm->axis[ 1 ], lm->axis[ 2 ] );
2034
2035                 /* walk light list */
2036                 for( i = 0; i < trace.numLights; i++ )
2037                 {
2038                         /* setup trace */
2039                         trace.light = trace.lights[ i ];
2040
2041                         /* style check */
2042                         for( lightmapNum = 0; lightmapNum < MAX_LIGHTMAPS; lightmapNum++ )
2043                         {
2044                                 if( lm->styles[ lightmapNum ] == trace.light->style ||
2045                                         lm->styles[ lightmapNum ] == LS_NONE )
2046                                         break;
2047                         }
2048
2049                         /* max of MAX_LIGHTMAPS (4) styles allowed to hit a surface/lightmap */
2050                         if( lightmapNum >= MAX_LIGHTMAPS )
2051                         {
2052                                 Sys_Printf( "WARNING: Hit per-surface style limit (%d)\n", MAX_LIGHTMAPS );
2053                                 continue;
2054                         }
2055
2056                         /* setup */
2057                         memset( lightLuxels, 0, llSize );
2058                         totalLighted = 0;
2059
2060                         /* initial pass, one sample per luxel */
2061                         for( y = 0; y < lm->sh; y++ )
2062                         {
2063                                 for( x = 0; x < lm->sw; x++ )
2064                                 {
2065                                         /* get cluster */
2066                                         cluster = SUPER_CLUSTER( x, y );
2067                                         if( *cluster < 0 )
2068                                                 continue;
2069
2070                                         /* get particulars */
2071                                         lightLuxel = LIGHT_LUXEL( x, y );
2072                                         deluxel = SUPER_DELUXEL( x, y );
2073                                         origin = SUPER_ORIGIN( x, y );
2074                                         normal = SUPER_NORMAL( x, y );
2075
2076 #if 0
2077                                         ////////// 27's temp hack for testing edge clipping ////
2078                                         if( origin[0]==0 && origin[1]==0 && origin[2]==0 )
2079                                         {
2080                                                 lightLuxel[ 1 ] = 255;
2081                                                 lightLuxel[ 3 ] = 1.0f;
2082                                                 totalLighted++;
2083                                         }
2084                                         else
2085 #endif
2086                                         {
2087                                                 /* set contribution count */
2088                                                 lightLuxel[ 3 ] = 1.0f;
2089
2090                                                 /* setup trace */
2091                                                 trace.cluster = *cluster;
2092                                                 VectorCopy( origin, trace.origin );
2093                                                 VectorCopy( normal, trace.normal );
2094
2095                                                 /* get light for this sample */
2096                                                 LightContributionToSample( &trace );
2097                                                 VectorCopy( trace.color, lightLuxel );
2098
2099                                                 /* add to count */
2100                                                 if( trace.color[ 0 ] || trace.color[ 1 ] || trace.color[ 2 ] )
2101                                                         totalLighted++;
2102                                         }
2103
2104                                         /* add to light direction map (fixme: use luxel normal as starting point for deluxel?) */
2105                                         if( deluxemap )
2106                                         {
2107                                                 if(DotProduct(normal, trace.direction) > 0) // do not take light from the back side
2108                                                 {
2109                                                         /* color to grayscale (photoshop rgb weighting) */
2110                                                         brightness = trace.colorNoShadow[ 0 ] * 0.3f + trace.colorNoShadow[ 1 ] * 0.59f + trace.colorNoShadow[ 2 ] * 0.11f;
2111                                                         brightness *= (1.0 / 255.0);
2112                                                         VectorScale( trace.direction, brightness, trace.direction );
2113                                                         VectorAdd( deluxel, trace.direction, deluxel );
2114                                                 }
2115                                         }
2116                                 }
2117                         }
2118
2119                         /* don't even bother with everything else if nothing was lit */
2120                         if( totalLighted == 0 )
2121                                 continue;
2122
2123                         /* determine filter radius */
2124                         filterRadius = lm->filterRadius > trace.light->filterRadius
2125                                 ? lm->filterRadius
2126                                 : trace.light->filterRadius;
2127                         if( filterRadius < 0.0f )
2128                                 filterRadius = 0.0f;
2129
2130                         /* set luxel filter radius */
2131                         luxelFilterRadius = superSample * filterRadius / lm->sampleSize;
2132                         if( luxelFilterRadius == 0 && (filterRadius > 0.0f || filter) )
2133                                 luxelFilterRadius = 1;
2134
2135                         /* secondary pass, adaptive supersampling (fixme: use a contrast function to determine if subsampling is necessary) */
2136                         /* 2003-09-27: changed it so filtering disamples supersampling, as it would waste time */
2137                         if( lightSamples > 1 && luxelFilterRadius == 0 )
2138                         {
2139                                 /* walk luxels */
2140                                 for( y = 0; y < (lm->sh - 1); y++ )
2141                                 {
2142                                         for( x = 0; x < (lm->sw - 1); x++ )
2143                                         {
2144                                                 /* setup */
2145                                                 mapped = 0;
2146                                                 lighted = 0;
2147                                                 VectorClear( total );
2148
2149                                                 /* test 2x2 stamp */
2150                                                 for( t = 0; t < 4; t++ )
2151                                                 {
2152                                                         /* set sample coords */
2153                                                         sx = x + tests[ t ][ 0 ];
2154                                                         sy = y + tests[ t ][ 1 ];
2155
2156                                                         /* get cluster */
2157                                                         cluster = SUPER_CLUSTER( sx, sy );
2158                                                         if( *cluster < 0 )
2159                                                                 continue;
2160                                                         mapped++;
2161
2162                                                         /* get luxel */
2163                                                         lightLuxel = LIGHT_LUXEL( sx, sy );
2164                                                         VectorAdd( total, lightLuxel, total );
2165                                                         if( (lightLuxel[ 0 ] + lightLuxel[ 1 ] + lightLuxel[ 2 ]) > 0.0f )
2166                                                                 lighted++;
2167                                                 }
2168
2169                                                 /* if total color is under a certain amount, then don't bother subsampling */
2170                                                 if( total[ 0 ] <= 4.0f && total[ 1 ] <= 4.0f && total[ 2 ] <= 4.0f )
2171                                                         continue;
2172
2173                                                 /* if all 4 pixels are either in shadow or light, then don't subsample */
2174                                                 if( lighted != 0 && lighted != mapped )
2175                                                 {
2176                                                         for( t = 0; t < 4; t++ )
2177                                                         {
2178                                                                 /* set sample coords */
2179                                                                 sx = x + tests[ t ][ 0 ];
2180                                                                 sy = y + tests[ t ][ 1 ];
2181
2182                                                                 /* get luxel */
2183                                                                 cluster = SUPER_CLUSTER( sx, sy );
2184                                                                 if( *cluster < 0 )
2185                                                                         continue;
2186                                                                 lightLuxel = LIGHT_LUXEL( sx, sy );
2187                                                                 origin = SUPER_ORIGIN( sx, sy );
2188
2189                                                                 /* only subsample shadowed luxels */
2190                                                                 //%     if( (lightLuxel[ 0 ] + lightLuxel[ 1 ] + lightLuxel[ 2 ]) <= 0.0f )
2191                                                                 //%             continue;
2192
2193                                                                 /* subsample it */
2194                                                                 SubsampleRawLuxel_r( lm, &trace, origin, sx, sy, 0.25f, lightLuxel );
2195
2196                                                                 /* debug code to colorize subsampled areas to yellow */
2197                                                                 //%     luxel = SUPER_LUXEL( lightmapNum, sx, sy );
2198                                                                 //%     VectorSet( luxel, 255, 204, 0 );
2199                                                         }
2200                                                 }
2201                                         }
2202                                 }
2203                         }
2204
2205                         /* tertiary pass, apply dirt map (ambient occlusion) */
2206                         if( 0 && dirty )
2207                         {
2208                                 /* walk luxels */
2209                                 for( y = 0; y < lm->sh; y++ )
2210                                 {
2211                                         for( x = 0; x < lm->sw; x++ )
2212                                         {
2213                                                 /* get cluster  */
2214                                                 cluster = SUPER_CLUSTER( x, y );
2215                                                 if( *cluster < 0 )
2216                                                         continue;
2217
2218                                                 /* get particulars */
2219                                                 lightLuxel = LIGHT_LUXEL( x, y );
2220                                                 dirt = SUPER_DIRT( x, y );
2221
2222                                                 /* scale light value */
2223                                                 VectorScale( lightLuxel, *dirt, lightLuxel );
2224                                         }
2225                                 }
2226                         }
2227
2228                         /* allocate sampling lightmap storage */
2229                         if( lm->superLuxels[ lightmapNum ] == NULL )
2230                         {
2231                                 /* allocate sampling lightmap storage */
2232                                 size = lm->sw * lm->sh * SUPER_LUXEL_SIZE * sizeof( float );
2233                                 lm->superLuxels[ lightmapNum ] = safe_malloc( size );
2234                                 memset( lm->superLuxels[ lightmapNum ], 0, size );
2235                         }
2236
2237                         /* set style */
2238                         if( lightmapNum > 0 )
2239                         {
2240                                 lm->styles[ lightmapNum ] = trace.light->style;
2241                                 //%     Sys_Printf( "Surface %6d has lightstyle %d\n", rawLightmapNum, trace.light->style );
2242                         }
2243
2244                         /* copy to permanent luxels */
2245                         for( y = 0; y < lm->sh; y++ )
2246                         {
2247                                 for( x = 0; x < lm->sw; x++ )
2248                                 {
2249                                         /* get cluster and origin */
2250                                         cluster = SUPER_CLUSTER( x, y );
2251                                         if( *cluster < 0 )
2252                                                 continue;
2253                                         origin = SUPER_ORIGIN( x, y );
2254
2255                                         /* filter? */
2256                                         if( luxelFilterRadius )
2257                                         {
2258                                                 /* setup */
2259                                                 VectorClear( averageColor );
2260                                                 samples = 0.0f;
2261
2262                                                 /* cheaper distance-based filtering */
2263                                                 for( sy = (y - luxelFilterRadius); sy <= (y + luxelFilterRadius); sy++ )
2264                                                 {
2265                                                         if( sy < 0 || sy >= lm->sh )
2266                                                                 continue;
2267
2268                                                         for( sx = (x - luxelFilterRadius); sx <= (x + luxelFilterRadius); sx++ )
2269                                                         {
2270                                                                 if( sx < 0 || sx >= lm->sw )
2271                                                                         continue;
2272
2273                                                                 /* get particulars */
2274                                                                 cluster = SUPER_CLUSTER( sx, sy );
2275                                                                 if( *cluster < 0 )
2276                                                                         continue;
2277                                                                 lightLuxel = LIGHT_LUXEL( sx, sy );
2278
2279                                                                 /* create weight */
2280                                                                 weight = (abs( sx - x ) == luxelFilterRadius ? 0.5f : 1.0f);
2281                                                                 weight *= (abs( sy - y ) == luxelFilterRadius ? 0.5f : 1.0f);
2282
2283                                                                 /* scale luxel by filter weight */
2284                                                                 VectorScale( lightLuxel, weight, color );
2285                                                                 VectorAdd( averageColor, color, averageColor );
2286                                                                 samples += weight;
2287                                                         }
2288                                                 }
2289
2290                                                 /* any samples? */
2291                                                 if( samples <= 0.0f     )
2292                                                         continue;
2293
2294                                                 /* scale into luxel */
2295                                                 luxel = SUPER_LUXEL( lightmapNum, x, y );
2296                                                 luxel[ 3 ] = 1.0f;
2297
2298                                                 /* handle negative light */
2299                                                 if( trace.light->flags & LIGHT_NEGATIVE )
2300                                                 {
2301                                                         luxel[ 0 ] -= averageColor[ 0 ] / samples;
2302                                                         luxel[ 1 ] -= averageColor[ 1 ] / samples;
2303                                                         luxel[ 2 ] -= averageColor[ 2 ] / samples;
2304                                                 }
2305
2306                                                 /* handle normal light */
2307                                                 else
2308                                                 {
2309                                                         luxel[ 0 ] += averageColor[ 0 ] / samples;
2310                                                         luxel[ 1 ] += averageColor[ 1 ] / samples;
2311                                                         luxel[ 2 ] += averageColor[ 2 ] / samples;
2312                                                 }
2313                                         }
2314
2315                                         /* single sample */
2316                                         else
2317                                         {
2318                                                 /* get particulars */
2319                                                 lightLuxel = LIGHT_LUXEL( x, y );
2320                                                 luxel = SUPER_LUXEL( lightmapNum, x, y );
2321
2322                                                 /* handle negative light */
2323                                                 if( trace.light->flags & LIGHT_NEGATIVE )
2324                                                         VectorScale( averageColor, -1.0f, averageColor );
2325
2326                                                 /* add color */
2327                                                 luxel[ 3 ] = 1.0f;
2328
2329                                                 /* handle negative light */
2330                                                 if( trace.light->flags & LIGHT_NEGATIVE )
2331                                                         VectorSubtract( luxel, lightLuxel, luxel );
2332
2333                                                 /* handle normal light */
2334                                                 else
2335                                                         VectorAdd( luxel, lightLuxel, luxel );
2336                                         }
2337                                 }
2338                         }
2339                 }
2340
2341                 /* free temporary luxels */
2342                 if( lightLuxels != stackLightLuxels )
2343                         free( lightLuxels );
2344         }
2345
2346         /* free light list */
2347         FreeTraceLights( &trace );
2348
2349         /* floodlight pass */
2350         FloodlightIlluminateLightmap(lm);
2351
2352         if (debugnormals)
2353         {
2354                 for( lightmapNum = 0; lightmapNum < MAX_LIGHTMAPS; lightmapNum++ )
2355                 {
2356                         /* early out */
2357                         if( lm->superLuxels[ lightmapNum ] == NULL )
2358                                 continue;
2359
2360                         for( y = 0; y < lm->sh; y++ )
2361                         {
2362                                 for( x = 0; x < lm->sw; x++ )
2363                                 {
2364                                         /* get cluster */
2365                                         cluster = SUPER_CLUSTER( x, y );
2366                                         //%     if( *cluster < 0 )
2367                                         //%             continue;
2368
2369                                         /* get particulars */
2370                                         luxel = SUPER_LUXEL( lightmapNum, x, y );
2371                                         normal = SUPER_NORMAL (  x, y );
2372
2373                                         luxel[0]=(normal[0]*127)+127;
2374                                         luxel[1]=(normal[1]*127)+127;
2375                                         luxel[2]=(normal[2]*127)+127;
2376                                 }
2377                         }
2378                 }
2379         }
2380
2381         /*      -----------------------------------------------------------------
2382                 dirt pass
2383                 ----------------------------------------------------------------- */
2384
2385         if( dirty )
2386         {
2387                 /* walk lightmaps */
2388                 for( lightmapNum = 0; lightmapNum < MAX_LIGHTMAPS; lightmapNum++ )
2389                 {
2390                         /* early out */
2391                         if( lm->superLuxels[ lightmapNum ] == NULL )
2392                                 continue;
2393
2394                         /* apply dirt to each luxel */
2395                         for( y = 0; y < lm->sh; y++ )
2396                         {
2397                                 for( x = 0; x < lm->sw; x++ )
2398                                 {
2399                                         /* get cluster */
2400                                         cluster = SUPER_CLUSTER( x, y );
2401                                         //%     if( *cluster < 0 ) // TODO why not do this check? These pixels should be zero anyway
2402                                         //%             continue;
2403
2404                                         /* get particulars */
2405                                         luxel = SUPER_LUXEL( lightmapNum, x, y );
2406                                         dirt = SUPER_DIRT( x, y );
2407
2408                                         /* apply dirt */
2409                                         VectorScale( luxel, *dirt, luxel );
2410
2411                                         /* debugging */
2412                                         if( dirtDebug )
2413                                                 VectorSet( luxel, *dirt * 255.0f, *dirt * 255.0f, *dirt * 255.0f );
2414                                 }
2415                         }
2416                 }
2417         }
2418
2419         /* -----------------------------------------------------------------
2420            filter pass
2421            ----------------------------------------------------------------- */
2422
2423         /* walk lightmaps */
2424         for( lightmapNum = 0; lightmapNum < MAX_LIGHTMAPS; lightmapNum++ )
2425         {
2426                 /* early out */
2427                 if( lm->superLuxels[ lightmapNum ] == NULL )
2428                         continue;
2429
2430                 /* average occluded luxels from neighbors */
2431                 for( y = 0; y < lm->sh; y++ )
2432                 {
2433                         for( x = 0; x < lm->sw; x++ )
2434                         {
2435                                 /* get particulars */
2436                                 cluster = SUPER_CLUSTER( x, y );
2437                                 luxel = SUPER_LUXEL( lightmapNum, x, y );
2438                                 deluxel = SUPER_DELUXEL( x, y );
2439                                 normal = SUPER_NORMAL( x, y );
2440
2441                                 /* determine if filtering is necessary */
2442                                 filterColor = qfalse;
2443                                 filterDir = qfalse;
2444                                 if( *cluster < 0 ||
2445                                         (lm->splotchFix && (luxel[ 0 ] <= ambientColor[ 0 ] || luxel[ 1 ] <= ambientColor[ 1 ] || luxel[ 2 ] <= ambientColor[ 2 ])) )
2446                                         filterColor = qtrue;
2447                                 if( deluxemap && lightmapNum == 0 && (*cluster < 0 || filter) )
2448                                         filterDir = qtrue;
2449
2450                                 if( !filterColor && !filterDir )
2451                                         continue;
2452
2453                                 /* choose seed amount */
2454                                 VectorClear( averageColor );
2455                                 VectorClear( averageDir );
2456                                 samples = 0.0f;
2457
2458                                 /* walk 3x3 matrix */
2459                                 for( sy = (y - 1); sy <= (y + 1); sy++ )
2460                                 {
2461                                         if( sy < 0 || sy >= lm->sh )
2462                                                 continue;
2463
2464                                         for( sx = (x - 1); sx <= (x + 1); sx++ )
2465                                         {
2466                                                 if( sx < 0 || sx >= lm->sw || (sx == x && sy == y) )
2467                                                         continue;
2468
2469                                                 /* get neighbor's particulars */
2470                                                 cluster2 = SUPER_CLUSTER( sx, sy );
2471                                                 luxel2 = SUPER_LUXEL( lightmapNum, sx, sy );
2472                                                 deluxel2 = SUPER_DELUXEL( sx, sy );
2473
2474                                                 /* ignore unmapped/unlit luxels */
2475                                                 if( *cluster2 < 0 || luxel2[ 3 ] == 0.0f ||
2476                                                         (lm->splotchFix && VectorCompare( luxel2, ambientColor )) )
2477                                                         continue;
2478
2479                                                 /* add its distinctiveness to our own */
2480                                                 VectorAdd( averageColor, luxel2, averageColor );
2481                                                 samples += luxel2[ 3 ];
2482                                                 if( filterDir )
2483                                                         VectorAdd( averageDir, deluxel2, averageDir );
2484                                         }
2485                                 }
2486
2487                                 /* fall through */
2488                                 if( samples <= 0.0f )
2489                                         continue;
2490
2491                                 /* dark lightmap seams */
2492                                 if( dark )
2493                                 {
2494                                         if( lightmapNum == 0 )
2495                                                 VectorMA( averageColor, 2.0f, ambientColor, averageColor );
2496                                         samples += 2.0f;
2497                                 }
2498
2499                                 /* average it */
2500                                 if( filterColor )
2501                                 {
2502                                         VectorDivide( averageColor, samples, luxel );
2503                                         luxel[ 3 ] = 1.0f;
2504                                 }
2505                                 if( filterDir )
2506                                         VectorDivide( averageDir, samples, deluxel );
2507
2508                                 /* set cluster to -3 */
2509                                 if( *cluster < 0 )
2510                                         *cluster = CLUSTER_FLOODED;
2511                         }
2512                 }
2513         }
2514
2515
2516 #if 0
2517         // audit pass
2518         for( lightmapNum = 0; lightmapNum < MAX_LIGHTMAPS; lightmapNum++ )
2519         {
2520                 /* early out */
2521                 if( lm->superLuxels[ lightmapNum ] == NULL )
2522                         continue;
2523                 for( y = 0; y < lm->sh; y++ )
2524                         for( x = 0; x < lm->sw; x++ )
2525                         {
2526                                 /* get cluster */
2527                                 cluster = SUPER_CLUSTER( x, y );
2528                                 luxel = SUPER_LUXEL( lightmapNum, x, y );
2529                                 deluxel = SUPER_DELUXEL( x, y );
2530                                 if(!luxel || !deluxel || !cluster)
2531                                 {
2532                                         Sys_FPrintf(SYS_VRB, "WARNING: I got NULL'd.\n");
2533                                         continue;
2534                                 }
2535                                 else if(*cluster < 0)
2536                                 {
2537                                         // unmapped pixel
2538                                         // should have neither deluxemap nor lightmap
2539                                         if(deluxel[3])
2540                                                 Sys_FPrintf(SYS_VRB, "WARNING: I have written deluxe to an unmapped luxel. Sorry.\n");
2541                                 }
2542                                 else
2543                                 {
2544                                         // mapped pixel
2545                                         // should have both deluxemap and lightmap
2546                                         if(deluxel[3])
2547                                                 Sys_FPrintf(SYS_VRB, "WARNING: I forgot to write deluxe to a mapped luxel. Sorry.\n");
2548                                 }
2549                         }
2550         }
2551 #endif
2552 }
2553
2554
2555
2556 /*
2557 IlluminateVertexes()
2558 light the surface vertexes
2559 */
2560
2561 #define VERTEX_NUDGE    4.0f
2562
2563 void IlluminateVertexes( int num )
2564 {
2565         int                                     i, x, y, z, x1, y1, z1, sx, sy, radius, maxRadius, *cluster;
2566         int                                     lightmapNum, numAvg;
2567         float                           samples, *vertLuxel, *radVertLuxel, *luxel, dirt;
2568         vec3_t                          origin, temp, temp2, colors[ MAX_LIGHTMAPS ], avgColors[ MAX_LIGHTMAPS ];
2569         bspDrawSurface_t        *ds;
2570         surfaceInfo_t           *info;
2571         rawLightmap_t           *lm;
2572         bspDrawVert_t           *verts;
2573         trace_t                         trace;
2574
2575
2576         /* get surface, info, and raw lightmap */
2577         ds = &bspDrawSurfaces[ num ];
2578         info = &surfaceInfos[ num ];
2579         lm = info->lm;
2580
2581         /* -----------------------------------------------------------------
2582            illuminate the vertexes
2583            ----------------------------------------------------------------- */
2584
2585         /* calculate vertex lighting for surfaces without lightmaps */
2586         if( lm == NULL || cpmaHack )
2587         {
2588                 /* setup trace */
2589                 trace.testOcclusion = (cpmaHack && lm != NULL) ? qfalse : !noTrace;
2590                 trace.forceSunlight = info->si->forceSunlight;
2591                 trace.recvShadows = info->recvShadows;
2592                 trace.numSurfaces = 1;
2593                 trace.surfaces = &num;
2594                 trace.inhibitRadius = DEFAULT_INHIBIT_RADIUS;
2595
2596                 /* twosided lighting */
2597                 trace.twoSided = info->si->twoSided;
2598
2599                 /* make light list for this surface */
2600                 CreateTraceLightsForSurface( num, &trace );
2601
2602                 /* setup */
2603                 verts = yDrawVerts + ds->firstVert;
2604                 numAvg = 0;
2605                 memset( avgColors, 0, sizeof( avgColors ) );
2606
2607                 /* walk the surface verts */
2608                 for( i = 0; i < ds->numVerts; i++ )
2609                 {
2610                         /* get vertex luxel */
2611                         radVertLuxel = RAD_VERTEX_LUXEL( 0, ds->firstVert + i );
2612
2613                         /* color the luxel with raw lightmap num? */
2614                         if( debugSurfaces )
2615                                 VectorCopy( debugColors[ num % 12 ], radVertLuxel );
2616
2617                         /* color the luxel with luxel origin? */
2618                         else if( debugOrigin )
2619                         {
2620                                 VectorSubtract( info->maxs, info->mins, temp );
2621                                 VectorScale( temp, (1.0f / 255.0f), temp );
2622                                 VectorSubtract( origin, lm->mins, temp2 );
2623                                 radVertLuxel[ 0 ] = info->mins[ 0 ] + (temp[ 0 ] * temp2[ 0 ]);
2624                                 radVertLuxel[ 1 ] = info->mins[ 1 ] + (temp[ 1 ] * temp2[ 1 ]);
2625                                 radVertLuxel[ 2 ] = info->mins[ 2 ] + (temp[ 2 ] * temp2[ 2 ]);
2626                         }
2627
2628                         /* color the luxel with the normal */
2629                         else if( normalmap )
2630                         {
2631                                 radVertLuxel[ 0 ] = (verts[ i ].normal[ 0 ] + 1.0f) * 127.5f;
2632                                 radVertLuxel[ 1 ] = (verts[ i ].normal[ 1 ] + 1.0f) * 127.5f;
2633                                 radVertLuxel[ 2 ] = (verts[ i ].normal[ 2 ] + 1.0f) * 127.5f;
2634                         }
2635
2636                         /* illuminate the vertex */
2637                         else
2638                         {
2639                                 /* clear vertex luxel */
2640                                 VectorSet( radVertLuxel, -1.0f, -1.0f, -1.0f );
2641
2642                                 /* try at initial origin */
2643                                 trace.cluster = ClusterForPointExtFilter( verts[ i ].xyz, VERTEX_EPSILON, info->numSurfaceClusters, &surfaceClusters[ info->firstSurfaceCluster ] );
2644                                 if( trace.cluster >= 0 )
2645                                 {
2646                                         /* setup trace */
2647                                         VectorCopy( verts[ i ].xyz, trace.origin );
2648                                         VectorCopy( verts[ i ].normal, trace.normal );
2649
2650                                         /* r7 dirt */
2651                                         if( dirty )
2652                                                 dirt = DirtForSample( &trace );
2653                                         else
2654                                                 dirt = 1.0f;
2655
2656                                         /* trace */
2657                                         LightingAtSample( &trace, ds->vertexStyles, colors );
2658
2659                                         /* store */
2660                                         for( lightmapNum = 0; lightmapNum < MAX_LIGHTMAPS; lightmapNum++ )
2661                                         {
2662                                                 /* r7 dirt */
2663                                                 VectorScale( colors[ lightmapNum ], dirt, colors[ lightmapNum ] );
2664
2665                                                 /* store */
2666                                                 radVertLuxel = RAD_VERTEX_LUXEL( lightmapNum, ds->firstVert + i );
2667                                                 VectorCopy( colors[ lightmapNum ], radVertLuxel );
2668                                                 VectorAdd( avgColors[ lightmapNum ], colors[ lightmapNum ], colors[ lightmapNum ] );
2669                                         }
2670                                 }
2671
2672                                 /* is this sample bright enough? */
2673                                 radVertLuxel = RAD_VERTEX_LUXEL( 0, ds->firstVert + i );
2674                                 if( radVertLuxel[ 0 ] <= ambientColor[ 0 ] &&
2675                                         radVertLuxel[ 1 ] <= ambientColor[ 1 ] &&
2676                                         radVertLuxel[ 2 ] <= ambientColor[ 2 ] )
2677                                 {
2678                                         /* nudge the sample point around a bit */
2679                                         for( x = 0; x < 4; x++ )
2680                                         {
2681                                                 /* two's complement 0, 1, -1, 2, -2, etc */
2682                                                 x1 = ((x >> 1) ^ (x & 1 ? -1 : 0)) + (x & 1);
2683
2684                                                 for( y = 0; y < 4; y++ )
2685                                                 {
2686                                                         y1 = ((y >> 1) ^ (y & 1 ? -1 : 0)) + (y & 1);
2687
2688                                                         for( z = 0; z < 4; z++ )
2689                                                         {
2690                                                                 z1 = ((z >> 1) ^ (z & 1 ? -1 : 0)) + (z & 1);
2691
2692                                                                 /* nudge origin */
2693                                                                 trace.origin[ 0 ] = verts[ i ].xyz[ 0 ] + (VERTEX_NUDGE * x1);
2694                                                                 trace.origin[ 1 ] = verts[ i ].xyz[ 1 ] + (VERTEX_NUDGE * y1);
2695                                                                 trace.origin[ 2 ] = verts[ i ].xyz[ 2 ] + (VERTEX_NUDGE * z1);
2696
2697                                                                 /* try at nudged origin */
2698                                                                 trace.cluster = ClusterForPointExtFilter( origin, VERTEX_EPSILON, info->numSurfaceClusters, &surfaceClusters[ info->firstSurfaceCluster ] );
2699                                                                 if( trace.cluster < 0 )
2700                                                                         continue;
2701
2702                                                                 /* trace */
2703                                                                 LightingAtSample( &trace, ds->vertexStyles, colors );
2704
2705                                                                 /* store */
2706                                                                 for( lightmapNum = 0; lightmapNum < MAX_LIGHTMAPS; lightmapNum++ )
2707                                                                 {
2708                                                                         /* r7 dirt */
2709                                                                         VectorScale( colors[ lightmapNum ], dirt, colors[ lightmapNum ] );
2710
2711                                                                         /* store */
2712                                                                         radVertLuxel = RAD_VERTEX_LUXEL( lightmapNum, ds->firstVert + i );
2713                                                                         VectorCopy( colors[ lightmapNum ], radVertLuxel );
2714                                                                 }
2715
2716                                                                 /* bright enough? */
2717                                                                 radVertLuxel = RAD_VERTEX_LUXEL( 0, ds->firstVert + i );
2718                                                                 if( radVertLuxel[ 0 ] > ambientColor[ 0 ] ||
2719                                                                         radVertLuxel[ 1 ] > ambientColor[ 1 ] ||
2720                                                                         radVertLuxel[ 2 ] > ambientColor[ 2 ] )
2721                                                                         x = y = z = 1000;
2722                                                         }
2723                                                 }
2724                                         }
2725                                 }
2726
2727                                 /* add to average? */
2728                                 radVertLuxel = RAD_VERTEX_LUXEL( 0, ds->firstVert + i );
2729                                 if( radVertLuxel[ 0 ] > ambientColor[ 0 ] ||
2730                                         radVertLuxel[ 1 ] > ambientColor[ 1 ] ||
2731                                         radVertLuxel[ 2 ] > ambientColor[ 2 ] )
2732                                 {
2733                                         numAvg++;
2734                                         for( lightmapNum = 0; lightmapNum < MAX_LIGHTMAPS; lightmapNum++ )
2735                                         {
2736                                                 radVertLuxel = RAD_VERTEX_LUXEL( lightmapNum, ds->firstVert + i );
2737                                                 VectorAdd( avgColors[ lightmapNum ], radVertLuxel, avgColors[ lightmapNum ] );
2738                                         }
2739                                 }
2740                         }
2741
2742                         /* another happy customer */
2743                         numVertsIlluminated++;
2744                 }
2745
2746                 /* set average color */
2747                 if( numAvg > 0 )
2748                 {
2749                         for( lightmapNum = 0; lightmapNum < MAX_LIGHTMAPS; lightmapNum++ )
2750                                 VectorScale( avgColors[ lightmapNum ], (1.0f / numAvg), avgColors[ lightmapNum ] );
2751                 }
2752                 else
2753                 {
2754                         VectorCopy( ambientColor, avgColors[ 0 ] );
2755                 }
2756
2757                 /* clean up and store vertex color */
2758                 for( i = 0; i < ds->numVerts; i++ )
2759                 {
2760                         /* get vertex luxel */
2761                         radVertLuxel = RAD_VERTEX_LUXEL( 0, ds->firstVert + i );
2762
2763                         /* store average in occluded vertexes */
2764                         if( radVertLuxel[ 0 ] < 0.0f )
2765                         {
2766                                 for( lightmapNum = 0; lightmapNum < MAX_LIGHTMAPS; lightmapNum++ )
2767                                 {
2768                                         radVertLuxel = RAD_VERTEX_LUXEL( lightmapNum, ds->firstVert + i );
2769                                         VectorCopy( avgColors[ lightmapNum ], radVertLuxel );
2770
2771                                         /* debug code */
2772                                         //%     VectorSet( radVertLuxel, 255.0f, 0.0f, 0.0f );
2773                                 }
2774                         }
2775
2776                         /* store it */
2777                         for( lightmapNum = 0; lightmapNum < MAX_LIGHTMAPS; lightmapNum++ )
2778                         {
2779                                 /* get luxels */
2780                                 vertLuxel = VERTEX_LUXEL( lightmapNum, ds->firstVert + i );
2781                                 radVertLuxel = RAD_VERTEX_LUXEL( lightmapNum, ds->firstVert + i );
2782
2783                                 /* store */
2784                                 if( bouncing || bounce == 0 || !bounceOnly )
2785                                         VectorAdd( vertLuxel, radVertLuxel, vertLuxel );
2786                                 if( !info->si->noVertexLight )
2787                                         ColorToBytes( vertLuxel, verts[ i ].color[ lightmapNum ], info->si->vertexScale );
2788                         }
2789                 }
2790
2791                 /* free light list */
2792                 FreeTraceLights( &trace );
2793
2794                 /* return to sender */
2795                 return;
2796         }
2797
2798         /* -----------------------------------------------------------------
2799            reconstitute vertex lighting from the luxels
2800            ----------------------------------------------------------------- */
2801
2802         /* set styles from lightmap */
2803         for( lightmapNum = 0; lightmapNum < MAX_LIGHTMAPS; lightmapNum++ )
2804                 ds->vertexStyles[ lightmapNum ] = lm->styles[ lightmapNum ];
2805
2806         /* get max search radius */
2807         maxRadius = lm->sw;
2808         maxRadius = maxRadius > lm->sh ? maxRadius : lm->sh;
2809
2810         /* walk the surface verts */
2811         verts = yDrawVerts + ds->firstVert;
2812         for( i = 0; i < ds->numVerts; i++ )
2813         {
2814                 /* do each lightmap */
2815                 for( lightmapNum = 0; lightmapNum < MAX_LIGHTMAPS; lightmapNum++ )
2816                 {
2817                         /* early out */
2818                         if( lm->superLuxels[ lightmapNum ] == NULL )
2819                                 continue;
2820
2821                         /* get luxel coords */
2822                         x = verts[ i ].lightmap[ lightmapNum ][ 0 ];
2823                         y = verts[ i ].lightmap[ lightmapNum ][ 1 ];
2824                         if( x < 0 )
2825                                 x = 0;
2826                         else if( x >= lm->sw )
2827                                 x = lm->sw - 1;
2828                         if( y < 0 )
2829                                 y = 0;
2830                         else if( y >= lm->sh )
2831                                 y = lm->sh - 1;
2832
2833                         /* get vertex luxels */
2834                         vertLuxel = VERTEX_LUXEL( lightmapNum, ds->firstVert + i );
2835                         radVertLuxel = RAD_VERTEX_LUXEL( lightmapNum, ds->firstVert + i );
2836
2837                         /* color the luxel with the normal? */
2838                         if( normalmap )
2839                         {
2840                                 radVertLuxel[ 0 ] = (verts[ i ].normal[ 0 ] + 1.0f) * 127.5f;
2841                                 radVertLuxel[ 1 ] = (verts[ i ].normal[ 1 ] + 1.0f) * 127.5f;
2842                                 radVertLuxel[ 2 ] = (verts[ i ].normal[ 2 ] + 1.0f) * 127.5f;
2843                         }
2844
2845                         /* color the luxel with surface num? */
2846                         else if( debugSurfaces )
2847                                 VectorCopy( debugColors[ num % 12 ], radVertLuxel );
2848
2849                         /* divine color from the superluxels */
2850                         else
2851                         {
2852                                 /* increasing radius */
2853                                 VectorClear( radVertLuxel );
2854                                 samples = 0.0f;
2855                                 for( radius = 0; radius < maxRadius && samples <= 0.0f; radius++ )
2856                                 {
2857                                         /* sample within radius */
2858                                         for( sy = (y - radius); sy <= (y + radius); sy++ )
2859                                         {
2860                                                 if( sy < 0 || sy >= lm->sh )
2861                                                         continue;
2862
2863                                                 for( sx = (x - radius); sx <= (x + radius); sx++ )
2864                                                 {
2865                                                         if( sx < 0 || sx >= lm->sw )
2866                                                                 continue;
2867
2868                                                         /* get luxel particulars */
2869                                                         luxel = SUPER_LUXEL( lightmapNum, sx, sy );
2870                                                         cluster = SUPER_CLUSTER( sx, sy );
2871                                                         if( *cluster < 0 )
2872                                                                 continue;
2873
2874                                                         /* testing: must be brigher than ambient color */
2875                                                         //%     if( luxel[ 0 ] <= ambientColor[ 0 ] || luxel[ 1 ] <= ambientColor[ 1 ] || luxel[ 2 ] <= ambientColor[ 2 ] )
2876                                                         //%             continue;
2877
2878                                                         /* add its distinctiveness to our own */
2879                                                         VectorAdd( radVertLuxel, luxel, radVertLuxel );
2880                                                         samples += luxel[ 3 ];
2881                                                 }
2882                                         }
2883                                 }
2884
2885                                 /* any color? */
2886                                 if( samples > 0.0f )
2887                                         VectorDivide( radVertLuxel, samples, radVertLuxel );
2888                                 else
2889                                         VectorCopy( ambientColor, radVertLuxel );
2890                         }
2891
2892                         /* store into floating point storage */
2893                         VectorAdd( vertLuxel, radVertLuxel, vertLuxel );
2894                         numVertsIlluminated++;
2895
2896                         /* store into bytes (for vertex approximation) */
2897                         if( !info->si->noVertexLight )
2898                                 ColorToBytes( vertLuxel, verts[ i ].color[ lightmapNum ], 1.0f );
2899                 }
2900         }
2901 }
2902
2903
2904
2905 /* -------------------------------------------------------------------------------
2906
2907 light optimization (-fast)
2908
2909 creates a list of lights that will affect a surface and stores it in tw
2910 this is to optimize surface lighting by culling out as many of the
2911 lights in the world as possible from further calculation
2912
2913 ------------------------------------------------------------------------------- */
2914
2915 /*
2916 SetupBrushes()
2917 determines opaque brushes in the world and find sky shaders for sunlight calculations
2918 */
2919
2920 void SetupBrushes( void )
2921 {
2922         int                             i, j, b, compileFlags;
2923         qboolean                inside;
2924         bspBrush_t              *brush;
2925         bspBrushSide_t  *side;
2926         bspShader_t             *shader;
2927         shaderInfo_t    *si;
2928
2929
2930         /* note it */
2931         Sys_FPrintf( SYS_VRB, "--- SetupBrushes ---\n" );
2932
2933         /* allocate */
2934         if( opaqueBrushes == NULL )
2935                 opaqueBrushes = safe_malloc( numBSPBrushes / 8 + 1 );
2936
2937         /* clear */
2938         memset( opaqueBrushes, 0, numBSPBrushes / 8 + 1 );
2939         numOpaqueBrushes = 0;
2940
2941         /* walk the list of worldspawn brushes */
2942         for( i = 0; i < bspModels[ 0 ].numBSPBrushes; i++ )
2943         {
2944                 /* get brush */
2945                 b = bspModels[ 0 ].firstBSPBrush + i;
2946                 brush = &bspBrushes[ b ];
2947
2948                 /* check all sides */
2949                 inside = qtrue;
2950                 compileFlags = 0;
2951                 for( j = 0; j < brush->numSides && inside; j++ )
2952                 {
2953                         /* do bsp shader calculations */
2954                         side = &bspBrushSides[ brush->firstSide + j ];
2955                         shader = &bspShaders[ side->shaderNum ];
2956
2957                         /* get shader info */
2958                         si = ShaderInfoForShader( shader->shader );
2959                         if( si == NULL )
2960                                 continue;
2961
2962                         /* or together compile flags */
2963                         compileFlags |= si->compileFlags;
2964                 }
2965
2966                 /* determine if this brush is opaque to light */
2967                 if( !(compileFlags & C_TRANSLUCENT) )
2968                 {
2969                         opaqueBrushes[ b >> 3 ] |= (1 << (b & 7));
2970                         numOpaqueBrushes++;
2971                         maxOpaqueBrush = i;
2972                 }
2973         }
2974
2975         /* emit some statistics */
2976         Sys_FPrintf( SYS_VRB, "%9d opaque brushes\n", numOpaqueBrushes );
2977 }
2978
2979
2980
2981 /*
2982 ClusterVisible()
2983 determines if two clusters are visible to each other using the PVS
2984 */
2985
2986 qboolean ClusterVisible( int a, int b )
2987 {
2988         int                     portalClusters, leafBytes;
2989         byte            *pvs;
2990
2991
2992         /* dummy check */
2993         if( a < 0 || b < 0 )
2994                 return qfalse;
2995
2996         /* early out */
2997         if( a == b )
2998                 return qtrue;
2999
3000         /* not vised? */
3001         if( numBSPVisBytes <=8 )
3002                 return qtrue;
3003
3004         /* get pvs data */
3005         portalClusters = ((int *) bspVisBytes)[ 0 ];
3006         leafBytes = ((int*) bspVisBytes)[ 1 ];
3007         pvs = bspVisBytes + VIS_HEADER_SIZE + (a * leafBytes);
3008
3009         /* check */
3010         if( (pvs[ b >> 3 ] & (1 << (b & 7))) )
3011                 return qtrue;
3012         return qfalse;
3013 }
3014
3015
3016
3017 /*
3018 PointInLeafNum_r()
3019 borrowed from vlight.c
3020 */
3021
3022 int     PointInLeafNum_r( vec3_t point, int nodenum )
3023 {
3024         int                     leafnum;
3025         vec_t           dist;
3026         bspNode_t               *node;
3027         bspPlane_t      *plane;
3028
3029
3030         while( nodenum >= 0 )
3031         {
3032                 node = &bspNodes[ nodenum ];
3033                 plane = &bspPlanes[ node->planeNum ];
3034                 dist = DotProduct( point, plane->normal ) - plane->dist;
3035                 if( dist > 0.1 )
3036                         nodenum = node->children[ 0 ];
3037                 else if( dist < -0.1 )
3038                         nodenum = node->children[ 1 ];
3039                 else
3040                 {
3041                         leafnum = PointInLeafNum_r( point, node->children[ 0 ] );
3042                         if( bspLeafs[ leafnum ].cluster != -1 )
3043                                 return leafnum;
3044                         nodenum = node->children[ 1 ];
3045                 }
3046         }
3047
3048         leafnum = -nodenum - 1;
3049         return leafnum;
3050 }
3051
3052
3053
3054 /*
3055 PointInLeafnum()
3056 borrowed from vlight.c
3057 */
3058
3059 int     PointInLeafNum( vec3_t point )
3060 {
3061         return PointInLeafNum_r( point, 0 );
3062 }
3063
3064
3065
3066 /*
3067 ClusterVisibleToPoint() - ydnar
3068 returns qtrue if point can "see" cluster
3069 */
3070
3071 qboolean ClusterVisibleToPoint( vec3_t point, int cluster )
3072 {
3073         int             pointCluster;
3074
3075
3076         /* get leafNum for point */
3077         pointCluster = ClusterForPoint( point );
3078         if( pointCluster < 0 )
3079                 return qfalse;
3080
3081         /* check pvs */
3082         return ClusterVisible( pointCluster, cluster );
3083 }
3084
3085
3086
3087 /*
3088 ClusterForPoint() - ydnar
3089 returns the pvs cluster for point
3090 */
3091
3092 int ClusterForPoint( vec3_t point )
3093 {
3094         int             leafNum;
3095
3096
3097         /* get leafNum for point */
3098         leafNum = PointInLeafNum( point );
3099         if( leafNum < 0 )
3100                 return -1;
3101
3102         /* return the cluster */
3103         return bspLeafs[ leafNum ].cluster;
3104 }
3105
3106
3107
3108 /*
3109 ClusterForPointExt() - ydnar
3110 also takes brushes into account for occlusion testing
3111 */
3112
3113 int ClusterForPointExt( vec3_t point, float epsilon )
3114 {
3115         int                             i, j, b, leafNum, cluster;
3116         float                   dot;
3117         qboolean                inside;
3118         int                             *brushes, numBSPBrushes;
3119         bspLeaf_t               *leaf;
3120         bspBrush_t              *brush;
3121         bspPlane_t              *plane;
3122
3123
3124         /* get leaf for point */
3125         leafNum = PointInLeafNum( point );
3126         if( leafNum < 0 )
3127                 return -1;
3128         leaf = &bspLeafs[ leafNum ];
3129
3130         /* get the cluster */
3131         cluster = leaf->cluster;
3132         if( cluster < 0 )
3133                 return -1;
3134
3135         /* transparent leaf, so check point against all brushes in the leaf */
3136         brushes = &bspLeafBrushes[ leaf->firstBSPLeafBrush ];
3137         numBSPBrushes = leaf->numBSPLeafBrushes;
3138         for( i = 0; i < numBSPBrushes; i++ )
3139         {
3140                 /* get parts */
3141                 b = brushes[ i ];
3142                 if( b > maxOpaqueBrush )
3143                         continue;
3144                 brush = &bspBrushes[ b ];
3145                 if( !(opaqueBrushes[ b >> 3 ] & (1 << (b & 7))) )
3146                         continue;
3147
3148                 /* check point against all planes */
3149                 inside = qtrue;
3150                 for( j = 0; j < brush->numSides && inside; j++ )
3151                 {
3152                         plane = &bspPlanes[ bspBrushSides[ brush->firstSide + j ].planeNum ];
3153                         dot = DotProduct( point, plane->normal );
3154                         dot -= plane->dist;
3155                         if( dot > epsilon )
3156                                 inside = qfalse;
3157                 }
3158
3159                 /* if inside, return bogus cluster */
3160                 if( inside )
3161                         return -1 - b;
3162         }
3163
3164         /* if the point made it this far, it's not inside any opaque brushes */
3165         return cluster;
3166 }
3167
3168
3169
3170 /*
3171 ClusterForPointExtFilter() - ydnar
3172 adds cluster checking against a list of known valid clusters
3173 */
3174
3175 int ClusterForPointExtFilter( vec3_t point, float epsilon, int numClusters, int *clusters )
3176 {
3177         int             i, cluster;
3178
3179
3180         /* get cluster for point */
3181         cluster = ClusterForPointExt( point, epsilon );
3182
3183         /* check if filtering is necessary */
3184         if( cluster < 0 || numClusters <= 0 || clusters == NULL )
3185                 return cluster;
3186
3187         /* filter */
3188         for( i = 0; i < numClusters; i++ )
3189         {
3190                 if( cluster == clusters[ i ] || ClusterVisible( cluster, clusters[ i ] ) )
3191                         return cluster;
3192         }
3193
3194         /* failed */
3195         return -1;
3196 }
3197
3198
3199
3200 /*
3201 ShaderForPointInLeaf() - ydnar
3202 checks a point against all brushes in a leaf, returning the shader of the brush
3203 also sets the cumulative surface and content flags for the brush hit
3204 */
3205
3206 int ShaderForPointInLeaf( vec3_t point, int leafNum, float epsilon, int wantContentFlags, int wantSurfaceFlags, int *contentFlags, int *surfaceFlags )
3207 {
3208         int                             i, j;
3209         float                   dot;
3210         qboolean                inside;
3211         int                             *brushes, numBSPBrushes;
3212         bspLeaf_t                       *leaf;
3213         bspBrush_t              *brush;
3214         bspBrushSide_t  *side;
3215         bspPlane_t              *plane;
3216         bspShader_t             *shader;
3217         int                             allSurfaceFlags, allContentFlags;
3218
3219
3220         /* clear things out first */
3221         *surfaceFlags = 0;
3222         *contentFlags = 0;
3223
3224         /* get leaf */
3225         if( leafNum < 0 )
3226                 return -1;
3227         leaf = &bspLeafs[ leafNum ];
3228
3229         /* transparent leaf, so check point against all brushes in the leaf */
3230         brushes = &bspLeafBrushes[ leaf->firstBSPLeafBrush ];
3231         numBSPBrushes = leaf->numBSPLeafBrushes;
3232         for( i = 0; i < numBSPBrushes; i++ )
3233         {
3234                 /* get parts */
3235                 brush = &bspBrushes[ brushes[ i ] ];
3236
3237                 /* check point against all planes */
3238                 inside = qtrue;
3239                 allSurfaceFlags = 0;
3240                 allContentFlags = 0;
3241                 for( j = 0; j < brush->numSides && inside; j++ )
3242                 {
3243                         side = &bspBrushSides[ brush->firstSide + j ];
3244                         plane = &bspPlanes[ side->planeNum ];
3245                         dot = DotProduct( point, plane->normal );
3246                         dot -= plane->dist;
3247                         if( dot > epsilon )
3248                                 inside = qfalse;
3249                         else
3250                         {
3251                                 shader = &bspShaders[ side->shaderNum ];
3252                                 allSurfaceFlags |= shader->surfaceFlags;
3253                                 allContentFlags |= shader->contentFlags;
3254                         }
3255                 }
3256
3257                 /* handle if inside */
3258                 if( inside )
3259                 {
3260                         /* if there are desired flags, check for same and continue if they aren't matched */
3261                         if( wantContentFlags && !(wantContentFlags & allContentFlags) )
3262                                 continue;
3263                         if( wantSurfaceFlags && !(wantSurfaceFlags & allSurfaceFlags) )
3264                                 continue;
3265
3266                         /* store the cumulative flags and return the brush shader (which is mostly useless) */
3267                         *surfaceFlags = allSurfaceFlags;
3268                         *contentFlags = allContentFlags;
3269                         return brush->shaderNum;
3270                 }
3271         }
3272
3273         /* if the point made it this far, it's not inside any brushes */
3274         return -1;
3275 }
3276
3277
3278
3279 /*
3280 ChopBounds()
3281 chops a bounding box by the plane defined by origin and normal
3282 returns qfalse if the bounds is entirely clipped away
3283
3284 this is not exactly the fastest way to do this...
3285 */
3286
3287 qboolean ChopBounds( vec3_t mins, vec3_t maxs, vec3_t origin, vec3_t normal )
3288 {
3289         /* FIXME: rewrite this so it doesn't use bloody brushes */
3290         return qtrue;
3291 }
3292
3293
3294
3295 /*
3296 SetupEnvelopes()
3297 calculates each light's effective envelope,
3298 taking into account brightness, type, and pvs.
3299 */
3300
3301 #define LIGHT_EPSILON   0.125f
3302 #define LIGHT_NUDGE             2.0f
3303
3304 void SetupEnvelopes( qboolean forGrid, qboolean fastFlag )
3305 {
3306         int                     i, x, y, z, x1, y1, z1;
3307         light_t         *light, *light2, **owner;
3308         bspLeaf_t       *leaf;
3309         vec3_t          origin, dir, mins, maxs, nullVector = { 0, 0, 0 };
3310         float           radius, intensity;
3311         light_t         *buckets[ 256 ];
3312
3313
3314         /* early out for weird cases where there are no lights */
3315         if( lights == NULL )
3316                 return;
3317
3318         /* note it */
3319         Sys_FPrintf( SYS_VRB, "--- SetupEnvelopes%s ---\n", fastFlag ? " (fast)" : "" );
3320
3321         /* count lights */
3322         numLights = 0;
3323         numCulledLights = 0;
3324         owner = &lights;
3325         while( *owner != NULL )
3326         {
3327                 /* get light */
3328                 light = *owner;
3329
3330                 /* handle negative lights */
3331                 if( light->photons < 0.0f || light->add < 0.0f )
3332                 {
3333                         light->photons *= -1.0f;
3334                         light->add *= -1.0f;
3335                         light->flags |= LIGHT_NEGATIVE;
3336                 }
3337
3338                 /* sunlight? */
3339                 if( light->type == EMIT_SUN )
3340                 {
3341                         /* special cased */
3342                         light->cluster = 0;
3343                         light->envelope = MAX_WORLD_COORD * 8.0f;
3344                         VectorSet( light->mins, MIN_WORLD_COORD * 8.0f, MIN_WORLD_COORD * 8.0f, MIN_WORLD_COORD * 8.0f );
3345                         VectorSet( light->maxs, MAX_WORLD_COORD * 8.0f, MAX_WORLD_COORD * 8.0f, MAX_WORLD_COORD * 8.0f );
3346                 }
3347
3348                 /* everything else */
3349                 else
3350                 {
3351                         /* get pvs cluster for light */
3352                         light->cluster = ClusterForPointExt( light->origin, LIGHT_EPSILON );
3353
3354                         /* invalid cluster? */
3355                         if( light->cluster < 0 )
3356                         {
3357                                 /* nudge the sample point around a bit */
3358                                 for( x = 0; x < 4; x++ )
3359                                 {
3360                                         /* two's complement 0, 1, -1, 2, -2, etc */
3361                                         x1 = ((x >> 1) ^ (x & 1 ? -1 : 0)) + (x & 1);
3362
3363                                         for( y = 0; y < 4; y++ )
3364                                         {
3365                                                 y1 = ((y >> 1) ^ (y & 1 ? -1 : 0)) + (y & 1);
3366
3367                                                 for( z = 0; z < 4; z++ )
3368                                                 {
3369                                                         z1 = ((z >> 1) ^ (z & 1 ? -1 : 0)) + (z & 1);
3370
3371                                                         /* nudge origin */
3372                                                         origin[ 0 ] = light->origin[ 0 ] + (LIGHT_NUDGE * x1);
3373                                                         origin[ 1 ] = light->origin[ 1 ] + (LIGHT_NUDGE * y1);
3374                                                         origin[ 2 ] = light->origin[ 2 ] + (LIGHT_NUDGE * z1);
3375
3376                                                         /* try at nudged origin */
3377                                                         light->cluster = ClusterForPointExt( origin, LIGHT_EPSILON );
3378                                                         if( light->cluster < 0 )
3379                                                                 continue;
3380
3381                                                         /* set origin */
3382                                                         VectorCopy( origin, light->origin );
3383                                                 }
3384                                         }
3385                                 }
3386                         }
3387
3388                         /* only calculate for lights in pvs and outside of opaque brushes */
3389                         if( light->cluster >= 0 )
3390                         {
3391                                 /* set light fast flag */
3392                                 if( fastFlag )
3393                                         light->flags |= LIGHT_FAST_TEMP;
3394                                 else
3395                                         light->flags &= ~LIGHT_FAST_TEMP;
3396                                 if( light->si && light->si->noFast )
3397                                         light->flags &= ~(LIGHT_FAST | LIGHT_FAST_TEMP);
3398
3399                                 /* clear light envelope */
3400                                 light->envelope = 0;
3401
3402                                 /* handle area lights */
3403                                 if( exactPointToPolygon && light->type == EMIT_AREA && light->w != NULL )
3404                                 {
3405                                         /* ugly hack to calculate extent for area lights, but only done once */
3406                                         VectorScale( light->normal, -1.0f, dir );
3407                                         for( radius = 100.0f; radius < 130000.0f && light->envelope == 0; radius += 10.0f )
3408                                         {
3409                                                 float   factor;
3410
3411                                                 VectorMA( light->origin, radius, light->normal, origin );
3412                                                 factor = PointToPolygonFormFactor( origin, dir, light->w );
3413                                                 if( factor < 0.0f )
3414                                                         factor *= -1.0f;
3415                                                 if( (factor * light->add) <= light->falloffTolerance )
3416                                                         light->envelope = radius;
3417                                         }
3418
3419                                         /* check for fast mode */
3420                                         if( !(light->flags & LIGHT_FAST) && !(light->flags & LIGHT_FAST_TEMP) )
3421                                                 light->envelope = MAX_WORLD_COORD * 8.0f;
3422                                 }
3423                                 else
3424                                 {
3425                                         radius = 0.0f;
3426                                         intensity = light->photons;
3427                                 }
3428
3429                                 /* other calcs */
3430                                 if( light->envelope <= 0.0f )
3431                                 {
3432                                         /* solve distance for non-distance lights */
3433                                         if( !(light->flags & LIGHT_ATTEN_DISTANCE) )
3434                                                 light->envelope = MAX_WORLD_COORD * 8.0f;
3435
3436                                         /* solve distance for linear lights */
3437                                         else if( (light->flags & LIGHT_ATTEN_LINEAR ) )
3438                                                 //% light->envelope = ((intensity / light->falloffTolerance) * linearScale - 1 + radius) / light->fade;
3439                                                 light->envelope = ((intensity * linearScale) - light->falloffTolerance) / light->fade;
3440
3441                                                 /*
3442                                                 add = angle * light->photons * linearScale - (dist * light->fade);
3443                                                 T = (light->photons * linearScale) - (dist * light->fade);
3444                                                 T + (dist * light->fade) = (light->photons * linearScale);
3445                                                 dist * light->fade = (light->photons * linearScale) - T;
3446                                                 dist = ((light->photons * linearScale) - T) / light->fade;
3447                                                 */
3448
3449                                         /* solve for inverse square falloff */
3450                                         else
3451                                                 light->envelope = sqrt( intensity / light->falloffTolerance ) + radius;
3452
3453                                                 /*
3454                                                 add = light->photons / (dist * dist);
3455                                                 T = light->photons / (dist * dist);
3456                                                 T * (dist * dist) = light->photons;
3457                                                 dist = sqrt( light->photons / T );
3458                                                 */
3459                                 }
3460
3461                                 /* chop radius against pvs */
3462                                 {
3463                                         /* clear bounds */
3464                                         ClearBounds( mins, maxs );
3465
3466                                         /* check all leaves */
3467                                         for( i = 0; i < numBSPLeafs; i++ )
3468                                         {
3469                                                 /* get test leaf */
3470                                                 leaf = &bspLeafs[ i ];
3471
3472                                                 /* in pvs? */
3473                                                 if( leaf->cluster < 0 )
3474                                                         continue;
3475                                                 if( ClusterVisible( light->cluster, leaf->cluster ) == qfalse ) /* ydnar: thanks Arnout for exposing my stupid error (this never failed before) */
3476                                                         continue;
3477
3478                                                 /* add this leafs bbox to the bounds */
3479                                                 VectorCopy( leaf->mins, origin );
3480                                                 AddPointToBounds( origin, mins, maxs );
3481                                                 VectorCopy( leaf->maxs, origin );
3482                                                 AddPointToBounds( origin, mins, maxs );
3483                                         }
3484
3485                                         /* test to see if bounds encompass light */
3486                                         for( i = 0; i < 3; i++ )
3487                                         {
3488                                                 if( mins[ i ] > light->origin[ i ] || maxs[ i ] < light->origin[ i ] )
3489                                                 {
3490                                                         //% Sys_Printf( "WARNING: Light PVS bounds (%.0f, %.0f, %.0f) -> (%.0f, %.0f, %.0f)\ndo not encompass light %d (%f, %f, %f)\n",
3491                                                         //%     mins[ 0 ], mins[ 1 ], mins[ 2 ],
3492                                                         //%     maxs[ 0 ], maxs[ 1 ], maxs[ 2 ],
3493                                                         //%     numLights, light->origin[ 0 ], light->origin[ 1 ], light->origin[ 2 ] );
3494                                                         AddPointToBounds( light->origin, mins, maxs );
3495                                                 }
3496                                         }
3497
3498                                         /* chop the bounds by a plane for area lights and spotlights */
3499                                         if( light->type == EMIT_AREA || light->type == EMIT_SPOT )
3500                                                 ChopBounds( mins, maxs, light->origin, light->normal );
3501
3502                                         /* copy bounds */
3503                                         VectorCopy( mins, light->mins );
3504                                         VectorCopy( maxs, light->maxs );
3505
3506                                         /* reflect bounds around light origin */
3507                                         //%     VectorMA( light->origin, -1.0f, origin, origin );
3508                                         VectorScale( light->origin, 2, origin );
3509                                         VectorSubtract( origin, maxs, origin );
3510                                         AddPointToBounds( origin, mins, maxs );
3511                                         //%     VectorMA( light->origin, -1.0f, mins, origin );
3512                                         VectorScale( light->origin, 2, origin );
3513                                         VectorSubtract( origin, mins, origin );
3514                                         AddPointToBounds( origin, mins, maxs );
3515
3516                                         /* calculate spherical bounds */
3517                                         VectorSubtract( maxs, light->origin, dir );
3518                                         radius = (float) VectorLength( dir );
3519
3520                                         /* if this radius is smaller than the envelope, then set the envelope to it */
3521                                         if( radius < light->envelope )
3522                                         {
3523                                                 light->envelope = radius;
3524                                                 //%     Sys_FPrintf( SYS_VRB, "PVS Cull (%d): culled\n", numLights );
3525                                         }
3526                                         //%     else
3527                                         //%             Sys_FPrintf( SYS_VRB, "PVS Cull (%d): failed (%8.0f > %8.0f)\n", numLights, radius, light->envelope );
3528                                 }
3529
3530                                 /* add grid/surface only check */
3531                                 if( forGrid )
3532                                 {
3533                                         if( !(light->flags & LIGHT_GRID) )
3534                                                 light->envelope = 0.0f;
3535                                 }
3536                                 else
3537                                 {
3538                                         if( !(light->flags & LIGHT_SURFACES) )
3539                                                 light->envelope = 0.0f;
3540                                 }
3541                         }
3542
3543                         /* culled? */
3544                         if( light->cluster < 0 || light->envelope <= 0.0f )
3545                         {
3546                                 /* debug code */
3547                                 //%     Sys_Printf( "Culling light: Cluster: %d Envelope: %f\n", light->cluster, light->envelope );
3548
3549                                 /* delete the light */
3550                                 numCulledLights++;
3551                                 *owner = light->next;
3552                                 if( light->w != NULL )
3553                                         free( light->w );
3554                                 free( light );
3555                                 continue;
3556                         }
3557                 }
3558
3559                 /* square envelope */
3560                 light->envelope2 = (light->envelope * light->envelope);
3561
3562                 /* increment light count */
3563                 numLights++;
3564
3565                 /* set next light */
3566                 owner = &((**owner).next);
3567         }
3568
3569         /* bucket sort lights by style */
3570         memset( buckets, 0, sizeof( buckets ) );
3571         light2 = NULL;
3572         for( light = lights; light != NULL; light = light2 )
3573         {
3574                 /* get next light */
3575                 light2 = light->next;
3576
3577                 /* filter into correct bucket */
3578                 light->next = buckets[ light->style ];
3579                 buckets[ light->style ] = light;
3580
3581                 /* if any styled light is present, automatically set nocollapse */
3582                 if( light->style != LS_NORMAL )
3583                         noCollapse = qtrue;
3584         }
3585
3586         /* filter back into light list */
3587         lights = NULL;
3588         for( i = 255; i >= 0; i-- )
3589         {
3590                 light2 = NULL;
3591                 for( light = buckets[ i ]; light != NULL; light = light2 )
3592                 {
3593                         light2 = light->next;
3594                         light->next = lights;
3595                         lights = light;
3596                 }
3597         }
3598
3599         /* emit some statistics */
3600         Sys_Printf( "%9d total lights\n", numLights );
3601         Sys_Printf( "%9d culled lights\n", numCulledLights );
3602 }
3603
3604
3605
3606 /*
3607 CreateTraceLightsForBounds()
3608 creates a list of lights that affect the given bounding box and pvs clusters (bsp leaves)
3609 */
3610
3611 void CreateTraceLightsForBounds( vec3_t mins, vec3_t maxs, vec3_t normal, int numClusters, int *clusters, int flags, trace_t *trace )
3612 {
3613         int                     i;
3614         light_t         *light;
3615         vec3_t          origin, dir, nullVector = { 0.0f, 0.0f, 0.0f };
3616         float           radius, dist, length;
3617
3618
3619         /* potential pre-setup  */
3620         if( numLights == 0 )
3621                 SetupEnvelopes( qfalse, fast );
3622
3623         /* debug code */
3624         //% Sys_Printf( "CTWLFB: (%4.1f %4.1f %4.1f) (%4.1f %4.1f %4.1f)\n", mins[ 0 ], mins[ 1 ], mins[ 2 ], maxs[ 0 ], maxs[ 1 ], maxs[ 2 ] );
3625
3626         /* allocate the light list */
3627         trace->lights = safe_malloc( sizeof( light_t* ) * (numLights + 1) );
3628         trace->numLights = 0;
3629
3630         /* calculate spherical bounds */
3631         VectorAdd( mins, maxs, origin );
3632         VectorScale( origin, 0.5f, origin );
3633         VectorSubtract( maxs, origin, dir );
3634         radius = (float) VectorLength( dir );
3635
3636         /* get length of normal vector */
3637         if( normal != NULL )
3638                 length = VectorLength( normal );
3639         else
3640         {
3641                 normal = nullVector;
3642                 length = 0;
3643         }
3644
3645         /* test each light and see if it reaches the sphere */
3646         /* note: the attenuation code MUST match LightingAtSample() */
3647         for( light = lights; light; light = light->next )
3648         {
3649                 /* check zero sized envelope */
3650                 if( light->envelope <= 0 )
3651                 {
3652                         lightsEnvelopeCulled++;
3653                         continue;
3654                 }
3655
3656                 /* check flags */
3657                 if( !(light->flags & flags) )
3658                         continue;
3659
3660                 /* sunlight skips all this nonsense */
3661                 if( light->type != EMIT_SUN )
3662                 {
3663                         /* sun only? */
3664                         if( sunOnly )
3665                                 continue;
3666
3667                         /* check against pvs cluster */
3668                         if( numClusters > 0 && clusters != NULL )
3669                         {
3670                                 for( i = 0; i < numClusters; i++ )
3671                                 {
3672                                         if( ClusterVisible( light->cluster, clusters[ i ] ) )
3673                                                 break;
3674                                 }
3675
3676                                 /* fixme! */
3677                                 if( i == numClusters )
3678                                 {
3679                                         lightsClusterCulled++;
3680                                         continue;
3681                                 }
3682                         }
3683
3684                         /* if the light's bounding sphere intersects with the bounding sphere then this light needs to be tested */
3685                         VectorSubtract( light->origin, origin, dir );
3686                         dist = VectorLength( dir );
3687                         dist -= light->envelope;
3688                         dist -= radius;
3689                         if( dist > 0 )
3690                         {
3691                                 lightsEnvelopeCulled++;
3692                                 continue;
3693                         }
3694
3695                         /* check bounding box against light's pvs envelope (note: this code never eliminated any lights, so disabling it) */
3696                         #if 0
3697                         skip = qfalse;
3698                         for( i = 0; i < 3; i++ )
3699                         {
3700                                 if( mins[ i ] > light->maxs[ i ] || maxs[ i ] < light->mins[ i ] )
3701                                         skip = qtrue;
3702                         }
3703                         if( skip )
3704                         {
3705                                 lightsBoundsCulled++;
3706                                 continue;
3707                         }
3708                         #endif
3709                 }
3710
3711                 /* planar surfaces (except twosided surfaces) have a couple more checks */
3712                 if( length > 0.0f && trace->twoSided == qfalse )
3713                 {
3714                         /* lights coplanar with a surface won't light it */
3715                         if( !(light->flags & LIGHT_TWOSIDED) && DotProduct( light->normal, normal ) > 0.999f )
3716                         {
3717                                 lightsPlaneCulled++;
3718                                 continue;
3719                         }
3720
3721                         /* check to see if light is behind the plane */
3722                         if( DotProduct( light->origin, normal ) - DotProduct( origin, normal ) < -1.0f )
3723                         {
3724                                 lightsPlaneCulled++;
3725                                 continue;
3726                         }
3727                 }
3728
3729                 /* add this light */
3730                 trace->lights[ trace->numLights++ ] = light;
3731         }
3732
3733         /* make last night null */
3734         trace->lights[ trace->numLights ] = NULL;
3735 }
3736
3737
3738
3739 void FreeTraceLights( trace_t *trace )
3740 {
3741         if( trace->lights != NULL )
3742                 free( trace->lights );
3743 }
3744
3745
3746
3747 /*
3748 CreateTraceLightsForSurface()
3749 creates a list of lights that can potentially affect a drawsurface
3750 */
3751
3752 void CreateTraceLightsForSurface( int num, trace_t *trace )
3753 {
3754         int                                     i;
3755         vec3_t                          mins, maxs, normal;
3756         bspDrawVert_t           *dv;
3757         bspDrawSurface_t        *ds;
3758         surfaceInfo_t           *info;
3759
3760
3761         /* dummy check */
3762         if( num < 0 )
3763                 return;
3764
3765         /* get drawsurface and info */
3766         ds = &bspDrawSurfaces[ num ];
3767         info = &surfaceInfos[ num ];
3768
3769         /* get the mins/maxs for the dsurf */
3770         ClearBounds( mins, maxs );
3771         VectorCopy( bspDrawVerts[ ds->firstVert ].normal, normal );
3772         for( i = 0; i < ds->numVerts; i++ )
3773         {
3774                 dv = &yDrawVerts[ ds->firstVert + i ];
3775                 AddPointToBounds( dv->xyz, mins, maxs );
3776                 if( !VectorCompare( dv->normal, normal ) )
3777                         VectorClear( normal );
3778         }
3779
3780         /* create the lights for the bounding box */
3781         CreateTraceLightsForBounds( mins, maxs, normal, info->numSurfaceClusters, &surfaceClusters[ info->firstSurfaceCluster ], LIGHT_SURFACES, trace );
3782 }
3783
3784 /////////////////////////////////////////////////////////////
3785
3786 #define FLOODLIGHT_CONE_ANGLE                   88      /* degrees */
3787 #define FLOODLIGHT_NUM_ANGLE_STEPS              16
3788 #define FLOODLIGHT_NUM_ELEVATION_STEPS  4
3789 #define FLOODLIGHT_NUM_VECTORS                  (FLOODLIGHT_NUM_ANGLE_STEPS * FLOODLIGHT_NUM_ELEVATION_STEPS)
3790
3791 static vec3_t   floodVectors[ FLOODLIGHT_NUM_VECTORS ];
3792 static int              numFloodVectors = 0;
3793
3794 void SetupFloodLight( void )
3795 {
3796         int             i, j;
3797         float   angle, elevation, angleStep, elevationStep;
3798         const char      *value;
3799         double v1,v2,v3,v4,v5;
3800
3801         /* note it */
3802         Sys_FPrintf( SYS_VRB, "--- SetupFloodLight ---\n" );
3803
3804         /* calculate angular steps */
3805         angleStep = DEG2RAD( 360.0f / FLOODLIGHT_NUM_ANGLE_STEPS );
3806         elevationStep = DEG2RAD( FLOODLIGHT_CONE_ANGLE / FLOODLIGHT_NUM_ELEVATION_STEPS );
3807
3808         /* iterate angle */
3809         angle = 0.0f;
3810         for( i = 0, angle = 0.0f; i < FLOODLIGHT_NUM_ANGLE_STEPS; i++, angle += angleStep )
3811         {
3812                 /* iterate elevation */
3813                 for( j = 0, elevation = elevationStep * 0.5f; j < FLOODLIGHT_NUM_ELEVATION_STEPS; j++, elevation += elevationStep )
3814                 {
3815                         floodVectors[ numFloodVectors ][ 0 ] = sin( elevation ) * cos( angle );
3816                         floodVectors[ numFloodVectors ][ 1 ] = sin( elevation ) * sin( angle );
3817                         floodVectors[ numFloodVectors ][ 2 ] = cos( elevation );
3818                         numFloodVectors++;
3819                 }
3820         }
3821
3822         /* emit some statistics */
3823         Sys_FPrintf( SYS_VRB, "%9d numFloodVectors\n", numFloodVectors );
3824
3825       /* floodlight */
3826         value = ValueForKey( &entities[ 0 ], "_floodlight" );
3827
3828         if( value[ 0 ] != '\0' )
3829         {
3830                 v1=v2=v3=0;
3831                 v4=floodlightDistance;
3832                 v5=floodlightIntensity;
3833
3834                 sscanf( value, "%lf %lf %lf %lf %lf", &v1, &v2, &v3, &v4, &v5);
3835
3836                 floodlightRGB[0]=v1;
3837                 floodlightRGB[1]=v2;
3838                 floodlightRGB[2]=v3;
3839
3840                 if (VectorLength(floodlightRGB)==0)
3841                 {
3842                         VectorSet(floodlightRGB,240,240,255);
3843                 }
3844
3845                 if (v4<1) v4=1024;
3846                 if (v5<1) v5=128;
3847
3848                 floodlightDistance=v4;
3849                 floodlightIntensity=v5;
3850
3851                 floodlighty = qtrue;
3852                 Sys_Printf( "FloodLighting enabled via worldspawn _floodlight key.\n" );
3853         }
3854         else
3855         {
3856                 VectorSet(floodlightRGB,240,240,255);
3857                 //floodlighty = qtrue;
3858                 //Sys_Printf( "FloodLighting enabled via worldspawn _floodlight key.\n" );
3859         }
3860         VectorNormalize(floodlightRGB,floodlightRGB);
3861 }
3862
3863 /*
3864 FloodLightForSample()
3865 calculates floodlight value for a given sample
3866 once again, kudos to the dirtmapping coder
3867 */
3868
3869 float FloodLightForSample( trace_t *trace , float floodLightDistance, qboolean floodLightLowQuality)
3870 {
3871         int             i;
3872         float   d;
3873         float   contribution;
3874         int     sub = 0;
3875         float   gatherLight, outLight;
3876         vec3_t  normal, worldUp, myUp, myRt, direction, displacement;
3877         float   dd;
3878         int     vecs = 0;
3879
3880         gatherLight=0;
3881         /* dummy check */
3882         //if( !dirty )
3883         //      return 1.0f;
3884         if( trace == NULL || trace->cluster < 0 )
3885                 return 0.0f;
3886
3887
3888         /* setup */
3889         dd = floodLightDistance;
3890         VectorCopy( trace->normal, normal );
3891
3892         /* check if the normal is aligned to the world-up */
3893         if( normal[ 0 ] == 0.0f && normal[ 1 ] == 0.0f )
3894         {
3895                 if( normal[ 2 ] == 1.0f )
3896                 {
3897                         VectorSet( myRt, 1.0f, 0.0f, 0.0f );
3898                         VectorSet( myUp, 0.0f, 1.0f, 0.0f );
3899                 }
3900                 else if( normal[ 2 ] == -1.0f )
3901                 {
3902                         VectorSet( myRt, -1.0f, 0.0f, 0.0f );
3903                         VectorSet( myUp,  0.0f, 1.0f, 0.0f );
3904                 }
3905         }
3906         else
3907         {
3908                 VectorSet( worldUp, 0.0f, 0.0f, 1.0f );
3909                 CrossProduct( normal, worldUp, myRt );
3910                 VectorNormalize( myRt, myRt );
3911                 CrossProduct( myRt, normal, myUp );
3912                 VectorNormalize( myUp, myUp );
3913         }
3914
3915         /* vortex: optimise floodLightLowQuality a bit */
3916         if ( floodLightLowQuality == qtrue )
3917     {
3918                 /* iterate through ordered vectors */
3919                 for( i = 0; i < numFloodVectors; i++ )
3920                         if (rand()%10 != 0 ) continue;
3921         }
3922         else
3923         {
3924                 /* iterate through ordered vectors */
3925                 for( i = 0; i < numFloodVectors; i++ )
3926                 {
3927                         vecs++;
3928
3929                         /* transform vector into tangent space */
3930                         direction[ 0 ] = myRt[ 0 ] * floodVectors[ i ][ 0 ] + myUp[ 0 ] * floodVectors[ i ][ 1 ] + normal[ 0 ] * floodVectors[ i ][ 2 ];
3931                         direction[ 1 ] = myRt[ 1 ] * floodVectors[ i ][ 0 ] + myUp[ 1 ] * floodVectors[ i ][ 1 ] + normal[ 1 ] * floodVectors[ i ][ 2 ];
3932                         direction[ 2 ] = myRt[ 2 ] * floodVectors[ i ][ 0 ] + myUp[ 2 ] * floodVectors[ i ][ 1 ] + normal[ 2 ] * floodVectors[ i ][ 2 ];
3933
3934                         /* set endpoint */
3935                         VectorMA( trace->origin, dd, direction, trace->end );
3936
3937                         //VectorMA( trace->origin, 1, direction, trace->origin );
3938
3939                         SetupTrace( trace );
3940                         /* trace */
3941                         TraceLine( trace );
3942                         contribution=1;
3943
3944                         if (trace->compileFlags & C_SKY )
3945                         {
3946                                 contribution=1.0f;
3947                         }
3948                         else if ( trace->opaque )
3949                         {
3950                                 VectorSubtract( trace->hit, trace->origin, displacement );
3951                                 d=VectorLength( displacement );
3952
3953                                 // d=trace->distance;
3954                                 //if (d>256) gatherDirt+=1;
3955                                 contribution=d/dd;
3956                                 if (contribution>1) contribution=1.0f;
3957
3958                                 //gatherDirt += 1.0f - ooDepth * VectorLength( displacement );
3959                         }
3960
3961                         gatherLight+=contribution;
3962                 }
3963         }
3964
3965         /* early out */
3966         if( gatherLight <= 0.0f )
3967                 return 0.0f;
3968
3969         sub=vecs;
3970
3971         if (sub<1) sub=1;
3972         gatherLight/=(sub);
3973
3974         outLight=gatherLight;
3975         if( outLight > 1.0f )
3976                 outLight = 1.0f;
3977
3978         /* return to sender */
3979         return outLight;
3980 }
3981
3982 /*
3983 FloodLightRawLightmap
3984 lighttracer style ambient occlusion light hack.
3985 Kudos to the dirtmapping author for most of this source.
3986 VorteX: modified to floodlight up custom surfaces (q3map_floodLight)
3987 VorteX: fixed problems with deluxemapping
3988 */
3989
3990 // floodlight pass on a lightmap
3991 void FloodLightRawLightmapPass( rawLightmap_t *lm , vec3_t lmFloodLightRGB, float lmFloodLightIntensity, float lmFloodLightDistance, qboolean lmFloodLightLowQuality, float floodlightDirectionScale)
3992 {
3993         int                                     i, x, y, *cluster;
3994         float                           *origin, *normal, *floodlight, floodLightAmount;
3995         surfaceInfo_t           *info;
3996         trace_t                         trace;
3997         // int sx, sy;
3998         // float samples, average, *floodlight2;
3999
4000         memset(&trace,0,sizeof(trace_t));
4001
4002         /* setup trace */
4003         trace.testOcclusion = qtrue;
4004         trace.forceSunlight = qfalse;
4005         trace.twoSided = qtrue;
4006         trace.recvShadows = lm->recvShadows;
4007         trace.numSurfaces = lm->numLightSurfaces;
4008         trace.surfaces = &lightSurfaces[ lm->firstLightSurface ];
4009         trace.inhibitRadius = DEFAULT_INHIBIT_RADIUS;
4010         trace.testAll = qfalse;
4011         trace.distance = 1024;
4012
4013         /* twosided lighting (may or may not be a good idea for lightmapped stuff) */
4014         //trace.twoSided = qfalse;
4015         for( i = 0; i < trace.numSurfaces; i++ )
4016         {
4017                 /* get surface */
4018                 info = &surfaceInfos[ trace.surfaces[ i ] ];
4019
4020                 /* check twosidedness */
4021                 if( info->si->twoSided )
4022                 {
4023                         trace.twoSided = qtrue;
4024                         break;
4025                 }
4026         }
4027
4028         /* gather floodlight */
4029         for( y = 0; y < lm->sh; y++ )
4030         {
4031                 for( x = 0; x < lm->sw; x++ )
4032                 {
4033                         /* get luxel */
4034                         cluster = SUPER_CLUSTER( x, y );
4035                         origin = SUPER_ORIGIN( x, y );
4036                         normal = SUPER_NORMAL( x, y );
4037                         floodlight = SUPER_FLOODLIGHT( x, y );
4038
4039                         /* set default dirt */
4040                         *floodlight = 0.0f;
4041
4042                         /* only look at mapped luxels */
4043                         if( *cluster < 0 )
4044                                 continue;
4045
4046                         /* copy to trace */
4047                         trace.cluster = *cluster;
4048                         VectorCopy( origin, trace.origin );
4049                         VectorCopy( normal, trace.normal );
4050
4051                         /* get floodlight */
4052                         floodLightAmount = FloodLightForSample( &trace , lmFloodLightDistance, lmFloodLightLowQuality)*lmFloodLightIntensity;
4053
4054                         /* add floodlight */
4055                         floodlight[0] += lmFloodLightRGB[0]*floodLightAmount;
4056                         floodlight[1] += lmFloodLightRGB[1]*floodLightAmount;
4057                         floodlight[2] += lmFloodLightRGB[2]*floodLightAmount;
4058                         floodlight[3] += floodlightDirectionScale;
4059                 }
4060         }
4061
4062         /* testing no filtering */
4063         return;
4064
4065 #if 0
4066
4067         /* filter "dirt" */
4068         for( y = 0; y < lm->sh; y++ )
4069         {
4070                 for( x = 0; x < lm->sw; x++ )
4071                 {
4072                         /* get luxel */
4073                         cluster = SUPER_CLUSTER( x, y );
4074                         floodlight = SUPER_FLOODLIGHT(x, y );
4075
4076                         /* filter dirt by adjacency to unmapped luxels */
4077                         average = *floodlight;
4078                         samples = 1.0f;
4079                         for( sy = (y - 1); sy <= (y + 1); sy++ )
4080                         {
4081                                 if( sy < 0 || sy >= lm->sh )
4082                                         continue;
4083
4084                                 for( sx = (x - 1); sx <= (x + 1); sx++ )
4085                                 {
4086                                         if( sx < 0 || sx >= lm->sw || (sx == x && sy == y) )
4087                                                 continue;
4088
4089                                         /* get neighboring luxel */
4090                                         cluster = SUPER_CLUSTER( sx, sy );
4091                                         floodlight2 = SUPER_FLOODLIGHT( sx, sy );
4092                                         if( *cluster < 0 || *floodlight2 <= 0.0f )
4093                                                 continue;
4094
4095                                         /* add it */
4096                                         average += *floodlight2;
4097                                         samples += 1.0f;
4098                                 }
4099
4100                                 /* bail */
4101                                 if( samples <= 0.0f )
4102                                         break;
4103                         }
4104
4105                         /* bail */
4106                         if( samples <= 0.0f )
4107                                 continue;
4108
4109                         /* scale dirt */
4110                         *floodlight = average / samples;
4111                 }
4112         }
4113 #endif
4114 }
4115
4116 void FloodLightRawLightmap( int rawLightmapNum )
4117 {
4118         rawLightmap_t           *lm;
4119
4120         /* bail if this number exceeds the number of raw lightmaps */
4121         if( rawLightmapNum >= numRawLightmaps )
4122                 return;
4123         /* get lightmap */
4124         lm = &rawLightmaps[ rawLightmapNum ];
4125
4126         /* global pass */
4127         if (floodlighty && floodlightIntensity)
4128                 FloodLightRawLightmapPass(lm, floodlightRGB, floodlightIntensity, floodlightDistance, floodlight_lowquality, 0);
4129
4130         /* custom pass */
4131         if (lm->floodlightIntensity)
4132         {
4133                 FloodLightRawLightmapPass(lm, lm->floodlightRGB, lm->floodlightIntensity, lm->floodlightDistance, qfalse, lm->floodlightDirectionScale);
4134                 numSurfacesFloodlighten += 1;
4135         }
4136 }
4137
4138 void FloodlightRawLightmaps()
4139 {
4140         Sys_Printf( "--- FloodlightRawLightmap ---\n" );
4141         numSurfacesFloodlighten = 0;
4142         RunThreadsOnIndividual( numRawLightmaps, qtrue, FloodLightRawLightmap );
4143         Sys_Printf( "%9d custom lightmaps floodlighted\n", numSurfacesFloodlighten );
4144 }
4145
4146 /*
4147 FloodLightIlluminate()
4148 illuminate floodlight into lightmap luxels
4149 */
4150
4151 void FloodlightIlluminateLightmap( rawLightmap_t *lm )
4152 {
4153         float                           *luxel, *floodlight, *deluxel, *normal;
4154         int                                     *cluster;
4155         float                           brightness;
4156         vec3_t                          lightvector;
4157         int                                     x, y, lightmapNum;
4158
4159         /* walk lightmaps */
4160         for( lightmapNum = 0; lightmapNum < MAX_LIGHTMAPS; lightmapNum++ )
4161         {
4162                 /* early out */
4163                 if( lm->superLuxels[ lightmapNum ] == NULL )
4164                         continue;
4165
4166                 /* apply floodlight to each luxel */
4167                 for( y = 0; y < lm->sh; y++ )
4168                 {
4169                         for( x = 0; x < lm->sw; x++ )
4170                         {
4171                                 /* get floodlight */
4172                                 floodlight = SUPER_FLOODLIGHT( x, y );
4173                                 if (!floodlight[0] && !floodlight[1] && !floodlight[2])
4174                                         continue;
4175
4176                                 /* get cluster */
4177                                 cluster = SUPER_CLUSTER( x, y );
4178
4179                                 /* only process mapped luxels */
4180                                 if( *cluster < 0 )
4181                                         continue;
4182
4183                                 /* get particulars */
4184                                 luxel = SUPER_LUXEL( lightmapNum, x, y );
4185                                 deluxel = SUPER_DELUXEL( x, y );
4186
4187                                 /* add to lightmap */
4188                                 luxel[0]+=floodlight[0];
4189                                 luxel[1]+=floodlight[1];
4190                                 luxel[2]+=floodlight[2];
4191
4192                                 if (luxel[3]==0) luxel[3]=1;
4193
4194                                 /* add to deluxemap */
4195                                 if (deluxemap && floodlight[3] > 0)
4196                                 {
4197                                         normal = SUPER_NORMAL( x, y );
4198                                         brightness = floodlight[ 0 ] * 0.3f + floodlight[ 1 ] * 0.59f + floodlight[ 2 ] * 0.11f;
4199                                         brightness *= ( 1.0f / 255.0f ) * floodlight[3];
4200                                         VectorScale( normal, brightness, lightvector );
4201                                         VectorAdd( deluxel, lightvector, deluxel );
4202                                 }
4203                         }
4204                 }
4205         }
4206 }