Use a piecewise function for distance -> fog alpha

The original Quake 3 fog code in principle used the equation alpha =
sqrt(density * distance in fog). But the values were looked up in an
image that had a resolution that for small distances was way too low to
approximate the function well. Actually using sqrt at the low range is
bad because sqrt has an infinite at zero. Use a linear ramp for the
first bit which prevents hard edges caused by using pure sqrt and gives
a similar result to the old code.

This fixes color banding caused by the discrete fog texture. Also, it
makes the thickness of the fog appear the same regardless of how far you
are away from it.

Author: slipher

src/engine/renderer/glsl_source/fogEquation_fp.glsl

@@ -1,77 +1,45 @@
 /*
 ===========================================================================
-Copyright (C) 1999-2005 Id Software, Inc.
-Copyright (C) 2006-2011 Robert Beckebans <trebor_7@users.sourceforge.net>
 
-This file is part of Daemon source code.
+Daemon BSD Source Code
+Copyright (c) 2025 Daemon Developers
+All rights reserved.
+
+This file is part of the Daemon BSD Source Code (Daemon Source Code).
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+	* Redistributions of source code must retain the above copyright
+	  notice, this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+	  notice, this list of conditions and the following disclaimer in the
+	  documentation and/or other materials provided with the distribution.
+	* Neither the name of the Daemon developers nor the
+	  names of its contributors may be used to endorse or promote products
+	  derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL DAEMON DEVELOPERS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-Daemon source code is free software; you can redistribute it
-and/or modify it under the terms of the GNU General Public License as
-published by the Free Software Foundation; either version 2 of the License,
-or (at your option) any later version.
-
-Daemon source code is distributed in the hope that it will be
-useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with Daemon source code; if not, write to the Free Software
-Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 ===========================================================================
 */
 
-float FogTable(float s)
-{
-	return sqrt(floor(s * 255.0) / 255);
-}
-
-float FogFactor(float s, float t)
-{
-	s -= 1.0f / 512.0f;
-
-	if ( s < 0 )
-	{
-		return 0;
-	}
-
-	if ( t < 1.0f / 32.0f )
-	{
-		return 0;
-	}
-
-	if ( t < 31.0f / 32.0f )
-	{
-		s *= ( t - 1.0f / 32.0f ) / ( 30.0f / 32.0f );
-	}
-
-	s *= 8;
-
-	if ( s > 1.0f )
-	{
-		s = 1.0f;
-	}
-
-	return FogTable(s);
-}
-
 float GetFogAlpha(float s, float t)
 {
-	float sfloor = floor(s * 256 + 0.5) - 0.5;
-	float sceil = sfloor + 1;
-	sfloor = clamp(sfloor, 0.5, 255.5) / 256;
-	sceil = clamp(sceil, 0.5, 255.5) / 256;
-	float smix = sfloor < sceil ? (s - sfloor) * 256 : 0.5;
+	t = clamp(t, 0.0, 1.0);
 
-	float tfloor = floor(t * 32 + 0.5) - 0.5;
-	float tceil = tfloor + 1;
-	tfloor = clamp(tfloor, 0.5, 31.5) / 32;
-	tceil = clamp(tceil, 0.5, 31.5) / 32;
-	float tmix = tfloor < tceil ? (t - tfloor) * 32 : 0.5;
+	float x = min(1, s * t);
 
-	float f00 = FogFactor(sfloor, tfloor);
-	float f01 = FogFactor(sfloor, tceil);
-	float f10 = FogFactor(sceil, tfloor);
-	float f11 = FogFactor(sceil, tceil);
-	return mix(mix(f00, f01, tmix), mix(f10, f11, tmix), smix);
+	// sqrt(x) is bad near 0 because it increases too quickly resulting in sharp edges.
+	// x ≤ 1/32: √32 * x
+	// x ≥ 1/32: √x
+	return min(sqrt(32.0) * x, sqrt(x));
 }

src/engine/renderer/glsl_source/fogQuake3_fp.glsl

@@ -39,9 +39,6 @@ void	main()
 	#insert material_fp
 
 	float s = length(var_ScaledViewerOffset);
-
-	s += 1.0 / 512.0;
-
 	float t = step( 0, var_FogPlaneDistance );
 
 	if ( u_FogEyeT < 0 ) // eye outside fog
@@ -50,8 +47,6 @@ void	main()
 		t *= var_FogPlaneDistance / ( max( 0, var_FogPlaneDistance ) - u_FogEyeT );
 	}
 
-	t = 1.0 / 32.0 + ( 30.0 / 32.0 ) * t;
-
 	vec4 color = vec4(1, 1, 1, GetFogAlpha(s, t));
 
 	color *= var_Color;

src/engine/renderer/glsl_source/fogQuake3_vp.glsl

@@ -79,16 +79,7 @@ void main()
 	var_ScaledViewerOffset = u_FogDensity * (position.xyz - u_ViewOrigin);
 
 	// calculate the length in fog
-	float t = dot(position.xyz, u_FogDepthVector.xyz) + u_FogDepthVector.w;
-
-	// HACK: increase cutoff to avoid dark lines at the edge of BSP triangles that stop
-	// right at the fog plane (when viewed from under fog)
-	// But don't do it for models as this causes a doubly-fogged light band at the fog plane
-	#if !defined(USE_VERTEX_ANIMATION) && !defined(USE_VERTEX_SKINNING)
-		t += 1.5;
-	#endif
-
-	var_FogPlaneDistance = t;
+	var_FogPlaneDistance = dot(position.xyz, u_FogDepthVector.xyz) + u_FogDepthVector.w;
 
 	var_Color = color;
 }

src/engine/renderer/tr_bsp.cpp

@@ -3335,7 +3335,7 @@ static void R_LoadFogs( lump_t *l, lump_t *brushesLump, lump_t *sidesLump )
 		out->color.SetAlpha( 1 );
 
 		d = shader->fogParms.depthForOpaque < 1 ? 1 : shader->fogParms.depthForOpaque;
-		out->tcScale = 1.0f / ( d * 8 );
+		out->tcScale = 1.0f / d;
 
 		// ydnar: global fog sets clearcolor/zfar
 		if ( out->originalBrushNumber == -1 )