Make models brighter with deluxe mapping off

The previous commit fixed excessive brightness with grid lighting
when deluxe mapping is disabled by using the average expected
brightness (over all directions) instead of the maximum, but
it went too far and made things dim. Boost the light a bit
since light directions are positively correlated with normals
in practice.

Author: slipher

src/engine/renderer/gl_shader.cpp

@@ -687,6 +687,8 @@ static std::string GenEngineConstants() {
 
 	AddDefine( str, "r_tileStep", glState.tileStep[0], glState.tileStep[1] );
 
+	AddDefine( str, "LIGHTGRID_AVERAGE_COSINE", tr.lightGridAverageCosine );
+
 	if ( glConfig.realtimeLighting )
 	{
 		AddDefine( str, "r_realtimeLighting", 1 );

src/engine/renderer/glsl_source/computeLight_fp.glsl

@@ -51,12 +51,12 @@ vec4 EnvironmentalSpecularFactor( vec3 viewDir, vec3 normal )
 
 #if defined(USE_GRID_LIGHTING) || defined(USE_GRID_DELUXE_MAPPING)
 	void ReadLightGrid( in vec4 texel1, in vec4 texel2, in float lightFactor, out vec3 lightDir, out vec3 ambientColor, out vec3 lightColor ) {
-		vec3 totalColor = /*LIGHTGRID_MAX_LIGHT*/ 1.25 * texel1.rgb;
+		vec3 totalColor = (1.0 + LIGHTGRID_AVERAGE_COSINE) * texel1.rgb;
 		float total1Norm = totalColor.r + totalColor.g + totalColor.b;
 		vec3 scaledLightDir = 2.0 * (texel2.xyz - (128.0 / 255.0));
 		float directed1Norm = 3.0 * length(scaledLightDir);
-		float directedFraction = clamp((0.25 * directed1Norm) / total1Norm, 0.0, 1.0);
-		float directedScale = 4.0 * directedFraction;
+		float directedFraction = clamp((LIGHTGRID_AVERAGE_COSINE * directed1Norm) / total1Norm, 0.0, 1.0);
+		float directedScale = directedFraction / LIGHTGRID_AVERAGE_COSINE;
 		float ambientScale = 1.0 - directedFraction;
 		ambientColor = ambientScale * totalColor;
 		lightColor = directedScale * totalColor;

src/engine/renderer/tr_backend.cpp

@@ -2227,11 +2227,11 @@ static void RB_RenderDebugUtils()
 					lightDir[ 1 ] = snorm8ToFloat( gp2->direction[ 1 ] - 128 );
 					lightDir[ 2 ] = snorm8ToFloat( gp2->direction[ 2 ] - 128 );
 					Color::Color totalColor = Color::Adapt( gp1->color );
-					totalColor *= LIGHTGRID_MAX_LIGHT;
+					totalColor *= 1.0f + tr.lightGridAverageCosine;
 					float total1Norm = totalColor.Red() + totalColor.Green() + totalColor.Blue();
 					float directed1Norm = 3.0f * VectorLength( lightDir );
-					float directedFraction = ( 0.25 * directed1Norm ) / total1Norm;
-					float directedScale = 4.0 * directedFraction;
+					float directedFraction = ( tr.lightGridAverageCosine * directed1Norm ) / total1Norm;
+					float directedScale = directedFraction / tr.lightGridAverageCosine;
 					float ambientScale = 1.0 - directedFraction;
 					Color::Color ambientColor = totalColor * ambientScale;
 					Color::Color directedColor = totalColor * directedScale;

src/engine/renderer/tr_bsp.cpp

@@ -3636,13 +3636,11 @@ void R_LoadLightGrid( lump_t *l )
 		direction[ 2 ] = cosf( lat );
 
 		// Separate ambient and directed colors are not implemented, so this is the total average light
-		// (averaged over all direction vectors): ambient + 0.25 * directed. See TraceGrid in light.c in
-		// q3map2 for more information about this equation. Though if to take
-		// half-Lambert lighting's cosine modification into account, the 1/4 factor should be replaced
-		// by 1/3. The result is scaled down to fit in [0, 1].
-		gridPoint1->color[ 0 ] = floatToUnorm8( ( ambientColor[ 0 ] + 0.25f * directedColor[ 0 ] ) / LIGHTGRID_MAX_LIGHT );
-		gridPoint1->color[ 1 ] = floatToUnorm8( ( ambientColor[ 1 ] + 0.25f * directedColor[ 1 ] ) / LIGHTGRID_MAX_LIGHT );
-		gridPoint1->color[ 2 ] = floatToUnorm8( ( ambientColor[ 2 ] + 0.25f * directedColor[ 2 ] ) / LIGHTGRID_MAX_LIGHT );
+		// (averaged over all direction vectors). The result is scaled down to fit in [0, 1].
+		float colorScale = 1.0f / ( 1.0f + tr.lightGridAverageCosine );
+		gridPoint1->color[ 0 ] = floatToUnorm8( ( ambientColor[ 0 ] + tr.lightGridAverageCosine * directedColor[ 0 ] ) * colorScale );
+		gridPoint1->color[ 1 ] = floatToUnorm8( ( ambientColor[ 1 ] + tr.lightGridAverageCosine * directedColor[ 1 ] ) * colorScale );
+		gridPoint1->color[ 2 ] = floatToUnorm8( ( ambientColor[ 2 ] + tr.lightGridAverageCosine * directedColor[ 2 ] ) * colorScale );
 		gridPoint1->unused = 255;
 
 		// The length of the direction vector is used to determine how much directed light there is.

src/engine/renderer/tr_init.cpp

@@ -1350,6 +1350,21 @@ ScreenshotCmd screenshotPNGRegistration("screenshotPNG", ssFormat_t::SSF_PNG, "p
 			}
 		}
 
+		if ( glConfig.deluxeMapping )
+		{
+			// Average value of max(0, dot(random vector, light dir)) over the unit sphere, used to
+			// compare directed lighting's average contribution with ambient. See TraceGrid in light.c in
+			// q3map2 for more information about this calculation. Though if we took half-Lambert lighting's
+			// cosine modification into account it would be 1/3 instead of 1/4.
+			tr.lightGridAverageCosine = 0.25f;
+		}
+		else
+		{
+			// Boost it when deluxe is disabled because otherwise it's too dark. Normals tend to line up
+			// with the light direction better than chance.
+			tr.lightGridAverageCosine = 0.4f;
+		}
+
 		R_NoiseInit();
 
 		R_Register();

src/engine/renderer/tr_local.h

@@ -1684,9 +1684,6 @@ enum
 		bspSurface_t *firstSurface;
 	};
 
-// max combined ambient+directed contribution to one color channel
-#define LIGHTGRID_MAX_LIGHT 1.25f
-
 	// The ambient and directional colors are packed into four bytes, the color[3] is the
 	// average of the ambient and directional colors and the ambientPart factor is the
 	// proportion of ambient light in the total light
@@ -2501,6 +2498,7 @@ enum
 		vec3_t ambientLight;
 		bool ambientLightSet = false;
 
+		float lightGridAverageCosine;
 		image_t   *lightGrid1Image;
 		image_t   *lightGrid2Image;