Merge branch 'master' into for-0.56.0/sync

Author: illwieckz

src/engine/renderer/GeometryOptimiser.cpp

@@ -570,7 +570,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 );
+		materialSystem.GenerateMaterial( &srf, world->globalFog );
 
 		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

@@ -1091,12 +1091,8 @@ void BindShaderFog( Material* material ) {
 
 	// all fogging distance is based on world Z units
 	vec4_t fogDistanceVector;
-	vec3_t local;
-	VectorSubtract( backEnd.orientation.origin, backEnd.viewParms.orientation.origin, local );
-	fogDistanceVector[0] = -backEnd.orientation.modelViewMatrix[2];
-	fogDistanceVector[1] = -backEnd.orientation.modelViewMatrix[6];
-	fogDistanceVector[2] = -backEnd.orientation.modelViewMatrix[10];
-	fogDistanceVector[3] = DotProduct( local, backEnd.viewParms.orientation.axis[0] );
+	VectorCopy( backEnd.viewParms.orientation.axis[ 0 ], fogDistanceVector );
+	fogDistanceVector[ 3 ] = -DotProduct( fogDistanceVector, backEnd.viewParms.orientation.origin );
 
 	// scale the fog vectors based on the fog's thickness
 	VectorScale( fogDistanceVector, fog->tcScale, fogDistanceVector );
@@ -1106,15 +1102,9 @@ void BindShaderFog( Material* material ) {
 	float eyeT;
 	vec4_t fogDepthVector;
 	if ( fog->hasSurface ) {
-		fogDepthVector[0] = fog->surface[0] * backEnd.orientation.axis[0][0] +
-			fog->surface[1] * backEnd.orientation.axis[0][1] + fog->surface[2] * backEnd.orientation.axis[0][2];
-		fogDepthVector[1] = fog->surface[0] * backEnd.orientation.axis[1][0] +
-			fog->surface[1] * backEnd.orientation.axis[1][1] + fog->surface[2] * backEnd.orientation.axis[1][2];
-		fogDepthVector[2] = fog->surface[0] * backEnd.orientation.axis[2][0] +
-			fog->surface[1] * backEnd.orientation.axis[2][1] + fog->surface[2] * backEnd.orientation.axis[2][2];
-		fogDepthVector[3] = -fog->surface[3] + DotProduct( backEnd.orientation.origin, fog->surface );
-
-		eyeT = DotProduct( backEnd.orientation.viewOrigin, fogDepthVector ) + fogDepthVector[3];
+		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
@@ -1487,7 +1477,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 ) {
+void MaterialSystem::GenerateMaterial( MaterialSurface* surface, int globalFog ) {
 	uint32_t stage = 0;
 	uint32_t previousMaterialID = 0;
 
@@ -1508,7 +1498,7 @@ void MaterialSystem::GenerateMaterial( MaterialSurface* surface ) {
 		surface->stages++;
 	}
 
-	if ( !surface->shader->noFog && surface->fog >= 1 ) {
+	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 );
 
@@ -2010,6 +2000,11 @@ void MaterialSystem::RenderMaterials( const shaderSort_t fromSort, const shaderS
 		}
 	}
 
+	// All material packs currently render depth-writing shaders.
+	// If we were to render depth fade or anything else sampling u_DepthMap with the material system,
+	// we would need to track this on a per-material basis.
+	backEnd.dirtyDepthBuffer = true;
+
 	GL_BindVAO( backEnd.defaultVAO );
 
 	// Draw the skybox here because we skipped R_AddWorldSurfaces()

src/engine/renderer/Material.h

@@ -379,7 +379,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 );
+	void GenerateMaterial( MaterialSurface* surface, int globalFog );
 	void GenerateWorldMaterialsBuffer();
 	void GenerateWorldCommandBuffer( std::vector<MaterialSurface>& surfaces );
 	void GeneratePortalBoundingSpheres();

src/engine/renderer/gl_shader.cpp

@@ -2139,7 +2139,7 @@ void GLShader::PostProcessUniforms() {
 		auto iterNext = FindUniformForOffset( uniformQueue, std140Size );
 		if ( iterNext == uniformQueue.end() ) {
 			// add 1 unit of padding
-			ASSERT( !( *iterNext )->_components ); // array WriteToBuffer impls don't handle padding correctly
+			ASSERT( !_materialSystemUniforms.back()->_components); // array WriteToBuffer impls don't handle padding correctly
 			++std140Size;
 			++_materialSystemUniforms.back()->_std430Size;
 		} else {
@@ -2639,7 +2639,8 @@ GLShader_fogGlobal::GLShader_fogGlobal() :
 	u_UnprojectMatrix( this ),
 	u_Color_Float( this ),
 	u_Color_Uint( this ),
-	u_FogDistanceVector( this )
+	u_ViewOrigin( this ),
+	u_FogDensity( this )
 {
 }
 

src/engine/renderer/gl_shader.h

@@ -3481,7 +3481,8 @@ class GLShader_fogGlobal :
 	public u_UnprojectMatrix,
 	public u_Color_Float,
 	public u_Color_Uint,
-	public u_FogDistanceVector
+	public u_ViewOrigin,
+	public u_FogDensity
 {
 public:
 	GLShader_fogGlobal();

src/engine/renderer/glsl_source/fogGlobal_fp.glsl

@@ -29,14 +29,11 @@ uniform sampler2D	u_DepthMap;
 
 uniform colorPack u_Color;
 
-uniform vec4		u_FogDistanceVector;
+uniform vec3 u_ViewOrigin;
+uniform float u_FogDensity;
 uniform mat4		u_UnprojectMatrix;
 
-#if __VERSION__ > 120
-out vec4 outputColor;
-#else
-#define outputColor gl_FragColor
-#endif
+DECLARE_OUTPUT(vec4)
 
 void	main()
 {
@@ -48,9 +45,8 @@ 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 0 if eye is in fog)
-	st.s = dot(P.xyz, u_FogDistanceVector.xyz) + u_FogDistanceVector.w;
-	// st.s = vertexDistanceToCamera;
+	// calculate the length in fog (t is always 1 if eye is in fog)
+	st.s = distance(u_ViewOrigin, P.xyz) * u_FogDensity;
 	st.t = 1.0;
 
 	vec4 color = texture2D(u_ColorMap, st);

src/engine/renderer/glsl_source/fogQuake3_fp.glsl

@@ -26,7 +26,6 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
 uniform sampler2D u_FogMap;
 
-IN(smooth) vec3		var_Position;
 IN(smooth) vec2		var_TexCoords;
 IN(smooth) vec4		var_Color;
 
@@ -41,8 +40,4 @@ void	main()
 	color *= var_Color;
 
 	outputColor = color;
-
-#if 0
-	outputColor = vec4(vec3(1.0, 0.0, 0.0), color.a);
-#endif
 }

src/engine/renderer/glsl_source/fogQuake3_vp.glsl

@@ -34,11 +34,12 @@ uniform colorPack u_ColorGlobal;
 uniform mat4		u_ModelMatrix;
 uniform mat4		u_ModelViewProjectionMatrix;
 
-uniform vec4		u_FogDistanceVector;
-uniform vec4		u_FogDepthVector;
+uniform vec4		u_FogDistanceVector; // view axis, scaled by fog density
+uniform vec4		u_FogDepthVector; // fog plane
 uniform float		u_FogEyeT;
 
-OUT(smooth) vec3	var_Position;
+// var_TexCoords.s is distance from viewer to vertex dotted with view axis
+// var_TexCoords.t is the fraction of the viewer-to-vertex ray which is inside fog
 OUT(smooth) vec2	var_TexCoords;
 OUT(smooth) vec4	var_Color;
 
@@ -71,7 +72,8 @@ void main()
 	gl_Position = u_ModelViewProjectionMatrix * position;
 
 	// transform position into world space
-	var_Position = (u_ModelMatrix * position).xyz;
+	position = u_ModelMatrix * position;
+	position.xyz /= position.w;
 
 	// calculate the length in fog
 	float s = dot(position.xyz, u_FogDistanceVector.xyz) + u_FogDistanceVector.w;

src/engine/renderer/tr_backend.cpp

@@ -1210,6 +1210,25 @@ void RB_RunVisTests( )
 	}
 }
 
+void RB_PrepareForSamplingDepthMap()
+{
+	if ( !glConfig.textureBarrierAvailable )
+	{
+		return;
+	}
+
+	if ( !backEnd.dirtyDepthBuffer )
+	{
+		return;
+	}
+
+	// Flush depth buffer to make sure it is available for reading in the depth fade
+	// GLSL - prevents https://github.com/DaemonEngine/Daemon/issues/1676
+	glTextureBarrier();
+
+	backEnd.dirtyDepthBuffer = false;
+}
+
 static void RenderDepthTiles()
 {
 	GL_State( GLS_DEPTHTEST_DISABLE );
@@ -1227,6 +1246,11 @@ static void RenderDepthTiles()
 		return;
 	}
 
+	if ( glConfig.usingBindlessTextures )
+	{
+		RB_PrepareForSamplingDepthMap();
+	}
+
 	// 1st step
 	R_BindFBO( tr.depthtile1FBO );
 	GL_Viewport( 0, 0, tr.depthtile1FBO->width, tr.depthtile1FBO->height );
@@ -1363,6 +1387,8 @@ void RB_RenderGlobalFog()
 
 	GLIMP_LOGCOMMENT( "--- RB_RenderGlobalFog ---" );
 
+	RB_PrepareForSamplingDepthMap();
+
 	GL_Cull( cullType_t::CT_TWO_SIDED );
 
 	gl_fogGlobalShader->BindProgram( 0 );
@@ -1377,20 +1403,8 @@ void RB_RenderGlobalFog()
 
 		GL_State( GLS_DEPTHTEST_DISABLE | GLS_SRCBLEND_SRC_ALPHA | GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA );
 
-		// all fogging distance is based on world Z units
-		vec4_t fogDistanceVector;
-		vec3_t local;
-		VectorSubtract( backEnd.orientation.origin, backEnd.viewParms.orientation.origin, local );
-		fogDistanceVector[ 0 ] = -backEnd.orientation.modelViewMatrix[ 2 ];
-		fogDistanceVector[ 1 ] = -backEnd.orientation.modelViewMatrix[ 6 ];
-		fogDistanceVector[ 2 ] = -backEnd.orientation.modelViewMatrix[ 10 ];
-		fogDistanceVector[ 3 ] = DotProduct( local, backEnd.viewParms.orientation.axis[ 0 ] );
-
-		// scale the fog vectors based on the fog's thickness
-		VectorScale( fogDistanceVector, fog->tcScale, fogDistanceVector );
-		fogDistanceVector[ 3 ] *= fog->tcScale;
-
-		gl_fogGlobalShader->SetUniform_FogDistanceVector( fogDistanceVector );
+		gl_fogGlobalShader->SetUniform_FogDensity( fog->tcScale );
+		gl_fogGlobalShader->SetUniform_ViewOrigin( backEnd.viewParms.orientation.origin );
 		SetUniform_Color( gl_fogGlobalShader, fog->color );
 	}
 
@@ -1508,6 +1522,8 @@ void RB_RenderMotionBlur()
 
 	GLIMP_LOGCOMMENT( "--- RB_RenderMotionBlur ---" );
 
+	RB_PrepareForSamplingDepthMap();
+
 	GL_State( GLS_DEPTHTEST_DISABLE );
 	GL_Cull( cullType_t::CT_TWO_SIDED );
 
@@ -1546,12 +1562,7 @@ void RB_RenderSSAO()
 
 	GLIMP_LOGCOMMENT( "--- RB_RenderSSAO ---" );
 
-	// Assume depth is dirty since we just rendered depth pass and everything opaque
-	if ( glConfig.textureBarrierAvailable )
-	{
-		glTextureBarrier();
-		backEnd.dirtyDepthBuffer = false;
-	}
+	RB_PrepareForSamplingDepthMap();
 
 	GL_State( GLS_DEPTHTEST_DISABLE | GLS_SRCBLEND_DST_COLOR | GLS_DSTBLEND_ZERO );
 	GL_Cull( cullType_t::CT_TWO_SIDED );
@@ -2718,9 +2729,6 @@ static void RB_RenderView( bool depthPass )
 	// draw everything that is translucent
 	if ( glConfig.usingMaterialSystem ) {
 		materialSystem.RenderMaterials( shaderSort_t::SS_ENVIRONMENT_NOFOG, shaderSort_t::SS_POST_PROCESS, backEnd.viewParms.viewID );
-
-		// HACK: assume surfaces with depth fade don't use the material system
-		backEnd.dirtyDepthBuffer = true;
 	}
 	RB_RenderDrawSurfaces( shaderSort_t::SS_ENVIRONMENT_NOFOG, shaderSort_t::SS_POST_PROCESS, DRAWSURFACES_ALL );
 

src/engine/renderer/tr_bsp.cpp

@@ -3324,6 +3324,12 @@ static void R_LoadFogs( lump_t *l, lump_t *brushesLump, lump_t *sidesLump )
 		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 );