Draw inside of fog with modified global fog shader

When the viewer is inside a fog volume, render the fog with a single
draw call instead of drawing a corresponding fog surface for every
opaque surface. The fogGlobal GLSL shader is modified to use a vertex
position so it can handle finite-sized fogs.

Before:
- Each opaque surface inside a fog volume is drawn a second time using
  the fog shader with GL_EQUAL depth test.
- The underside of the fog plane is drawn with a normal depth test, to
  cover things outside the fog when the viewer is inside.

After:
- If the viewer is inside the fog, draw all inside faces of the fog
  brush, using the depth buffer to reduce the fog distance in the case
  that something is in front of the fog boundary.
- If the viewer is outside the fog, do everything as before.

For the moment this is only used when material system is disabled.

Fixes seams at the edge of fog that appear when MSAA is enabled.

Author: slipher

src.cmake

@@ -108,7 +108,6 @@ set(GLSL_EMBED_LIST
     blur_fp.glsl
     cameraEffects_fp.glsl
     contrast_fp.glsl
-    fogGlobal_fp.glsl
     fxaa_fp.glsl
     fxaa3_11_fp.glsl
     motionblur_fp.glsl
@@ -130,6 +129,8 @@ set(GLSL_EMBED_LIST
     vertexSkinning_vp.glsl
 
     # Regular shaders
+    fogGlobal_vp.glsl
+    fogGlobal_fp.glsl
     fogQuake3_vp.glsl
     fogQuake3_fp.glsl
     generic_vp.glsl

src/engine/renderer/VertexSpecification.h

@@ -41,6 +41,9 @@ enum
 	// GPU vertex animations
 	ATTR_INDEX_POSITION2,
 	ATTR_INDEX_QTANGENT2,
+
+	ATTR_INDEX_FOG_SURFACE,
+
 	ATTR_INDEX_MAX
 };
 
@@ -53,7 +56,8 @@ static const char* const attributeNames[] =
 	"attr_Color",
 	"attr_BoneFactors",
 	"attr_Position2",
-	"attr_QTangent2"
+	"attr_QTangent2",
+	"attr_FogSurface",
 };
 
 enum
@@ -69,6 +73,8 @@ enum
   ATTR_POSITION2      = BIT( ATTR_INDEX_POSITION2 ),
   ATTR_QTANGENT2      = BIT( ATTR_INDEX_QTANGENT2 ),
 
+  ATTR_FOG_SURFACE    = BIT( ATTR_INDEX_FOG_SURFACE ),
+
   ATTR_INTERP_BITS = ATTR_POSITION2 | ATTR_QTANGENT2,
 };
 

src/engine/renderer/gl_shader.cpp

@@ -2719,15 +2719,17 @@ GLShader_fogQuake3Material::GLShader_fogQuake3Material() :
 	GLDeformStage( this ) {
 }
 
+// TODO: rename
 GLShader_fogGlobal::GLShader_fogGlobal() :
-	GLShader( "fogGlobal", ATTR_POSITION,
-		false, "screenSpace", "fogGlobal" ),
+	GLShader( "fogGlobal", ATTR_POSITION | ATTR_FOG_SURFACE,
+		false, "fogGlobal", "fogGlobal" ),
 	u_DepthMap( this ),
+	u_ModelViewProjectionMatrix( this ),
 	u_UnprojectMatrix( this ),
 	u_Color_Float( this ),
 	u_Color_Uint( this ),
 	u_ViewOrigin( this ),
-	u_FogDensity( this )
+	u_FogGradient( this )
 {
 }
 

src/engine/renderer/gl_shader.h

@@ -3210,11 +3210,12 @@ class GLShader_fogQuake3Material :
 class GLShader_fogGlobal :
 	public GLShader,
 	public u_DepthMap,
+	public u_ModelViewProjectionMatrix,
 	public u_UnprojectMatrix,
 	public u_Color_Float,
 	public u_Color_Uint,
 	public u_ViewOrigin,
-	public u_FogDensity
+	public u_FogGradient
 {
 public:
 	GLShader_fogGlobal();

src/engine/renderer/glsl_source/fogGlobal_fp.glsl

@@ -27,16 +27,20 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
 #define DEPTHMAP_GLSL
 
+IN(smooth) vec3 var_Position;
+IN(flat) vec4 var_FogSurface;
+
 uniform sampler2D	u_DepthMap;
 
 uniform colorPack u_Color;
 
 uniform vec3 u_ViewOrigin;
-uniform float u_FogDensity;
+uniform vec2 u_FogGradient;
 uniform mat4		u_UnprojectMatrix;
 
 DECLARE_OUTPUT(vec4)
 
+// This shader can be used to draw a fog volume the viewer is inside of.
 void	main()
 {
 	#insert material_fp
@@ -50,7 +54,25 @@ void	main()
 	P.xyz /= P.w;
 
 	// calculate the length in fog
-	float s = distance(u_ViewOrigin, P.xyz) * u_FogDensity;
+	float depthDist = distance(u_ViewOrigin, P.xyz);
+	float fogBoundaryDist = distance(u_ViewOrigin, var_Position);
+	vec3 endPoint;
+	float distInFog;
+	if ( depthDist < fogBoundaryDist )
+	{
+		endPoint = P.xyz;
+		distInFog = depthDist;
+	}
+	else
+	{
+		endPoint = var_Position;
+		distInFog = fogBoundaryDist;
+	}
+
+	float t0 = dot(var_FogSurface.xyz, u_ViewOrigin) + var_FogSurface.w;
+	float t1 = dot(var_FogSurface.xyz, endPoint) + var_FogSurface.w;
+
+	float s = distInFog * GetFogGradientModifier(u_FogGradient.y, t0, t1) * u_FogGradient.x;
 
 	vec4 color = vec4(1, 1, 1, GetFogAlpha(s));
 

src/engine/renderer/glsl_source/fogGlobal_vp.glsl

@@ -0,0 +1,49 @@
+/*
+===========================================================================
+
+Daemon BSD Source Code
+Copyright (c) 2026 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.
+
+===========================================================================
+*/
+
+uniform mat4 u_ModelViewProjectionMatrix;
+
+IN vec3 attr_Position;
+IN vec4 attr_FogSurface;
+
+OUT(smooth) vec3 var_Position;
+OUT(flat) vec4 var_FogSurface;
+
+void main()
+{
+	vec4 position = vec4(attr_Position, 1.0);
+	gl_Position = u_ModelViewProjectionMatrix * position;
+	var_Position = attr_Position;
+	var_FogSurface = attr_FogSurface;
+}

src/engine/renderer/tr_backend.cpp

@@ -1423,7 +1423,8 @@ void RB_RenderPostDepthLightTile()
 	GL_CheckErrors();
 }
 
-void RB_RenderGlobalFog()
+// TODO: move with other Render_ functions
+void Render_fogGlobal( shaderStage_t *stage )
 {
 	if ( backEnd.refdef.rdflags & RDF_NOWORLDMODEL )
 	{
@@ -1435,42 +1436,39 @@ void RB_RenderGlobalFog()
 		return;
 	}
 
-	if ( !tr.world || tr.world->globalFog < 0 )
-	{
-		return;
-	}
-
 	GLIMP_LOGCOMMENT( "--- RB_RenderGlobalFog ---" );
 
 	RB_PrepareForSamplingDepthMap();
 
-	GL_Cull( cullType_t::CT_TWO_SIDED );
+	GL_Cull( cullType_t::CT_FRONT_SIDED );
 
 	gl_fogGlobalShader->BindProgram();
 
-	// go back to the world modelview matrix
-	backEnd.orientation = backEnd.viewParms.world;
-
 	{
-		fog_t* fog = &tr.world->fogs[ tr.world->globalFog ];
-
-		GLIMP_LOGCOMMENT( "--- RB_RenderGlobalFog( fogNum = %i ) ---", tr.world->globalFog );
+		GL_State( stage->stateBits );
 
-		GL_State( GLS_DEPTHTEST_DISABLE | GLS_SRCBLEND_SRC_ALPHA | GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA );
-
-		gl_fogGlobalShader->SetUniform_FogDensity( 1.0f / fog->shader->fogParms.depthForOpaque );
+		gl_fogGlobalShader->SetUniform_FogGradient(
+			1.0f / stage->shader->fogParms.depthForOpaque, stage->shader->fogParms.falloffExp );
 		gl_fogGlobalShader->SetUniform_ViewOrigin( backEnd.viewParms.orientation.origin );
-		SetUniform_Color( gl_fogGlobalShader, fog->shader->fogParms.color );
+		SetUniform_Color( gl_fogGlobalShader, stage->shader->fogParms.color );
 	}
 
+	// It's important to avoid far plane clipping
+	matrix_t projection, mvp;
+	MatrixPerspectiveProjectionFovXYInfiniteRH( projection, tr.refdef.fov_x, tr.refdef.fov_y, 1.0f );
+	MatrixMultiply( projection, glState.modelViewMatrix[ glState.stackIndex ], mvp );
+
+	gl_fogGlobalShader->SetUniform_ModelViewProjectionMatrix( mvp );
 	gl_fogGlobalShader->SetUniform_UnprojectMatrix( backEnd.viewParms.unprojectionMatrix );
 
 	// bind u_DepthMap
 	gl_fogGlobalShader->SetUniform_DepthMapBindless(
 		GL_BindToTMU( 1, tr.depthSamplerImage )
 	);
 
-	Tess_InstantScreenSpaceQuad();
+	gl_fogGlobalShader->SetRequiredVertexPointers();
+
+	Tess_DrawElements();
 
 	GL_CheckErrors();
 }
@@ -2801,9 +2799,6 @@ static void RB_RenderView( bool depthPass )
 
 	RB_RenderSSAO();
 
-	// render global fog post process effect
-	RB_RenderGlobalFog();
-
 	TransitionMainToMSAA( GL_COLOR_BUFFER_BIT );
 
 	// draw everything that is translucent

src/engine/renderer/tr_bsp.cpp

@@ -3262,6 +3262,14 @@ static void R_LoadFogs( lump_t *l, lump_t *brushesLump, lump_t *sidesLump )
 
 	sidesCount = sidesLump->filelen / sizeof( *sides );
 
+	struct FogVert
+	{
+		float position[ 3 ];
+		vec4_t surface;
+	};
+	std::vector<FogVert> fogVerts(8 * count);
+	std::vector<glIndex_t> fogIndexes(36 * count);
+
 	for ( i = 0; i < count; i++, fogs++ )
 	{
 		out->originalBrushNumber = LittleLong( fogs->brushNum );
@@ -3331,6 +3339,7 @@ static void R_LoadFogs( lump_t *l, lump_t *brushesLump, lump_t *sidesLump )
 		if ( sideNum < 0 || sideNum >= sidesCount )
 		{
 			out->hasSurface = false;
+			Vector4Set( out->surface, 0.0f, 0.0f, 0.0f, -1.0e10f );
 		}
 		else
 		{
@@ -3340,9 +3349,47 @@ static void R_LoadFogs( lump_t *l, lump_t *brushesLump, lump_t *sidesLump )
 			out->surface[ 3 ] = -s_worldData.planes[ planeNum ].dist;
 		}
 
+		// add faces of fog brush for drawing fog from inside
+		for ( int p = 0; p < 8; p++ )
+		{
+			fogVerts[ i * 8 + p ].position[ 0 ] = out->bounds[ p & 1 ][ 0 ];
+			fogVerts[ i * 8 + p ].position[ 1 ] = out->bounds[ ( p >> 1 ) & 1 ][ 1 ];
+			fogVerts[ i * 8 + p ].position[ 2 ] = out->bounds[ p >> 2 ][ 2 ];
+
+			VectorCopy( out->surface, fogVerts[ i * 8 + p ].surface );
+			fogVerts[ i * 8 + p ].surface[ 3 ] = -out->surface[ 3 ];
+		}
+
+		constexpr int box[ 36 ] = { 2, 3, 0, 0, 3, 1, 0, 1, 4, 4, 1, 5, 2, 0, 6, 6, 0, 4,
+		                            1, 3, 5, 5, 3, 7, 3, 2, 7, 7, 2, 6, 7, 6, 5, 5, 6, 4 };
+		for ( int p = 0; p < 36; p++ )
+		{
+			fogIndexes[ 36 * i + p ] = 8 * i + box[ p ];
+		}
+
+		// add draw surf for fog brush faces
+		out->surf.firstIndex = 36 * i;
+		out->surf.numTriangles = 12;
+		out->surf.surfaceType = surfaceType_t::SF_TRIANGLES;
+
 		out++;
 	}
 
+	vertexAttributeSpec_t attributes[] {
+		{ ATTR_INDEX_POSITION, GL_FLOAT, GL_FLOAT, &fogVerts[ 0 ].position, 3, sizeof( fogVerts[ 0 ] ), 0 },
+		{ ATTR_INDEX_FOG_SURFACE, GL_FLOAT, GL_FLOAT, &fogVerts[ 0 ].surface, 4, sizeof( fogVerts[ 0 ] ), 0 },
+	};
+	VBO_t *fogVBO = R_CreateStaticVBO(
+		"fogs VBO", std::begin( attributes ), std::end( attributes ), fogVerts.size() );
+	IBO_t *fogIBO = R_CreateStaticIBO( "fogs IBO", &fogIndexes[ 0 ], fogIndexes.size() );
+	SetupVAOBuffers( fogVBO, fogIBO, ATTR_POSITION | ATTR_FOG_SURFACE, &fogVBO->VAO );
+
+	for ( int j = 1; j < s_worldData.numFogs; j++ )
+	{
+		s_worldData.fogs[ j ].surf.vbo = fogVBO;
+		s_worldData.fogs[ j ].surf.ibo = fogIBO;
+	}
+
 	Log::Debug("%i fog volumes loaded", s_worldData.numFogs );
 }
 

src/engine/renderer/tr_init.cpp

@@ -1541,6 +1541,8 @@ ScreenshotCmd screenshotPNGRegistration("screenshotPNG", ssFormat_t::SSF_PNG, "p
 					gl_fogQuake3Shader->SetDeform( 0 );
 					gl_fogQuake3Shader->MarkProgramForBuilding();
 				}
+
+				gl_fogGlobalShader->MarkProgramForBuilding();
 			}
 
 			for ( int i = 0; i < tr.numModels; i++ ) {