Taper fog density at edge with a small gradient

src/engine/renderer/GeometryOptimiser.h

@@ -87,7 +87,6 @@ void MarkShaderBuildScreen( const shaderStage_t* pStage );
 void MarkShaderBuildPortal( const shaderStage_t* pStage );
 void MarkShaderBuildHeatHaze( const shaderStage_t* pStage );
 void MarkShaderBuildLiquid( const shaderStage_t* pStage );
-void MarkShaderBuildFog( const shaderStage_t* pStage );
 
 void MarkShaderBuildIQM( const IQModel_t* model );
 void MarkShaderBuildMDV( const mdvModel_t* model );

src/engine/renderer/Material.cpp

@@ -1114,11 +1114,12 @@ 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( fog->tcScale );
+	gl_fogQuake3ShaderMaterial->SetUniform_FogGradient(
+		1.0f / fog->shader->fogParms.depthForOpaque, fog->shader->fogParms.falloffExp );
 	gl_fogQuake3ShaderMaterial->SetUniform_FogDepthVector( fogDepthVector );
 	gl_fogQuake3ShaderMaterial->SetUniform_FogEyeT( eyeT );
 
-	gl_fogQuake3ShaderMaterial->SetUniform_ColorGlobal_Uint( fog->color );
+	gl_fogQuake3ShaderMaterial->SetUniform_ColorGlobal_Uint( fog->shader->fogParms.color );
 
 	gl_fogQuake3ShaderMaterial->SetUniform_ModelMatrix( backEnd.orientation.transformMatrix );
 	gl_fogQuake3ShaderMaterial->SetUniform_ModelViewProjectionMatrix( glState.modelViewProjectionMatrix[glState.stackIndex] );

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 ) {
@@ -2733,7 +2733,6 @@ GLShader_fogGlobal::GLShader_fogGlobal() :
 
 void GLShader_fogGlobal::SetShaderProgramUniforms( ShaderProgramDescriptor *shaderProgram )
 {
-	glUniform1i( glGetUniformLocation( shaderProgram->id, "u_ColorMap" ), 0 );
 	glUniform1i( glGetUniformLocation( shaderProgram->id, "u_DepthMap" ), 1 );
 }
 

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_backend.cpp

@@ -1458,9 +1458,9 @@ void RB_RenderGlobalFog()
 
 		GL_State( GLS_DEPTHTEST_DISABLE | GLS_SRCBLEND_SRC_ALPHA | GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA );
 
-		gl_fogGlobalShader->SetUniform_FogDensity( fog->tcScale );
+		gl_fogGlobalShader->SetUniform_FogDensity( 1.0f / fog->shader->fogParms.depthForOpaque );
 		gl_fogGlobalShader->SetUniform_ViewOrigin( backEnd.viewParms.orientation.origin );
-		SetUniform_Color( gl_fogGlobalShader, fog->color );
+		SetUniform_Color( gl_fogGlobalShader, fog->shader->fogParms.color );
 	}
 
 	gl_fogGlobalShader->SetUniform_UnprojectMatrix( backEnd.viewParms.unprojectionMatrix );

src/engine/renderer/tr_bsp.cpp

@@ -3217,8 +3217,6 @@ static void R_LoadFogs( lump_t *l, lump_t *brushesLump, lump_t *sidesLump )
 	int          count, brushesCount, sidesCount;
 	int          sideNum;
 	int          planeNum;
-	shader_t     *shader;
-	float        d;
 	int          firstSide = 0;
 
 	Log::Debug("...loading fogs" );
@@ -3316,26 +3314,9 @@ static void R_LoadFogs( lump_t *l, lump_t *brushesLump, lump_t *sidesLump )
 			out->bounds[ 1 ][ 2 ] = s_worldData.planes[ planeNum ].dist;
 		}
 
-		// get information from the shader for fog parameters
 		// it says RSF_3D but if there is no shader text found it should probably just error instead
 		// of trying to create an implicit shader from an image...
-		shader = R_FindShader( fogs->shader, RSF_3D );
-
-		out->fogParms = shader->fogParms;
-
-		out->color = Color::Adapt( shader->fogParms.color );
-
-		if ( tr.worldLinearizeTexture )
-		{
-			out->color = out->color.ConvertFromSRGB();
-		}
-
-		out->color *= tr.identityLight;
-
-		out->color.SetAlpha( 1 );
-
-		d = shader->fogParms.depthForOpaque < 1 ? 1 : shader->fogParms.depthForOpaque;
-		out->tcScale = 1.0f / d;
+		out->shader = R_FindShader( fogs->shader, RSF_3D );
 
 		// ydnar: global fog sets clearcolor/zfar
 		if ( out->originalBrushNumber == -1 )

src/engine/renderer/tr_cmds.cpp

@@ -74,10 +74,6 @@ void R_PerformanceCounters()
 	{
 		Log::Notice("viewcluster: %i", tr.visClusters[ tr.visIndex ] );
 	}
-	else if ( r_speeds->integer == Util::ordinal(renderSpeeds_t::RSPEEDS_FOG ))
-	{
-		Log::Notice("fog srf:%i batches:%i", backEnd.pc.c_fogSurfaces, backEnd.pc.c_fogBatches );
-	}
 	else if ( r_speeds->integer == Util::ordinal(renderSpeeds_t::RSPEEDS_NEAR_FAR ))
 	{
 		Log::Notice("zNear: %.0f zFar: %.0f", tr.viewParms.zNear, tr.viewParms.zFar );

src/engine/renderer/tr_local.h

@@ -350,7 +350,6 @@ enum class ssaoMode {
 	  RSPEEDS_GENERAL = 1,
 	  RSPEEDS_CULLING,
 	  RSPEEDS_VIEWCLUSTER,
-	  RSPEEDS_FOG,
 	  RSPEEDS_CHC,
 	  RSPEEDS_NEAR_FAR,
 	};
@@ -1124,8 +1123,9 @@ enum
 
 	struct fogParms_t
 	{
-		vec3_t color;
+		Color::Color color;
 		float  depthForOpaque;
+		float falloffExp;
 	};
 
 	struct shader_t
@@ -1354,9 +1354,7 @@ enum
 		int        originalBrushNumber;
 		vec3_t     bounds[ 2 ];
 
-		Color::Color color; // in packed byte format
-		float      tcScale; // texture coordinate vector scales
-		fogParms_t fogParms;
+		shader_t *shader; // has the fog parms
 
 		// for clipping distance in fog when outside
 		bool hasSurface;
@@ -2122,7 +2120,6 @@ enum
 		int c_leafs;
 	};
 
-#define FOG_TABLE_SIZE  256
 #define FUNCTABLE_SIZE  1024
 #define FUNCTABLE_SIZE2 10
 #define FUNCTABLE_MASK  ( FUNCTABLE_SIZE - 1 )
@@ -2184,9 +2181,6 @@ enum
 		int   c_vboVertexes;
 		int   c_vboIndexes;
 
-		int   c_fogSurfaces;
-		int   c_fogBatches;
-
 		int   c_multiDrawElements;
 		int   c_multiDrawPrimitives;
 		int   c_multiVboIndexes;

src/engine/renderer/tr_shade.cpp

@@ -1646,12 +1646,13 @@ void Render_fog( shaderStage_t* pStage )
 	gl_fogQuake3Shader->BindProgram();
 
 	gl_fogQuake3Shader->SetUniform_ViewOrigin( backEnd.viewParms.orientation.origin );
-	gl_fogQuake3Shader->SetUniform_FogDensity( fog->tcScale );
+	gl_fogQuake3Shader->SetUniform_FogGradient(
+		1.0f / fog->shader->fogParms.depthForOpaque, fog->shader->fogParms.falloffExp );
 	gl_fogQuake3Shader->SetUniform_FogDepthVector( fogDepthVector );
 	gl_fogQuake3Shader->SetUniform_FogEyeT( eyeT );
 
 	// u_Color
-	SetUniform_ColorGlobal( gl_fogQuake3Shader, fog->color );
+	SetUniform_ColorGlobal( gl_fogQuake3Shader, fog->shader->fogParms.color );
 
 	gl_fogQuake3Shader->SetUniform_ModelMatrix( backEnd.orientation.transformMatrix );
 	gl_fogQuake3Shader->SetUniform_ModelViewProjectionMatrix( glState.modelViewProjectionMatrix[ glState.stackIndex ] );