Introduce fogGradient shader keyword

Add a shader keyword that can be used to configure a gradient for fog
density, which tapers to 0 at the edge of the fog. The density of the
fog is scaled by a factor of (1 - exp(-k * t)) where t is the distance
under the fog plane and k a configurable constant.

fogGradient expFalloff <dist>  configures the exponential falloff such
that the density is at 50% of the maximum at <dist> qu from the fog
plane.

fogGradient const  does the same thing as the current default - no
gradient; hard-edged fog.

Author: slipher

src/engine/renderer/Material.cpp

@@ -1114,7 +1114,8 @@ void BindShaderFog( Material* material ) {
 	// since fognum is grouped with the GL state stuff, segregating each fognum in a separate draw call.
 
 	gl_fogQuake3ShaderMaterial->SetUniform_ViewOrigin( backEnd.viewParms.orientation.origin );
-	gl_fogQuake3ShaderMaterial->SetUniform_FogDensity( 1.0f / fog->shader->fogParms.depthForOpaque );
+	gl_fogQuake3ShaderMaterial->SetUniform_FogGradient(
+		1.0f / fog->shader->fogParms.depthForOpaque, fog->shader->fogParms.falloffExp );
 	gl_fogQuake3ShaderMaterial->SetUniform_FogDepthVector( fogDepthVector );
 	gl_fogQuake3ShaderMaterial->SetUniform_FogEyeT( eyeT );
 

src/engine/renderer/gl_shader.cpp

@@ -2697,7 +2697,7 @@ GLShader_fogQuake3::GLShader_fogQuake3() :
 	u_Bones( this ),
 	u_VertexInterpolation( this ),
 	u_ViewOrigin( this ),
-	u_FogDensity( this ),
+	u_FogGradient( this ),
 	u_FogDepthVector( this ),
 	u_FogEyeT( this ),
 	GLDeformStage( this ),
@@ -2713,7 +2713,7 @@ GLShader_fogQuake3Material::GLShader_fogQuake3Material() :
 	u_ModelViewProjectionMatrix( this ),
 	u_ColorGlobal_Uint( this ),
 	u_ViewOrigin( this ),
-	u_FogDensity( this ),
+	u_FogGradient( this ),
 	u_FogDepthVector( this ),
 	u_FogEyeT( this ),
 	GLDeformStage( this ) {

src/engine/renderer/gl_shader.h

@@ -1859,6 +1859,22 @@ class u_FogDensity :
 	}
 };
 
+class u_FogGradient :
+	GLUniform2f
+{
+public:
+	u_FogGradient( GLShader *shader ) :
+		GLUniform2f( shader, "u_FogGradient", PUSH )
+	{
+	}
+
+	void SetUniform_FogGradient( float density, float falloffExp )
+	{
+		vec2_t value{ density, falloffExp };
+		this->SetValue( value );
+	}
+};
+
 class u_FogColor :
 	GLUniform3f
 {
@@ -3166,7 +3182,7 @@ class GLShader_fogQuake3 :
 	public u_Bones,
 	public u_VertexInterpolation,
 	public u_ViewOrigin,
-	public u_FogDensity,
+	public u_FogGradient,
 	public u_FogDepthVector,
 	public u_FogEyeT,
 	public GLDeformStage,
@@ -3183,7 +3199,7 @@ class GLShader_fogQuake3Material :
 	public u_ModelViewProjectionMatrix,
 	public u_ColorGlobal_Uint,
 	public u_ViewOrigin,
-	public u_FogDensity,
+	public u_FogGradient,
 	public u_FogDepthVector,
 	public u_FogEyeT,
 	public GLDeformStage {

src/engine/renderer/glsl_source/fogEquation_fp.glsl

@@ -32,11 +32,35 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ===========================================================================
 */
 
-float GetFogAlpha(float s, float t)
+float FogGradientFunction(float k, float t)
 {
-	t = clamp(t, 0.0, 1.0);
+	return 1 - exp(-k * t);
+}
 
-	float x = min(1, s * t);
+float FogGradientAntiderivative(float k, float t)
+{
+	return t + exp(-k * t) / k;
+}
+
+float GetFogGradientModifier(float k, float t0, float t1)
+{
+	t0 = max(0.0, t0);
+	t1 = max(0.0, t1);
+
+	float deltaT = t1 - t0;
+	if (abs(deltaT) > 0.1)
+	{
+		return ( FogGradientAntiderivative(k, t1) - FogGradientAntiderivative(k, t0) ) / deltaT;
+	}
+	else
+	{
+		return FogGradientFunction(k, t0);
+	}
+}
+
+float GetFogAlpha(float x)
+{
+	x = clamp(x, 0.0, 1.0);
 
 	// sqrt(x) is bad near 0 because it increases too quickly resulting in sharp edges.
 	// x ≤ 1/32: √32 * x

src/engine/renderer/glsl_source/fogGlobal_fp.glsl

@@ -49,10 +49,10 @@ void	main()
 	vec4 P = u_UnprojectMatrix * vec4(gl_FragCoord.xy, depth, 1.0);
 	P.xyz /= P.w;
 
-	// calculate the length in fog (t is always 1 if eye is in fog)
+	// calculate the length in fog
 	float s = distance(u_ViewOrigin, P.xyz) * u_FogDensity;
 
-	vec4 color = vec4(1, 1, 1, GetFogAlpha(s, 1.0));
+	vec4 color = vec4(1, 1, 1, GetFogAlpha(s));
 
 	outputColor = UnpackColor( u_Color ) * color;
 }

src/engine/renderer/glsl_source/fogQuake3_fp.glsl

@@ -26,10 +26,11 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
 #define DEPTHMAP_GLSL
 
+uniform vec2 u_FogGradient;
 uniform float u_FogEyeT;
 
 IN(smooth) float var_FogPlaneDistance;
-IN(smooth) vec3 var_ScaledViewerOffset;
+IN(smooth) vec3 var_ViewerOffset;
 IN(smooth) vec4		var_Color;
 
 DECLARE_OUTPUT(vec4)
@@ -38,16 +39,22 @@ void	main()
 {
 	#insert material_fp
 
-	float s = length(var_ScaledViewerOffset);
-	float t = step( 0, var_FogPlaneDistance );
+	if ( var_FogPlaneDistance < -0.01 )
+	{
+		discard;
+	}
+
+	float distInFog = length(var_ViewerOffset);
 
 	if ( u_FogEyeT < 0 ) // eye outside fog
 	{
 		// fraction of the viewer-to-vertex ray which is inside fog
-		t *= var_FogPlaneDistance / ( max( 0, var_FogPlaneDistance ) - u_FogEyeT );
+		distInFog *= var_FogPlaneDistance / ( max( 0, var_FogPlaneDistance ) - u_FogEyeT );
 	}
 
-	vec4 color = vec4(1, 1, 1, GetFogAlpha(s, t));
+	float gradient = GetFogGradientModifier(u_FogGradient.y, u_FogEyeT, var_FogPlaneDistance);
+
+	vec4 color = vec4(1, 1, 1, GetFogAlpha(gradient * u_FogGradient.x * distInFog));
 
 	color *= var_Color;
 

src/engine/renderer/glsl_source/fogQuake3_vp.glsl

@@ -35,13 +35,12 @@ uniform mat4		u_ModelMatrix;
 uniform mat4		u_ModelViewProjectionMatrix;
 uniform vec3 u_ViewOrigin;
 
-uniform float u_FogDensity;
 uniform vec4		u_FogDepthVector; // fog plane
 
 // how far the vertex is under the fog plane
 OUT(smooth) float var_FogPlaneDistance;
 
-OUT(smooth) vec3 var_ScaledViewerOffset;
+OUT(smooth) vec3 var_ViewerOffset;
 OUT(smooth) vec4	var_Color;
 
 void DeformVertex( inout vec4 pos,
@@ -76,7 +75,7 @@ void main()
 	position = u_ModelMatrix * position;
 	position.xyz /= position.w;
 
-	var_ScaledViewerOffset = u_FogDensity * (position.xyz - u_ViewOrigin);
+	var_ViewerOffset = position.xyz - u_ViewOrigin;
 
 	// calculate the length in fog
 	var_FogPlaneDistance = dot(position.xyz, u_FogDepthVector.xyz) + u_FogDepthVector.w;

src/engine/renderer/tr_local.h

@@ -1127,6 +1127,7 @@ enum
 	{
 		Color::Color color;
 		float  depthForOpaque;
+		float falloffExp;
 	};
 
 	struct shader_t

src/engine/renderer/tr_shade.cpp

@@ -1636,7 +1636,8 @@ void Render_fog( shaderStage_t* pStage )
 	gl_fogQuake3Shader->BindProgram();
 
 	gl_fogQuake3Shader->SetUniform_ViewOrigin( backEnd.viewParms.orientation.origin );
-	gl_fogQuake3Shader->SetUniform_FogDensity( 1.0f / fog->shader->fogParms.depthForOpaque );
+	gl_fogQuake3Shader->SetUniform_FogGradient(
+		1.0f / fog->shader->fogParms.depthForOpaque, fog->shader->fogParms.falloffExp );
 	gl_fogQuake3Shader->SetUniform_FogDepthVector( fogDepthVector );
 	gl_fogQuake3Shader->SetUniform_FogEyeT( eyeT );
 

src/engine/renderer/tr_shader.cpp

@@ -4636,6 +4636,37 @@ static bool ParseShader( const char *_text )
 			SkipRestOfLine( text );
 			continue;
 		}
+		// fogGradient
+		else if ( !Q_stricmp( token, "fogGradient" ) )
+		{
+			token = COM_ParseExt2( text, false );
+
+			if ( !Q_stricmp( token, "const" ) )
+			{
+				shader.fogParms.falloffExp = 9999;
+			}
+			// fogGradient expFalloff <dist from edge at which density is 50% of max>
+			// scales density by 1 - exp(-k*t) where t is distance under fog plane
+			else if ( !Q_stricmp( token, "expFalloff" ) )
+			{
+				token = COM_ParseExt2( text, false );
+				float val = atof( token );
+
+				if ( val > 0.0f )
+				{
+					shader.fogParms.falloffExp = M_LN2 / val;
+				}
+				else
+				{
+					Log::Warn( "bad expFalloff value in shader '%s'", shader.name );
+				}
+			}
+			else
+			{
+				Log::Warn( "invalid fogGradient type '%s' in shader '%s'", token, shader.name );
+			}
+			continue;
+		}
 		// noFog
 		else if ( !Q_stricmp( token, "noFog" ) )
 		{
@@ -5991,6 +6022,11 @@ static shader_t *FinishShader()
 		shader.portalRange = r_portalDefaultRange.Get();
 	}
 
+	if ( shader.fogParms.falloffExp == 0.0f )
+	{
+		shader.fogParms.falloffExp = 9999;
+	}
+
 	numStages = MAX_SHADER_STAGES;
 	GroupActiveStages();