int angleSteps, elevationSteps;
float angle, elevation;
float angleStep, elevationStep;
- float step, start;
sun_t sun;
if( value <= 0.0f || iterations < 2 )
return;
- /* calculate some stuff */
- step = 2.0f / (iterations - 1);
- start = -1.0f;
-
/* basic sun setup */
VectorCopy( color, sun.color );
sun.deviance = 0.0f;
if( _color && _color[ 0 ] )
{
sscanf( _color, "%f %f %f", &light->color[ 0 ], &light->color[ 1 ], &light->color[ 2 ] );
+ if (colorsRGB)
+ {
+ light->color[0] = Image_LinearFloatFromsRGBFloat(light->color[0]);
+ light->color[1] = Image_LinearFloatFromsRGBFloat(light->color[1]);
+ light->color[2] = Image_LinearFloatFromsRGBFloat(light->color[2]);
+ }
if (!(light->flags & LIGHT_UNNORMALIZED))
{
ColorNormalize( light->color, light->color );
else
light->color[ 0 ] = light->color[ 1 ] = light->color[ 2 ] = 1.0f;
- intensity = intensity * pointScale;
+ light->extraDist = FloatForKey( e, "_extradist" );
+ if(light->extraDist == 0.0f)
+ light->extraDist = extraDist;
+
light->photons = intensity;
light->type = EMIT_POINT;
{
Sys_Printf( "WARNING: light at (%i %i %i) has missing target\n",
(int) light->origin[ 0 ], (int) light->origin[ 1 ], (int) light->origin[ 2 ] );
+ light->photons *= pointScale;
}
else
{
/* make a sun */
VectorScale( light->normal, -1.0f, sun.direction );
VectorCopy( light->color, sun.color );
- sun.photons = (intensity / pointScale);
+ sun.photons = intensity;
sun.deviance = deviance / 180.0f * Q_PI;
sun.numSamples = numSamples;
sun.style = noStyles ? LS_NORMAL : light->style;
/* skip the rest of this love story */
continue;
}
+ else
+ {
+ light->photons *= spotScale;
+ }
}
}
+ else
+ light->photons *= pointScale;
/* jitter the light */
for( j = 1; j < numSamples; j++ )
float angle;
float add;
float dist;
-
+ float addDeluxe = 0.0f, addDeluxeBounceScale = 0.25f;
+ qboolean angledDeluxe = qtrue;
+ float colorBrightness;
+ qboolean doAddDeluxe = qtrue;
/* get light */
light = trace->light;
/* clear color */
+ trace->forceSubsampling = 0.0f; /* to make sure */
VectorClear( trace->color );
VectorClear( trace->colorNoShadow );
+ VectorClear( trace->directionContribution );
+
+ colorBrightness = RGBTOGRAY( light->color ) * ( 1.0f/255.0f );
/* ydnar: early out */
if( !(light->flags & LIGHT_SURFACES) || light->envelope <= 0.0f )
}
/* nudge the point so that it is clearly forward of the light */
- /* so that surfaces meeting a light emiter don't get black edges */
+ /* so that surfaces meeting a light emitter don't get black edges */
if( d > -8.0f && d < 8.0f )
VectorMA( trace->origin, (8.0f - d), light->normal, pushedOrigin );
else
angle = DotProduct( trace->normal, trace->direction );
/* twosided lighting */
- if( trace->twoSided )
- angle = fabs( angle );
+ if( trace->twoSided && angle < 0 )
+ {
+ angle = -angle;
+
+ /* no deluxemap contribution from "other side" light */
+ doAddDeluxe = qfalse;
+ }
/* attenuate */
angle *= -DotProduct( light->normal, trace->direction );
return 0;
else if( angle < 0.0f &&
(trace->twoSided || (light->flags & LIGHT_TWOSIDED)) )
+ {
angle = -angle;
+
+ /* no deluxemap contribution from "other side" light */
+ doAddDeluxe = qfalse;
+ }
+
+ /* clamp the distance to prevent super hot spots */
+ dist = sqrt(dist * dist + light->extraDist * light->extraDist);
+ if( dist < 16.0f )
+ dist = 16.0f;
+
add = light->photons / (dist * dist) * angle;
+
+ if( deluxemap )
+ {
+ if( angledDeluxe )
+ addDeluxe = light->photons / (dist * dist) * angle;
+ else
+ addDeluxe = light->photons / (dist * dist);
+ }
}
else
{
dist = SetupTrace( trace );
if( dist >= light->envelope )
return 0;
+
+ /* no deluxemap contribution from "other side" light */
+ doAddDeluxe = qfalse;
}
else
return 0;
}
+
+ /* also don't deluxe if the direction is on the wrong side */
+ if(DotProduct(trace->normal, trace->direction) < 0)
+ {
+ /* no deluxemap contribution from "other side" light */
+ doAddDeluxe = qfalse;
+ }
/* ydnar: moved to here */
add = factor * light->add;
+
+ if( deluxemap )
+ addDeluxe = add;
}
}
dist = SetupTrace( trace );
if( dist >= light->envelope )
return 0;
-
+
/* clamp the distance to prevent super hot spots */
+ dist = sqrt(dist * dist + light->extraDist * light->extraDist);
if( dist < 16.0f )
dist = 16.0f;
-
+
/* angle attenuation */
- angle = (light->flags & LIGHT_ATTEN_ANGLE) ? DotProduct( trace->normal, trace->direction ) : 1.0f;
+ if( light->flags & LIGHT_ATTEN_ANGLE )
+ {
+ /* standard Lambert attenuation */
+ float dot = DotProduct( trace->normal, trace->direction );
+
+ /* twosided lighting */
+ if( trace->twoSided && dot < 0 )
+ {
+ dot = -dot;
+
+ /* no deluxemap contribution from "other side" light */
+ doAddDeluxe = qfalse;
+ }
+
+ /* jal: optional half Lambert attenuation (http://developer.valvesoftware.com/wiki/Half_Lambert) */
+ if( lightAngleHL )
+ {
+ if( dot > 0.001f ) // skip coplanar
+ {
+ if( dot > 1.0f ) dot = 1.0f;
+ dot = ( dot * 0.5f ) + 0.5f;
+ dot *= dot;
+ }
+ else
+ dot = 0;
+ }
+
+ angle = dot;
+ }
+ else
+ angle = 1.0f;
+
if( light->angleScale != 0.0f )
{
angle /= light->angleScale;
angle = 1.0f;
}
- /* twosided lighting */
- if( trace->twoSided )
- angle = fabs( angle );
-
/* attenuate */
if( light->flags & LIGHT_ATTEN_LINEAR )
{
add = angle * light->photons * linearScale - (dist * light->fade);
if( add < 0.0f )
add = 0.0f;
+
+ if( deluxemap )
+ {
+ if( angledDeluxe )
+ addDeluxe = angle * light->photons * linearScale - (dist * light->fade);
+ else
+ addDeluxe = light->photons * linearScale - (dist * light->fade);
+
+ if( addDeluxe < 0.0f )
+ addDeluxe = 0.0f;
+ }
}
else
- add = light->photons / (dist * dist) * angle;
+ {
+ add = (light->photons / (dist * dist)) * angle;
+ if( add < 0.0f )
+ add = 0.0f;
+
+ if( deluxemap )
+ {
+ if( angledDeluxe )
+ addDeluxe = (light->photons / (dist * dist)) * angle;
+ else
+ addDeluxe = (light->photons / (dist * dist));
+ }
+
+ if( addDeluxe < 0.0f )
+ addDeluxe = 0.0f;
+ }
/* handle spotlights */
if( light->type == EMIT_SPOT )
/* attenuate */
if( sampleRadius > (radiusAtDist - 32.0f) )
+ {
add *= ((radiusAtDist - sampleRadius) / 32.0f);
+ if( add < 0.0f )
+ add = 0.0f;
+
+ addDeluxe *= ((radiusAtDist - sampleRadius) / 32.0f);
+
+ if( addDeluxe < 0.0f )
+ addDeluxe = 0.0f;
+ }
}
}
/* get origin and direction */
VectorAdd( trace->origin, light->origin, trace->end );
dist = SetupTrace( trace );
-
+
/* angle attenuation */
- angle = (light->flags & LIGHT_ATTEN_ANGLE)
- ? DotProduct( trace->normal, trace->direction )
- : 1.0f;
-
- /* twosided lighting */
- if( trace->twoSided )
- angle = fabs( angle );
+ if( light->flags & LIGHT_ATTEN_ANGLE )
+ {
+ /* standard Lambert attenuation */
+ float dot = DotProduct( trace->normal, trace->direction );
+
+ /* twosided lighting */
+ if( trace->twoSided && dot < 0 )
+ {
+ dot = -dot;
+
+ /* no deluxemap contribution from "other side" light */
+ doAddDeluxe = qfalse;
+ }
+
+ /* jal: optional half Lambert attenuation (http://developer.valvesoftware.com/wiki/Half_Lambert) */
+ if( lightAngleHL )
+ {
+ if( dot > 0.001f ) // skip coplanar
+ {
+ if( dot > 1.0f ) dot = 1.0f;
+ dot = ( dot * 0.5f ) + 0.5f;
+ dot *= dot;
+ }
+ else
+ dot = 0;
+ }
+
+ angle = dot;
+ }
+ else
+ angle = 1.0f;
/* attenuate */
add = light->photons * angle;
+
+ if( deluxemap )
+ {
+ if( angledDeluxe )
+ addDeluxe = light->photons * angle;
+ else
+ addDeluxe = light->photons;
+
+ if( addDeluxe < 0.0f )
+ addDeluxe = 0.0f;
+ }
+
if( add <= 0.0f )
return 0;
/* VorteX: set noShadow color */
VectorScale(light->color, add, trace->colorNoShadow);
+
+ addDeluxe *= colorBrightness;
+
+ if( bouncing )
+ {
+ addDeluxe *= addDeluxeBounceScale;
+ if( addDeluxe < 0.00390625f )
+ addDeluxe = 0.00390625f;
+ }
+
+ VectorScale( trace->direction, addDeluxe, trace->directionContribution );
/* setup trace */
trace->testAll = qtrue;
{
/* trace */
TraceLine( trace );
+ trace->forceSubsampling *= add;
if( !(trace->compileFlags & C_SKY) || trace->opaque )
{
VectorClear( trace->color );
+ VectorClear( trace->directionContribution );
+
return -1;
}
}
/* return to sender */
return 1;
}
+ else
+ Error("Light of undefined type!");
/* VorteX: set noShadow color */
VectorScale(light->color, add, trace->colorNoShadow);
/* ydnar: changed to a variable number */
if( add <= 0.0f || (add <= light->falloffTolerance && (light->flags & LIGHT_FAST_ACTUAL)) )
return 0;
+
+ addDeluxe *= colorBrightness;
+
+ /* hack land: scale down the radiosity contribution to light directionality.
+ Deluxemaps fusion many light directions into one. In a rtl process all lights
+ would contribute individually to the bump map, so several light sources together
+ would make it more directional (example: a yellow and red lights received from
+ opposing sides would light one side in red and the other in blue, adding
+ the effect of 2 directions applied. In the deluxemapping case, this 2 lights would
+ neutralize each other making it look like having no direction.
+ Same thing happens with radiosity. In deluxemapping case the radiosity contribution
+ is modifying the direction applied from directional lights, making it go closer and closer
+ to the surface normal the bigger is the amount of radiosity received.
+ So, for preserving the directional lights contributions, we scale down the radiosity
+ contribution. It's a hack, but there's a reason behind it */
+ if( bouncing )
+ {
+ addDeluxe *= addDeluxeBounceScale;
+ /* better NOT increase it beyond the original value
+ if( addDeluxe < 0.00390625f )
+ addDeluxe = 0.00390625f;
+ */
+ }
+
+ if(doAddDeluxe)
+ {
+ VectorScale( trace->direction, addDeluxe, trace->directionContribution );
+ }
/* setup trace */
trace->testAll = qfalse;
/* raytrace */
TraceLine( trace );
+ trace->forceSubsampling *= add;
if( trace->passSolid || trace->opaque )
{
VectorClear( trace->color );
+ VectorClear( trace->directionContribution );
+
return -1;
}
if( light->type == EMIT_AREA && faster )
{
/* clamp the distance to prevent super hot spots */
+ dist = sqrt(dist * dist + light->extraDist * light->extraDist);
if( dist < 16.0f )
dist = 16.0f;
-
+
/* attenuate */
add = light->photons / (dist * dist);
}
else if( light->type == EMIT_POINT || light->type == EMIT_SPOT )
{
/* clamp the distance to prevent super hot spots */
+ dist = sqrt(dist * dist + light->extraDist * light->extraDist);
if( dist < 16.0f )
dist = 16.0f;
{
vec3_t dir;
vec3_t color;
+ vec3_t ambient;
int style;
}
contribution_t;
void TraceGrid( int num )
{
- int i, j, x, y, z, mod, step, numCon, numStyles;
- float d;
- vec3_t baseOrigin, cheapColor, color;
+ int i, j, x, y, z, mod, numCon, numStyles;
+ float d, step;
+ vec3_t baseOrigin, cheapColor, color, thisdir;
rawGridPoint_t *gp;
bspGridPoint_t *bgp;
contribution_t contributions[ MAX_CONTRIBUTIONS ];
trace_t trace;
-
/* get grid points */
gp = &rawGridPoints[ num ];
bgp = &bspGridPoints[ num ];
{
/* try to nudge the origin around to find a valid point */
VectorCopy( trace.origin, baseOrigin );
- for( step = 9; step <= 18; step += 9 )
+ for( step = 0; (step += 0.005) <= 1.0; )
{
- for( i = 0; i < 8; i++ )
- {
- VectorCopy( baseOrigin, trace.origin );
- if( i & 1 )
- trace.origin[ 0 ] += step;
- else
- trace.origin[ 0 ] -= step;
-
- if( i & 2 )
- trace.origin[ 1 ] += step;
- else
- trace.origin[ 1 ] -= step;
+ VectorCopy( baseOrigin, trace.origin );
+ trace.origin[ 0 ] += step * (Random() - 0.5) * gridSize[0];
+ trace.origin[ 1 ] += step * (Random() - 0.5) * gridSize[1];
+ trace.origin[ 2 ] += step * (Random() - 0.5) * gridSize[2];
- if( i & 4 )
- trace.origin[ 2 ] += step;
- else
- trace.origin[ 2 ] -= step;
-
- /* ydnar: changed to find cluster num */
- trace.cluster = ClusterForPointExt( trace.origin, VERTEX_EPSILON );
- if( trace.cluster >= 0 )
- break;
- }
-
- if( i != 8 )
+ /* ydnar: changed to find cluster num */
+ trace.cluster = ClusterForPointExt( trace.origin, VERTEX_EPSILON );
+ if( trace.cluster >= 0 )
break;
}
/* can't find a valid point at all */
- if( step > 18 )
+ if( step > 1.0 )
return;
}
/* add a contribution */
VectorCopy( trace.color, contributions[ numCon ].color );
VectorCopy( trace.direction, contributions[ numCon ].dir );
+ VectorClear( contributions[ numCon ].ambient );
contributions[ numCon ].style = trace.light->style;
numCon++;
/////// Floodlighting for point //////////////////
//do our floodlight ambient occlusion loop, and add a single contribution based on the brightest dir
- if (floodlighty)
+ if( floodlighty )
{
- int q;
- float addSize,f;
- vec3_t col,dir;
- col[0]=col[1]=col[2]=floodlightIntensity;
- dir[0]=dir[1]=0;
- dir[2]=1;
+ int k;
+ float addSize, f;
+ vec3_t dir = { 0, 0, 1 };
+ float ambientFrac = 0.25f;
trace.testOcclusion = qtrue;
trace.forceSunlight = qfalse;
trace.inhibitRadius = DEFAULT_INHIBIT_RADIUS;
trace.testAll = qtrue;
- for (q=0;q<2;q++)
+ for( k = 0; k < 2; k++ )
{
- if (q==0) //upper hemisphere
+ if( k == 0 ) // upper hemisphere
{
- trace.normal[0]=0;
- trace.normal[1]=0;
- trace.normal[2]=1;
+ trace.normal[0] = 0;
+ trace.normal[1] = 0;
+ trace.normal[2] = 1;
}
else //lower hemisphere
{
- trace.normal[0]=0;
- trace.normal[1]=0;
- trace.normal[2]=-1;
+ trace.normal[0] = 0;
+ trace.normal[1] = 0;
+ trace.normal[2] = -1;
}
- f = FloodLightForSample(&trace, floodlightDistance, floodlight_lowquality);
+ f = FloodLightForSample( &trace, floodlightDistance, floodlight_lowquality );
+
+ /* add a fraction as pure ambient, half as top-down direction */
+ contributions[ numCon ].color[0]= floodlightRGB[0] * floodlightIntensity * f * ( 1.0f - ambientFrac );
+ contributions[ numCon ].color[1]= floodlightRGB[1] * floodlightIntensity * f * ( 1.0f - ambientFrac );
+ contributions[ numCon ].color[2]= floodlightRGB[2] * floodlightIntensity * f * ( 1.0f - ambientFrac );
- contributions[ numCon ].color[0]=col[0]*f;
- contributions[ numCon ].color[1]=col[1]*f;
- contributions[ numCon ].color[2]=col[2]*f;
+ contributions[ numCon ].ambient[0]= floodlightRGB[0] * floodlightIntensity * f * ambientFrac;
+ contributions[ numCon ].ambient[1]= floodlightRGB[1] * floodlightIntensity * f * ambientFrac;
+ contributions[ numCon ].ambient[2]= floodlightRGB[2] * floodlightIntensity * f * ambientFrac;
- contributions[ numCon ].dir[0]=dir[0];
- contributions[ numCon ].dir[1]=dir[1];
- contributions[ numCon ].dir[2]=dir[2];
+ contributions[ numCon ].dir[0] = dir[0];
+ contributions[ numCon ].dir[1] = dir[1];
+ contributions[ numCon ].dir[2] = dir[2];
contributions[ numCon ].style = 0;
- numCon++;
+
/* push average direction around */
- addSize = VectorLength( col );
+ addSize = VectorLength( contributions[ numCon ].color );
VectorMA( gp->dir, addSize, dir, gp->dir );
+
+ numCon++;
}
}
/////////////////////
/* normalize to get primary light direction */
- VectorNormalize( gp->dir, gp->dir );
+ VectorNormalize( gp->dir, thisdir );
/* now that we have identified the primary light direction,
go back and separate all the light into directed and ambient */
for( i = 0; i < numCon; i++ )
{
/* get relative directed strength */
- d = DotProduct( contributions[ i ].dir, gp->dir );
+ d = DotProduct( contributions[ i ].dir, thisdir );
+ /* we map 1 to gridDirectionality, and 0 to gridAmbientDirectionality */
+ d = gridAmbientDirectionality + d * (gridDirectionality - gridAmbientDirectionality);
if( d < 0.0f )
d = 0.0f;
d = 0.25f * (1.0f - d);
VectorMA( gp->ambient[ j ], d, contributions[ i ].color, gp->ambient[ j ] );
+ VectorAdd( gp->ambient[ j ], contributions[ i ].ambient, gp->ambient[ j ] );
+
/*
* div0:
* the total light average = ambient value + 0.25 * sum of all directional values
#endif
/* store direction */
- if( !bouncing )
- NormalToLatLong( gp->dir, bgp->latLong );
+ NormalToLatLong( thisdir, bgp->latLong );
}
/* find the optional minimum lighting values */
GetVectorForKey( &entities[ 0 ], "_color", color );
+ if (colorsRGB)
+ {
+ color[0] = Image_LinearFloatFromsRGBFloat(color[0]);
+ color[1] = Image_LinearFloatFromsRGBFloat(color[1]);
+ color[2] = Image_LinearFloatFromsRGBFloat(color[2]);
+ }
if( VectorLength( color ) == 0.0f )
VectorSet( color, 1.0, 1.0, 1.0 );
SetupEnvelopes( qtrue, fastgrid );
Sys_Printf( "--- TraceGrid ---\n" );
+ inGrid = qtrue;
RunThreadsOnIndividual( numRawGridPoints, qtrue, TraceGrid );
+ inGrid = qfalse;
Sys_Printf( "%d x %d x %d = %d grid\n",
gridBounds[ 0 ], gridBounds[ 1 ], gridBounds[ 2 ], numBSPGridPoints );
if( dirty )
{
Sys_Printf( "--- DirtyRawLightmap ---\n" );
-
-
-
-
RunThreadsOnIndividual( numRawLightmaps, qtrue, DirtyRawLightmap );
}
gridBoundsCulled = 0;
Sys_Printf( "--- BounceGrid ---\n" );
+ inGrid = qtrue;
RunThreadsOnIndividual( numRawGridPoints, qtrue, TraceGrid );
+ inGrid = qfalse;
Sys_FPrintf( SYS_VRB, "%9d grid points envelope culled\n", gridEnvelopeCulled );
Sys_FPrintf( SYS_VRB, "%9d grid points bounds culled\n", gridBoundsCulled );
}
char mapSource[ 1024 ];
const char *value;
int lightmapMergeSize = 0;
+ qboolean lightSamplesInsist = qfalse;
/* note it */
lightmapGamma = game->lightmapGamma;
Sys_Printf( " lightning gamma: %f\n", lightmapGamma );
+ lightmapsRGB = game->lightmapsRGB;
+ if(lightmapsRGB)
+ Sys_Printf( " lightmap colorspace: sRGB\n" );
+ else
+ Sys_Printf( " lightmap colorspace: linear\n" );
+
+ texturesRGB = game->texturesRGB;
+ if(texturesRGB)
+ Sys_Printf( " texture colorspace: sRGB\n" );
+ else
+ Sys_Printf( " texture colorspace: linear\n" );
+
+ colorsRGB = game->colorsRGB;
+ if(colorsRGB)
+ Sys_Printf( " _color colorspace: sRGB\n" );
+ else
+ Sys_Printf( " _color colorspace: linear\n" );
+
lightmapCompensate = game->lightmapCompensate;
Sys_Printf( " lightning compensation: %f\n", lightmapCompensate );
gridAmbientScale = game->gridAmbientScale;
Sys_Printf( " lightgrid ambient scale: %f\n", gridAmbientScale );
+ lightAngleHL = game->lightAngleHL;
+ if( lightAngleHL )
+ Sys_Printf( " half lambert light angle attenuation enabled \n" );
+
noStyles = game->noStyles;
if (noStyles == qtrue)
Sys_Printf( " shader lightstyles hack: disabled\n" );
else
Sys_Printf( " shader lightstyles hack: enabled\n" );
- keepLights = game->keepLights;
- if (keepLights == qtrue)
- Sys_Printf( " keep lights: enabled\n" );
- else
- Sys_Printf( " keep lights: disabled\n" );
-
patchShadows = game->patchShadows;
if (patchShadows == qtrue)
Sys_Printf( " patch shadows: enabled\n" );
{
f = atof( argv[ i + 1 ] );
pointScale *= f;
- Sys_Printf( "Point (entity) light scaled by %f to %f\n", f, pointScale );
+ spotScale *= f;
+ Sys_Printf( "Spherical point (entity) light scaled by %f to %f\n", f, pointScale );
+ Sys_Printf( "Spot point (entity) light scaled by %f to %f\n", f, spotScale );
+ i++;
+ }
+
+ else if( !strcmp( argv[ i ], "-spherical" ) || !strcmp( argv[ i ], "-sphericalscale" ) )
+ {
+ f = atof( argv[ i + 1 ] );
+ pointScale *= f;
+ Sys_Printf( "Spherical point (entity) light scaled by %f to %f\n", f, pointScale );
+ i++;
+ }
+
+ else if( !strcmp( argv[ i ], "-spot" ) || !strcmp( argv[ i ], "-spotscale" ) )
+ {
+ f = atof( argv[ i + 1 ] );
+ spotScale *= f;
+ Sys_Printf( "Spot point (entity) light scaled by %f to %f\n", f, spotScale );
i++;
}
{
f = atof( argv[ i + 1 ] );
pointScale *= f;
+ spotScale *= f;
areaScale *= f;
skyScale *= f;
bounceScale *= f;
gridAmbientScale *= f;
i++;
}
+
+ else if( !strcmp( argv[ i ], "-griddirectionality" ) )
+ {
+ f = atof( argv[ i + 1 ] );
+ if(f > 1) f = 1;
+ if(f < gridAmbientDirectionality) gridAmbientDirectionality = f;
+ Sys_Printf( "Grid directionality is %f\n", f );
+ gridDirectionality = f;
+ i++;
+ }
+
+ else if( !strcmp( argv[ i ], "-gridambientdirectionality" ) )
+ {
+ f = atof( argv[ i + 1 ] );
+ if(f < -1) f = -1;
+ if(f > gridDirectionality) gridDirectionality = f;
+ Sys_Printf( "Grid ambient directionality is %f\n", f );
+ gridAmbientDirectionality = f;
+ i++;
+ }
else if( !strcmp( argv[ i ], "-gamma" ) )
{
i++;
}
+ else if( !strcmp( argv[ i ], "-sRGBlight" ) )
+ {
+ lightmapsRGB = qtrue;
+ Sys_Printf( "Lighting is in sRGB\n" );
+ }
+
+ else if( !strcmp( argv[ i ], "-nosRGBlight" ) )
+ {
+ lightmapsRGB = qfalse;
+ Sys_Printf( "Lighting is linear\n" );
+ }
+
+ else if( !strcmp( argv[ i ], "-sRGBtex" ) )
+ {
+ texturesRGB = qtrue;
+ Sys_Printf( "Textures are in sRGB\n" );
+ }
+
+ else if( !strcmp( argv[ i ], "-nosRGBtex" ) )
+ {
+ texturesRGB = qfalse;
+ Sys_Printf( "Textures are linear\n" );
+ }
+
+ else if( !strcmp( argv[ i ], "-sRGBcolor" ) )
+ {
+ colorsRGB = qtrue;
+ Sys_Printf( "Colors are in sRGB\n" );
+ }
+
+ else if( !strcmp( argv[ i ], "-nosRGBcolor" ) )
+ {
+ colorsRGB = qfalse;
+ Sys_Printf( "Colors are linear\n" );
+ }
+
+ else if( !strcmp( argv[ i ], "-nosRGB" ) )
+ {
+ lightmapsRGB = qtrue;
+ Sys_Printf( "Lighting is linear\n" );
+ texturesRGB = qtrue;
+ Sys_Printf( "Textures are linear\n" );
+ colorsRGB = qtrue;
+ Sys_Printf( "Colors are linear\n" );
+ }
+
else if( !strcmp( argv[ i ], "-exposure" ) )
{
f = atof( argv[ i + 1 ] );
i++;
}
+ else if( !strcmp( argv[ i ], "-randomsamples" ) )
+ {
+ lightRandomSamples = qtrue;
+ Sys_Printf( "Random sampling enabled\n", lightRandomSamples );
+ }
+
else if( !strcmp( argv[ i ], "-samples" ) )
{
+ if(*argv[i+1] == '+')
+ lightSamplesInsist = qtrue;
+ else
+ lightSamplesInsist = qfalse;
lightSamples = atoi( argv[ i + 1 ] );
if( lightSamples < 1 )
lightSamples = 1;
i++;
}
+ else if( !strcmp( argv[ i ], "-samplessearchboxsize" ) )
+ {
+ lightSamplesSearchBoxSize = atoi( argv[ i + 1 ] );
+ if( lightSamplesSearchBoxSize <= 0 )
+ lightSamplesSearchBoxSize = 1;
+ if( lightSamplesSearchBoxSize > 4 )
+ lightSamplesSearchBoxSize = 4; /* more makes no sense */
+ else if( lightSamplesSearchBoxSize != 1 )
+ Sys_Printf( "Adaptive supersampling uses %f times the normal search box size\n", lightSamplesSearchBoxSize );
+ i++;
+ }
+
else if( !strcmp( argv[ i ], "-filter" ) )
{
filter = qtrue;
wolfLight = qfalse;
Sys_Printf( "Enabling Quake 3 lighting model (nonlinear default)\n" );
}
+
+ else if( !strcmp( argv[ i ], "-extradist" ) )
+ {
+ extraDist = atof( argv[ i + 1 ] );
+ if( extraDist < 0 )
+ extraDist = 0;
+ i++;
+ Sys_Printf( "Default extra radius set to %f units\n", extraDist );
+ }
else if( !strcmp( argv[ i ], "-sunonly" ) )
{
Sys_Printf( "The -smooth argument is deprecated, use \"-samples 2\" instead\n" );
}
+ else if( !strcmp( argv[ i ], "-nofastpoint" ) )
+ {
+ fastpoint = qfalse;
+ Sys_Printf( "Automatic fast mode for point lights disabled\n" );
+ }
+
else if( !strcmp( argv[ i ], "-fast" ) )
{
fast = qtrue;
fastgrid = qtrue;
fastbounce = qtrue;
- Sys_Printf( "Fast mode enabled\n" );
+ Sys_Printf( "Fast mode enabled for all area lights\n" );
}
else if( !strcmp( argv[ i ], "-faster" ) )
loMem = qtrue;
Sys_Printf( "Enabling low-memory (potentially slower) lighting mode\n" );
}
+ else if( !strcmp( argv[ i ], "-lightanglehl" ) )
+ {
+ if( ( atoi( argv[ i + 1 ] ) != 0 ) != lightAngleHL )
+ {
+ lightAngleHL = ( atoi( argv[ i + 1 ] ) != 0 );
+ if( lightAngleHL )
+ Sys_Printf( "Enabling half lambert light angle attenuation\n" );
+ else
+ Sys_Printf( "Disabling half lambert light angle attenuation\n" );
+ }
+ }
else if( !strcmp( argv[ i ], "-nostyle" ) || !strcmp( argv[ i ], "-nostyles" ) )
{
noStyles = qtrue;
noStyles = qfalse;
Sys_Printf( "Enabling lightstyles\n" );
}
- else if( !strcmp( argv[ i ], "-keeplights" ))
- {
- keepLights = qtrue;
- Sys_Printf( "Leaving light entities on map after compile\n" );
- }
else if( !strcmp( argv[ i ], "-cpma" ) )
{
cpmaHack = qtrue;
{
lightmapExtraVisClusterNudge = qtrue;
}
+ else if( !strcmp( argv[ i ], "-fill" ) )
+ {
+ lightmapFill = qtrue;
+ Sys_Printf( "Filling lightmap colors from surrounding pixels to improve JPEG compression\n" );
+ }
/* unhandled args */
else
{
}
+ /* fix up falloff tolerance for sRGB */
+ if(lightmapsRGB)
+ falloffTolerance = Image_LinearFloatFromsRGBFloat(falloffTolerance * (1.0 / 255.0)) * 255.0;
+
+ /* fix up samples count */
+ if(lightRandomSamples)
+ {
+ if(!lightSamplesInsist)
+ {
+ /* approximately match -samples in quality */
+ switch(lightSamples)
+ {
+ /* somewhat okay */
+ case 1:
+ case 2:
+ lightSamples = 16;
+ Sys_Printf( "Adaptive supersampling preset enabled with %d random sample(s) per lightmap texel\n", lightSamples );
+ break;
+
+ /* good */
+ case 3:
+ lightSamples = 64;
+ Sys_Printf( "Adaptive supersampling preset enabled with %d random sample(s) per lightmap texel\n", lightSamples );
+ break;
+
+ /* perfect */
+ case 4:
+ lightSamples = 256;
+ Sys_Printf( "Adaptive supersampling preset enabled with %d random sample(s) per lightmap texel\n", lightSamples );
+ break;
+
+ default: break;
+ }
+ }
+ }
+
/* fix up lightmap search power */
if(lightmapMergeSize)
{
/* load map file */
value = ValueForKey( &entities[ 0 ], "_keepLights" );
if( value[ 0 ] != '1' )
- LoadMapFile( mapSource, qtrue );
+ LoadMapFile( mapSource, qtrue, qfalse );
/* set the entity/model origins and init yDrawVerts */
SetEntityOrigins();