if ( scale <= 0.0f ) {
scale = 1.0f;
}
+ /* globally */
+ scale *= lightmapBrightness;
/* make a local copy */
VectorScale( color, scale, sample );
/* compensate for ingame overbrighting/bitshifting */
VectorScale( sample, ( 1.0f / lightmapCompensate ), sample );
+ /* contrast */
+ if ( lightmapContrast != 1.0f ){
+ for ( i = 0; i < 3; i++ ){
+ sample[i] = lightmapContrast * ( sample[i] - 128 ) + 128;
+ if ( sample[i] < 0 ){
+ sample[i] = 0;
+ }
+ }
+ if ( ( sample[0] > 255 ) || ( sample[1] > 255 ) || ( sample[2] > 255 ) ) {
+ max = sample[0] > sample[1] ? sample[0] : sample[1];
+ max = max > sample[2] ? max : sample[2];
+ sample[0] = sample[0] * 255 / max;
+ sample[1] = sample[1] * 255 / max;
+ sample[2] = sample[2] * 255 / max;
+ }
+ }
+
/* sRGB lightmaps */
if ( lightmapsRGB ) {
sample[0] = floor( Image_sRGBFloatFromLinearFloat( sample[0] * ( 1.0 / 255.0 ) ) * 255.0 + 0.5 );
colorBytes[ 2 ] = sample[ 2 ];
}
+/*
+ * Same as ColorToBytes, but if the output color will never contain zero
+ * components. Used to avoid returning 0 0 0 due to an ioq3 issue. Reason
+ * to also map 0 0 1 to 1 1 1 is to ensure monotonicity in the color mapping
+ * to prevent banding-like artifacts on lightmaps.
+ */
+void ColorToBytesNonZero( const float *color, byte *colorBytes, float scale) {
+ int i;
+ ColorToBytes(color, colorBytes, scale);
+ for (i = 0; i < 3; ++i)
+ if (colorBytes[i] == 0)
+ colorBytes[i] = 1;
+}
/* -------------------------------------------------------------------------------
/* allocate shade angle table */
- shadeAngles = safe_malloc( numBSPDrawVerts * sizeof( float ) );
- memset( shadeAngles, 0, numBSPDrawVerts * sizeof( float ) );
+ shadeAngles = safe_malloc0( numBSPDrawVerts * sizeof( float ) );
/* allocate smoothed table */
cs = ( numBSPDrawVerts / 8 ) + 1;
- smoothed = safe_malloc( cs );
- memset( smoothed, 0, cs );
+ smoothed = safe_malloc0( cs );
/* set default shade angle */
defaultShadeAngle = DEG2RAD( shadeAngleDegrees );
origin2 = SUPER_ORIGIN( x, y );
//% normal2 = SUPER_NORMAL( x, y );
}
- else
- {
- Error( "Spurious lightmap S vector\n" );
+ else {
+ Sys_FPrintf( SYS_WRN, "WARNING: Spurious lightmap S vector\n" );
}
VectorSubtract( origin2, origin, originVecs[ 0 ] );
//% normal2 = SUPER_NORMAL( x, y );
}
else{
- Sys_Printf( "WARNING: Spurious lightmap T vector\n" );
+ Sys_FPrintf( SYS_WRN, "WARNING: Spurious lightmap T vector\n" );
}
VectorSubtract( origin2, origin, originVecs[ 1 ] );
- //% VectorSubtract( normal2, normal, normalVecs[ 1 ] );
/* calculate new origin */
- //% VectorMA( origin, bx, originVecs[ 0 ], sampleOrigin );
- //% VectorMA( sampleOrigin, by, originVecs[ 1 ], sampleOrigin );
for ( i = 0; i < 3; i++ )
sampleOrigin[ i ] = sampleOrigin[ i ] + ( bx * originVecs[ 0 ][ i ] ) + ( by * originVecs[ 1 ][ i ] );
}
/* calculate new normal */
- //% VectorMA( normal, bx, normalVecs[ 0 ], sampleNormal );
- //% VectorMA( sampleNormal, by, normalVecs[ 1 ], sampleNormal );
- //% if( VectorNormalize( sampleNormal, sampleNormal ) <= 0.0f )
- //% return qfalse;
normal = SUPER_NORMAL( x, y );
VectorCopy( normal, sampleNormal );
/* max of MAX_LIGHTMAPS (4) styles allowed to hit a surface/lightmap */
if ( lightmapNum >= MAX_LIGHTMAPS ) {
- Sys_Printf( "WARNING: Hit per-surface style limit (%d)\n", MAX_LIGHTMAPS );
+ Sys_FPrintf( SYS_WRN, "WARNING: Hit per-surface style limit (%d)\n", MAX_LIGHTMAPS );
continue;
}
}
/* allocate sampling flags storage */
- if ( ( lightSamples > 1 || lightRandomSamples ) && luxelFilterRadius == 0 ) {
+ if ( lightSamples > 1 || lightRandomSamples ) {
size = lm->sw * lm->sh * SUPER_LUXEL_SIZE * sizeof( unsigned char );
if ( lm->superFlags == NULL ) {
lm->superFlags = safe_malloc( size );
normal = SUPER_NORMAL( x, y );
flag = SUPER_FLAG( x, y );
-#if 0
- ////////// 27's temp hack for testing edge clipping ////
- if ( origin[0] == 0 && origin[1] == 0 && origin[2] == 0 ) {
- lightLuxel[ 1 ] = 255;
- lightLuxel[ 3 ] = 1.0f;
- totalLighted++;
- }
- else
-#endif
- {
- /* set contribution count */
- lightLuxel[ 3 ] = 1.0f;
+ /* set contribution count */
+ lightLuxel[ 3 ] = 1.0f;
- /* setup trace */
- trace.cluster = *cluster;
- VectorCopy( origin, trace.origin );
- VectorCopy( normal, trace.normal );
+ /* setup trace */
+ trace.cluster = *cluster;
+ VectorCopy( origin, trace.origin );
+ VectorCopy( normal, trace.normal );
- /* get light for this sample */
- LightContributionToSample( &trace );
- VectorCopy( trace.color, lightLuxel );
+ /* get light for this sample */
+ LightContributionToSample( &trace );
+ VectorCopy( trace.color, lightLuxel );
- /* add the contribution to the deluxemap */
- if ( deluxemap ) {
- VectorCopy( trace.directionContribution, lightDeluxel );
- }
+ /* add the contribution to the deluxemap */
+ if ( deluxemap ) {
+ VectorCopy( trace.directionContribution, lightDeluxel );
+ }
- /* check for evilness */
- if ( trace.forceSubsampling > 1.0f && ( lightSamples > 1 || lightRandomSamples ) && luxelFilterRadius == 0 ) {
- totalLighted++;
- *flag |= FLAG_FORCE_SUBSAMPLING; /* force */
- }
- /* add to count */
- else if ( trace.color[ 0 ] || trace.color[ 1 ] || trace.color[ 2 ] ) {
- totalLighted++;
- }
+ /* check for evilness */
+ if ( trace.forceSubsampling > 1.0f && ( lightSamples > 1 || lightRandomSamples ) ) {
+ totalLighted++;
+ *flag |= FLAG_FORCE_SUBSAMPLING; /* force */
+ }
+ /* add to count */
+ else if ( trace.color[ 0 ] || trace.color[ 1 ] || trace.color[ 2 ] ) {
+ totalLighted++;
}
}
}
/* secondary pass, adaptive supersampling (fixme: use a contrast function to determine if subsampling is necessary) */
/* 2003-09-27: changed it so filtering disamples supersampling, as it would waste time */
- if ( ( lightSamples > 1 || lightRandomSamples ) && luxelFilterRadius == 0 ) {
+ if ( lightSamples > 1 || lightRandomSamples ) {
/* walk luxels */
for ( y = 0; y < ( lm->sh - 1 ); y++ )
{
if ( lm->superLuxels[ lightmapNum ] == NULL ) {
/* allocate sampling lightmap storage */
size = lm->sw * lm->sh * SUPER_LUXEL_SIZE * sizeof( float );
- lm->superLuxels[ lightmapNum ] = safe_malloc( size );
- memset( lm->superLuxels[ lightmapNum ], 0, size );
+ lm->superLuxels[ lightmapNum ] = safe_malloc0( size );
}
/* set style */
{
/* get cluster */
cluster = SUPER_CLUSTER( x, y );
- //% if( *cluster < 0 ) // TODO why not do this check? These pixels should be zero anyway
- //% continue;
/* get particulars */
luxel = SUPER_LUXEL( lightmapNum, x, y );
}
}
}
-
-
-#if 0
- // audit pass
- for ( lightmapNum = 0; lightmapNum < MAX_LIGHTMAPS; lightmapNum++ )
- {
- /* early out */
- if ( lm->superLuxels[ lightmapNum ] == NULL ) {
- continue;
- }
- for ( y = 0; y < lm->sh; y++ )
- for ( x = 0; x < lm->sw; x++ )
- {
- /* get cluster */
- cluster = SUPER_CLUSTER( x, y );
- luxel = SUPER_LUXEL( lightmapNum, x, y );
- deluxel = SUPER_DELUXEL( x, y );
- if ( !luxel || !deluxel || !cluster ) {
- Sys_FPrintf( SYS_VRB, "WARNING: I got NULL'd.\n" );
- continue;
- }
- else if ( *cluster < 0 ) {
- // unmapped pixel
- // should have neither deluxemap nor lightmap
- if ( deluxel[3] ) {
- Sys_FPrintf( SYS_VRB, "WARNING: I have written deluxe to an unmapped luxel. Sorry.\n" );
- }
- }
- else
- {
- // mapped pixel
- // should have both deluxemap and lightmap
- if ( deluxel[3] ) {
- Sys_FPrintf( SYS_VRB, "WARNING: I forgot to write deluxe to a mapped luxel. Sorry.\n" );
- }
- }
- }
- }
-#endif
}
int i, x, y, z, x1, y1, z1, sx, sy, radius, maxRadius, *cluster;
int lightmapNum, numAvg;
float samples, *vertLuxel, *radVertLuxel, *luxel, dirt;
- vec3_t origin, temp, temp2, colors[ MAX_LIGHTMAPS ], avgColors[ MAX_LIGHTMAPS ];
+ vec3_t temp, temp2, colors[ MAX_LIGHTMAPS ], avgColors[ MAX_LIGHTMAPS ];
bspDrawSurface_t *ds;
surfaceInfo_t *info;
rawLightmap_t *lm;
else if ( debugOrigin ) {
VectorSubtract( info->maxs, info->mins, temp );
VectorScale( temp, ( 1.0f / 255.0f ), temp );
- VectorSubtract( origin, lm->mins, temp2 );
+ VectorSubtract( verts[ i ].xyz, info->mins, temp2 );
radVertLuxel[ 0 ] = info->mins[ 0 ] + ( temp[ 0 ] * temp2[ 0 ] );
radVertLuxel[ 1 ] = info->mins[ 1 ] + ( temp[ 1 ] * temp2[ 1 ] );
radVertLuxel[ 2 ] = info->mins[ 2 ] + ( temp[ 2 ] * temp2[ 2 ] );
radVertLuxel[ 2 ] = ( verts[ i ].normal[ 2 ] + 1.0f ) * 127.5f;
}
+ else if ( info->si->noVertexLight ) {
+ VectorSet( radVertLuxel, 127.5f, 127.5f, 127.5f );
+ }
+
+ else if ( noVertexLighting > 0 ) {
+ VectorSet( radVertLuxel, 127.5f * noVertexLighting, 127.5f * noVertexLighting, 127.5f * noVertexLighting );
+ }
+
/* illuminate the vertex */
else
{
trace.origin[ 2 ] = verts[ i ].xyz[ 2 ] + ( VERTEX_NUDGE * z1 );
/* try at nudged origin */
- trace.cluster = ClusterForPointExtFilter( origin, VERTEX_EPSILON, info->numSurfaceClusters, &surfaceClusters[ info->firstSurfaceCluster ] );
+ trace.cluster = ClusterForPointExtFilter( trace.origin, VERTEX_EPSILON, info->numSurfaceClusters, &surfaceClusters[ info->firstSurfaceCluster ] );
if ( trace.cluster < 0 ) {
continue;
}
VectorCopy( debugColors[ num % 12 ], radVertLuxel );
}
+ else if ( info->si->noVertexLight ) {
+ VectorSet( radVertLuxel, 127.5f, 127.5f, 127.5f );
+ }
+
+ else if ( noVertexLighting > 0 ) {
+ VectorSet( radVertLuxel, 127.5f * noVertexLighting, 127.5f * noVertexLighting, 127.5f * noVertexLighting );
+ }
+
/* divine color from the superluxels */
else
{
determines opaque brushes in the world and find sky shaders for sunlight calculations
*/
-void SetupBrushesFlags( int mask_any, int test_any, int mask_all, int test_all ){
+void SetupBrushesFlags( unsigned int mask_any, unsigned int test_any, unsigned int mask_all, unsigned int test_all ){
int i, j, b;
unsigned int compileFlags, allCompileFlags;
qboolean inside;
else{
light->flags &= ~LIGHT_FAST_TEMP;
}
- if ( fastpoint && ( light->flags != EMIT_AREA ) ) {
+ if ( fastpoint && ( light->type != EMIT_AREA ) ) {
light->flags |= LIGHT_FAST_TEMP;
}
if ( light->si && light->si->noFast ) {
for ( i = 0; i < 3; i++ )
{
if ( mins[ i ] > light->origin[ i ] || maxs[ i ] < light->origin[ i ] ) {
- //% Sys_Printf( "WARNING: Light PVS bounds (%.0f, %.0f, %.0f) -> (%.0f, %.0f, %.0f)\ndo not encompass light %d (%f, %f, %f)\n",
+ //% Sys_FPrintf( SYS_WRN, "WARNING: Light PVS bounds (%.0f, %.0f, %.0f) -> (%.0f, %.0f, %.0f)\ndo not encompass light %d (%f, %f, %f)\n",
//% mins[ 0 ], mins[ 1 ], mins[ 2 ],
//% maxs[ 0 ], maxs[ 1 ], maxs[ 2 ],
//% numLights, light->origin[ 0 ], light->origin[ 1 ], light->origin[ 2 ] );
continue;
}
+ if( lm->styles[lightmapNum] != LS_NORMAL && lm->styles[lightmapNum] != LS_NONE ) // isStyleLight
+ continue;
+
/* apply floodlight to each luxel */
for ( y = 0; y < lm->sh; y++ )
{