Use new depth-based fog shaders in material system

Use the depth-based fog shaders (currently called "fogGlobal") when the
material system is enabled as well. For now they are always run with the
'core' rendering loop.

NUKE the fogQuake3 shader and all the code for propagating fog nums with
surfaces.

Fixes #1798 (marks drawn over fog with material system) by virtue of not
drawing fogs with the material system.

Also brings improvements described for the core renderer in previous
commits:
- MSAA works with fog without artifacts
- Fog volumes can be open on any side

Author: slipher

src.cmake

@@ -131,8 +131,6 @@ set(GLSL_EMBED_LIST
     # Regular shaders
     fogGlobal_vp.glsl
     fogGlobal_fp.glsl
-    fogQuake3_vp.glsl
-    fogQuake3_fp.glsl
     generic_vp.glsl
     generic_fp.glsl
     heatHaze_vp.glsl

src/engine/renderer/GeometryOptimiser.cpp

@@ -54,12 +54,6 @@ static int LeafSurfaceCompare( const void* a, const void* b ) {
 		return 1;
 	}
 
-	if ( aa->fogIndex < bb->fogIndex ) {
-		return -1;
-	} else if ( aa->fogIndex > bb->fogIndex ) {
-		return 1;
-	}
-
 	// sort by leaf
 	if ( aa->scratch2 < bb->scratch2 ) {
 		return -1;
@@ -168,7 +162,6 @@ void OptimiseMapGeometryCore( world_t* world, bspSurface_t** rendererSurfaces, i
 
 			shader_t* shader1 = surf1->shader;
 
-			int fogIndex1 = surf1->fogIndex;
 			int lightMapNum1 = surf1->lightmapNum;
 			surf1->viewCount = surf1 - world->surfaces;
 			surf1->scratch1 = j;
@@ -187,9 +180,8 @@ void OptimiseMapGeometryCore( world_t* world, bspSurface_t** rendererSurfaces, i
 				}
 
 				shader_t* shader2 = surf2->shader;
-				int fogIndex2 = surf2->fogIndex;
 				int lightMapNum2 = surf2->lightmapNum;
-				if ( shader1 != shader2 || fogIndex1 != fogIndex2 || lightMapNum1 != lightMapNum2 ) {
+				if ( shader1 != shader2 || lightMapNum1 != lightMapNum2 ) {
 					continue;
 				}
 
@@ -315,7 +307,6 @@ void MergeLeafSurfacesCore( world_t* world, bspSurface_t** rendererSurfaces, int
 		SphereFromBounds( vboSurf->bounds[0], vboSurf->bounds[1], vboSurf->origin, &vboSurf->radius );
 
 		mergedSurf->data = ( surfaceType_t* ) vboSurf;
-		mergedSurf->fogIndex = surf1->fogIndex;
 		mergedSurf->shader = surf1->shader;
 		mergedSurf->lightmapNum = surf1->lightmapNum;
 		mergedSurf->viewCount = -1;
@@ -557,7 +548,6 @@ std::vector<MaterialSurface> OptimiseMapGeometryMaterial( world_t* world, bspSur
 		srf.skyBrush = surface->skyBrush;
 
 		srf.lightMapNum = surface->lightmapNum;
-		srf.fog = surface->fogIndex;
 		srf.portalNum = surface->portalNum;
 
 		srf.firstIndex = ( ( srfGeneric_t* ) surface->data )->firstIndex;
@@ -568,7 +558,7 @@ std::vector<MaterialSurface> OptimiseMapGeometryMaterial( world_t* world, bspSur
 		VectorCopy( ( ( srfGeneric_t* ) surface->data )->origin, srf.origin );
 		srf.radius = ( ( srfGeneric_t* ) surface->data )->radius;
 
-		materialSystem.GenerateMaterial( &srf, world->globalFog );
+		materialSystem.GenerateMaterial( &srf );
 
 		static const float MAX_NORMAL_SURFACE_DISTANCE = 65536.0f * sqrtf( 2.0f );
 		if ( VectorLength( ( ( srfGeneric_t* ) surface->data )->bounds[0] ) > MAX_NORMAL_SURFACE_DISTANCE

src/engine/renderer/Material.cpp

@@ -334,14 +334,6 @@ void UpdateSurfaceDataLiquid( uint32_t* materials, shaderStage_t* pStage, bool,
 	gl_liquidShaderMaterial->WriteUniformsToBuffer( materials, GLShader::MATERIAL );
 }
 
-void UpdateSurfaceDataFog( uint32_t* materials, shaderStage_t* pStage, bool, bool, bool ) {
-	// shader_t* shader = pStage->shader;
-
-	materials += pStage->bufferOffset;
-
-	gl_fogQuake3ShaderMaterial->WriteUniformsToBuffer( materials, GLShader::MATERIAL );
-}
-
 /*
 * Buffer layout:
 * // Static surfaces data:
@@ -746,10 +738,10 @@ class ListMaterialsCmd : public Cmd::StaticCmd {
 			       shaderSortName.at( materialPack.fromSort ), shaderSortName.at( materialPack.toSort ) );
 			for ( const Material& material : materialPack.materials ) {
 				Print( "id: %u, sync: %5s, stateBits: %10x, GLShader: %s, GLProgramID: %u,"
-				       " deform: %i, fog: %i, drawCmdCount: %u",
+				       " deform: %i, drawCmdCount: %u",
 				       material.id, material.useSync, material.stateBits,
 				       material.shader->_name, material.program,
-				       material.deformIndex, material.fog, material.drawCommandCount );
+				       material.deformIndex, material.drawCommandCount );
 			}
 		}
 	}
@@ -762,7 +754,6 @@ static std::string GetStageInfo( const shaderStage_t* pStage, const uint32_t dyn
 		{ BindShaderGeneric3D,    "genericMaterial     " },
 		{ BindShaderLightMapping, "lightMappingMaterial" },
 		{ BindShaderHeatHaze,     "heatHazeMaterial    " },
-		{ BindShaderFog,          "fogQuake3Material   " },
 		{ BindShaderLiquid,       "liquidMaterial      " },
 		{ BindShaderScreen,       "screenMaterial      " },
 		{ BindShaderSkybox,       "skyboxMaterial      " },
@@ -1090,43 +1081,6 @@ void BindShaderLiquid( Material* material ) {
 	gl_liquidShaderMaterial->SetUniform_PortalMapBindless( GL_BindToTMU( 1, tr.portalRenderImage ) );
 }
 
-void BindShaderFog( Material* material ) {
-	// Bind shader program.
-	gl_fogQuake3ShaderMaterial->SetDeform( material->deformIndex );
-	gl_fogQuake3ShaderMaterial->BindProgram();
-
-	// Set shader uniforms.
-	const fog_t* fog = tr.world->fogs + material->fog;
-
-	// rotate the gradient vector for this orientation
-	float eyeT;
-	vec4_t fogDepthVector;
-	if ( fog->hasSurface ) {
-		VectorCopy( fog->surface, fogDepthVector );
-		fogDepthVector[ 3 ] = -fog->surface[ 3 ];
-		eyeT = DotProduct( backEnd.viewParms.orientation.origin, fogDepthVector ) + fogDepthVector[ 3 ];
-	} else {
-		Vector4Set( fogDepthVector, 0, 0, 0, 1 );
-		eyeT = 1; // non-surface fog always has eye inside
-	}
-
-	// Note: things that seemingly should be per-shader or per-surface can be set as global uniforms
-	// 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_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->shader->fogParms.color );
-
-	gl_fogQuake3ShaderMaterial->SetUniform_ModelMatrix( backEnd.orientation.transformMatrix );
-	gl_fogQuake3ShaderMaterial->SetUniform_ModelViewProjectionMatrix( glState.modelViewProjectionMatrix[glState.stackIndex] );
-
-	gl_fogQuake3ShaderMaterial->SetUniform_Time( backEnd.refdef.floatTime - backEnd.currentEntity->e.shaderTime );
-}
-
 void ProcessMaterialNONE( Material*, shaderStage_t*, MaterialSurface* ) {
 	ASSERT_UNREACHABLE();
 }
@@ -1264,15 +1218,6 @@ void ProcessMaterialLiquid( Material* material, shaderStage_t* pStage, MaterialS
 	material->program = gl_liquidShaderMaterial->GetProgram( materialSystem.buildOneShader );
 }
 
-void ProcessMaterialFog( Material* material, shaderStage_t* pStage, MaterialSurface* surface ) {
-	material->shader = gl_fogQuake3ShaderMaterial;
-	material->fog = surface->fog;
-
-	gl_fogQuake3ShaderMaterial->SetDeform( pStage->deformIndex );
-
-	material->program = gl_fogQuake3ShaderMaterial->GetProgram( materialSystem.buildOneShader );
-}
-
 void MaterialSystem::AddStage( MaterialSurface* surface, shaderStage_t* pStage, uint32_t stage,
 	const bool mayUseVertexOverbright, const bool vertexLit, const bool fullbright ) {
 	const int variant = ( mayUseVertexOverbright ? ShaderStageVariant::VERTEX_OVERBRIGHT : 0 )
@@ -1496,7 +1441,7 @@ void MaterialSystem::ProcessStage( MaterialSurface* surface, shaderStage_t* pSta
 /* This will only generate a material itself
 A material represents a distinct global OpenGL state (e. g. blend function, depth test, depth write etc.)
 Materials can have a dependency on other materials to make sure that consecutive stages are rendered in the proper order */
-void MaterialSystem::GenerateMaterial( MaterialSurface* surface, int globalFog ) {
+void MaterialSystem::GenerateMaterial( MaterialSurface* surface ) {
 	uint32_t stage = 0;
 	uint32_t previousMaterialID = 0;
 
@@ -1516,13 +1461,6 @@ void MaterialSystem::GenerateMaterial( MaterialSurface* surface, int globalFog )
 
 		surface->stages++;
 	}
-
-	if ( !surface->shader->noFog && surface->fog >= 1 && surface->fog != globalFog ) {
-		uint32_t unused;
-		ProcessStage( surface, surface->shader->fogShader->stages, surface->shader->fogShader, packIDs, stage, unused, true );
-
-		surface->stages++;
-	}
 }
 
 void MaterialSystem::SetWorldBounds( vec3_t bounds[2] ) {
@@ -1918,7 +1856,6 @@ bool MaterialSystem::AddPortalSurface( uint32_t viewID, PortalSurface* portalSur
 		{
 			drawSurf.bspSurface = portalSurfaces[portalSurface->drawSurfID].bspSurface;
 			drawSurf.entity = &tr.worldEntity;
-			drawSurf.fog = portalSurfaces[portalSurface->drawSurfID].fog;
 			drawSurf.portalNum = portalSurfaces[portalSurface->drawSurfID].portalNum;
 			drawSurf.shader = portalSurfaces[portalSurface->drawSurfID].shader;
 			drawSurf.surface = portalSurfaces[portalSurface->drawSurfID].surface;
@@ -1994,7 +1931,7 @@ void MaterialSystem::AddAutospriteSurfaces() {
 	for ( const bspSurface_t* surface : autospriteSurfaces )
 	{
 		R_AddDrawSurf( surface->data, surface->shader,
-		               surface->lightmapNum, surface->fogIndex, true );
+		               surface->lightmapNum, true );
 	}
 }
 
@@ -2046,7 +1983,7 @@ void MaterialSystem::RenderMaterials( const shaderSort_t fromSort, const shaderS
 			}
 
 			tr.drawingSky = true;
-			Tess_Begin( Tess_StageIteratorSky, skyShader, false, -1, 0, false );
+			Tess_Begin( Tess_StageIteratorSky, skyShader, false, -1, false );
 			Tess_End();
 		}
 	}
@@ -2096,12 +2033,6 @@ void MaterialSystem::RenderMaterial( Material& material, const uint32_t viewID )
 		stateBits &= ~( GLS_SRCBLEND_BITS | GLS_DSTBLEND_BITS );
 	}
 
-	if( material.shaderBinder == BindShaderFog ) {
-		if ( r_noFog->integer || ( backEnd.refdef.rdflags & RDF_NOWORLDMODEL ) ) {
-			return;
-		}
-	}
-
 	backEnd.currentEntity = &tr.worldEntity;
 
 	GL_State( stateBits );

src/engine/renderer/Material.h

@@ -85,7 +85,6 @@ struct MaterialSurface {
 	bool skyBrush;
 
 	int16_t lightMapNum;
-	int fog;
 	int portalNum = -1;
 
 	GLuint firstIndex;
@@ -148,15 +147,13 @@ struct Material {
 
 	bool usePolygonOffset = false;
 
-	int fog = 0;
-
 	uint32_t drawCommandCount = 0;
 	bool texturesResident = false;
 	std::vector<Texture*> textures;
 
 	bool operator==( const Material& other ) {
 		return program == other.program && stateBits == other.stateBits
-			&& fog == other.fog && cullType == other.cullType && usePolygonOffset == other.usePolygonOffset;
+			&& cullType == other.cullType && usePolygonOffset == other.usePolygonOffset;
 	}
 
 	void AddTexture( Texture* texture ) {
@@ -381,7 +378,7 @@ class MaterialSystem {
 		const bool mayUseVertexOverbright, const bool vertexLit, const bool fullbright );
 	void ProcessStage( MaterialSurface* surface, shaderStage_t* pStage, shader_t* shader, uint32_t* packIDs, uint32_t& stage,
 		uint32_t& previousMaterialID, bool skipStageSync = false );
-	void GenerateMaterial( MaterialSurface* surface, int globalFog );
+	void GenerateMaterial( MaterialSurface* surface );
 	void GenerateWorldMaterialsBuffer();
 	void GenerateWorldCommandBuffer( std::vector<MaterialSurface>& surfaces );
 	void GeneratePortalBoundingSpheres();
@@ -462,7 +459,6 @@ void UpdateSurfaceDataSkybox( uint32_t* materials, shaderStage_t* pStage, bool,
 void UpdateSurfaceDataScreen( uint32_t* materials, shaderStage_t* pStage, bool, bool, bool );
 void UpdateSurfaceDataHeatHaze( uint32_t* materials, shaderStage_t* pStage, bool, bool, bool );
 void UpdateSurfaceDataLiquid( uint32_t* materials, shaderStage_t* pStage, bool, bool, bool );
-void UpdateSurfaceDataFog( uint32_t* materials, shaderStage_t* pStage, bool, bool, bool );
 
 void BindShaderNONE( Material* );
 void BindShaderNOP( Material* );
@@ -473,7 +469,6 @@ void BindShaderSkybox( Material* material );
 void BindShaderScreen( Material* material );
 void BindShaderHeatHaze( Material* material );
 void BindShaderLiquid( Material* material );
-void BindShaderFog( Material* material );
 
 void ProcessMaterialNONE( Material*, shaderStage_t*, MaterialSurface* );
 void ProcessMaterialNOP( Material*, shaderStage_t*, MaterialSurface* );
@@ -484,6 +479,5 @@ void ProcessMaterialSkybox( Material* material, shaderStage_t* pStage, MaterialS
 void ProcessMaterialScreen( Material* material, shaderStage_t* pStage, MaterialSurface* /* surface */ );
 void ProcessMaterialHeatHaze( Material* material, shaderStage_t* pStage, MaterialSurface* surface );
 void ProcessMaterialLiquid( Material* material, shaderStage_t* pStage, MaterialSurface* /* surface */ );
-void ProcessMaterialFog( Material* material, shaderStage_t* pStage, MaterialSurface* surface );
 
 #endif // MATERIAL_H

src/engine/renderer/gl_shader.cpp

@@ -68,8 +68,6 @@ GLShader_generic                         *gl_genericShader = nullptr;
 GLShader_genericMaterial                 *gl_genericShaderMaterial = nullptr;
 GLShader_lightMapping                    *gl_lightMappingShader = nullptr;
 GLShader_lightMappingMaterial            *gl_lightMappingShaderMaterial = nullptr;
-GLShader_fogQuake3                       *gl_fogQuake3Shader = nullptr;
-GLShader_fogQuake3Material               *gl_fogQuake3ShaderMaterial = nullptr;
 GLShader_heatHaze                        *gl_heatHazeShader = nullptr;
 GLShader_heatHazeMaterial                *gl_heatHazeShaderMaterial = nullptr;
 GLShader_liquid                          *gl_liquidShader = nullptr;
@@ -2690,38 +2688,6 @@ GLShader_skyboxMaterial::GLShader_skyboxMaterial() :
 	u_ModelViewProjectionMatrix( this )
 {}
 
-GLShader_fogQuake3::GLShader_fogQuake3() :
-	GLShader( "fogQuake3", ATTR_POSITION | ATTR_QTANGENT,
-		false, "fogQuake3", "fogQuake3" ),
-	u_ModelMatrix( this ),
-	u_ModelViewProjectionMatrix( this ),
-	u_ColorGlobal_Float( this ),
-	u_ColorGlobal_Uint( this ),
-	u_Bones( this ),
-	u_VertexInterpolation( this ),
-	u_ViewOrigin( this ),
-	u_FogGradient( this ),
-	u_FogDepthVector( this ),
-	u_FogEyeT( this ),
-	GLDeformStage( this ),
-	GLCompileMacro_USE_VERTEX_SKINNING( this ),
-	GLCompileMacro_USE_VERTEX_ANIMATION( this )
-{
-}
-
-GLShader_fogQuake3Material::GLShader_fogQuake3Material() :
-	GLShader( "fogQuake3Material", ATTR_POSITION | ATTR_QTANGENT,
-		true, "fogQuake3", "fogQuake3" ),
-	u_ModelMatrix( this ),
-	u_ModelViewProjectionMatrix( this ),
-	u_ColorGlobal_Uint( this ),
-	u_ViewOrigin( this ),
-	u_FogGradient( this ),
-	u_FogDepthVector( this ),
-	u_FogEyeT( this ),
-	GLDeformStage( this ) {
-}
-
 // TODO: rename
 GLShader_fogGlobal::GLShader_fogGlobal() :
 	GLShader( "fogGlobal", ATTR_POSITION | ATTR_FOG_SURFACE,