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(light->extraDist == 0.0f)
light->extraDist = extraDist;
- intensity = intensity * pointScale;
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 add;
float dist;
float addDeluxe = 0.0f, addDeluxeBounceScale = 0.25f;
- qboolean angledDeluxe = qfalse;
+ 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 );
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 = 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;
float dot = DotProduct( trace->normal, trace->direction );
/* twosided lighting */
- if( trace->twoSided )
- dot = fabs( dot );
+ 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 )
float dot = DotProduct( trace->normal, trace->direction );
/* twosided lighting */
- if( trace->twoSided )
- dot = fabs( dot );
+ 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 )
{
/* trace */
TraceLine( trace );
+ trace->forceSubsampling *= add;
if( !(trace->compileFlags & C_SKY) || trace->opaque )
{
VectorClear( trace->color );
/* return to sender */
return 1;
}
+ else
+ Error("Light of undefined type!");
/* VorteX: set noShadow color */
VectorScale(light->color, add, trace->colorNoShadow);
if( bouncing )
{
addDeluxe *= addDeluxeBounceScale;
+ /* better NOT increase it beyond the original value
if( addDeluxe < 0.00390625f )
addDeluxe = 0.00390625f;
+ */
}
- VectorScale( trace->direction, addDeluxe, trace->directionContribution );
+ 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 );
/////// Floodlighting for point //////////////////
//do our floodlight ambient occlusion loop, and add a single contribution based on the brightest dir
- if( floodlighty )\r
- {\r
- int k;\r
- float addSize, f;\r
- vec3_t dir = { 0, 0, 1 };\r
- float ambientFrac = 0.25f;\r
-\r
- trace.testOcclusion = qtrue;\r
- trace.forceSunlight = qfalse;\r
- trace.inhibitRadius = DEFAULT_INHIBIT_RADIUS;\r
- trace.testAll = qtrue;\r
-\r
- for( k = 0; k < 2; k++ )\r
- {\r
- if( k == 0 ) // upper hemisphere\r
- {\r
- trace.normal[0] = 0;\r
- trace.normal[1] = 0;\r
- trace.normal[2] = 1;\r
- }\r
- else //lower hemisphere\r
- {\r
- trace.normal[0] = 0;\r
- trace.normal[1] = 0;\r
- trace.normal[2] = -1;\r
- }\r
-\r
- f = FloodLightForSample( &trace, floodlightDistance, floodlight_lowquality );\r
-\r
- /* add a fraction as pure ambient, half as top-down direction */\r
- contributions[ numCon ].color[0]= floodlightRGB[0] * floodlightIntensity * f * ( 1.0f - ambientFrac );\r
- contributions[ numCon ].color[1]= floodlightRGB[1] * floodlightIntensity * f * ( 1.0f - ambientFrac );\r
- contributions[ numCon ].color[2]= floodlightRGB[2] * floodlightIntensity * f * ( 1.0f - ambientFrac );\r
-\r
- contributions[ numCon ].ambient[0]= floodlightRGB[0] * floodlightIntensity * f * ambientFrac;\r
- contributions[ numCon ].ambient[1]= floodlightRGB[1] * floodlightIntensity * f * ambientFrac;\r
- contributions[ numCon ].ambient[2]= floodlightRGB[2] * floodlightIntensity * f * ambientFrac;\r
-\r
- contributions[ numCon ].dir[0] = dir[0];\r
- contributions[ numCon ].dir[1] = dir[1];\r
- contributions[ numCon ].dir[2] = dir[2];\r
-\r
- contributions[ numCon ].style = 0;\r
-\r
- /* push average direction around */\r
- addSize = VectorLength( contributions[ numCon ].color );\r
- VectorMA( gp->dir, addSize, dir, gp->dir );\r
-\r
- numCon++;\r
- }\r
+ if( floodlighty )
+ {
+ 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( k = 0; k < 2; k++ )
+ {
+ if( k == 0 ) // upper hemisphere
+ {
+ 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;
+ }
+
+ 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 ].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 ].style = 0;
+
+ /* push average direction around */
+ addSize = VectorLength( contributions[ numCon ].color );
+ VectorMA( gp->dir, addSize, dir, gp->dir );
+
+ numCon++;
+ }
}
/////////////////////
vec3_t color;
float f;
int b, bt;
- qboolean minVertex, minGrid, ps;
+ qboolean minVertex, minGrid;
const char *value;
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" );
+
lightmapCompensate = game->lightmapCompensate;
Sys_Printf( " lightning compensation: %f\n", lightmapCompensate );
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;
else if( !strcmp( argv[ i ], "-griddirectionality" ) )
{
f = atof( argv[ i + 1 ] );
- if(f < 0) f = 0;
- if(f > gridAmbientDirectionality) f = gridAmbientDirectionality;
+ if(f > 1) f = 1;
+ if(f < gridAmbientDirectionality) gridAmbientDirectionality = f;
Sys_Printf( "Grid directionality is %f\n", f );
- gridDirectionality *= f;
+ gridDirectionality = f;
i++;
}
else if( !strcmp( argv[ i ], "-gridambientdirectionality" ) )
{
f = atof( argv[ i + 1 ] );
- if(f > gridDirectionality) f = gridDirectionality;
- if(f > 1) f = 1;
+ if(f < -1) f = -1;
+ if(f > gridDirectionality) gridDirectionality = f;
Sys_Printf( "Grid ambient directionality is %f\n", f );
- gridAmbientDirectionality *= f;
+ gridAmbientDirectionality = f;
i++;
}
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 ], "-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;
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 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();