Implement adaptive exposure

Add a compute shader that will compute the geometric mean of scene luminance, then map it to an exposure curve in the `cameraEffects` shader. This is controlled by `r_tonemapAdaptiveExposure`.

Also improves some of the shader #insert's a bit and untangle some of the related code.

Author: VReaperV

src.cmake

@@ -148,6 +148,7 @@ set(GLSLSOURCELIST
     ${ENGINE_DIR}/renderer/glsl_source/cull_cp.glsl
     ${ENGINE_DIR}/renderer/glsl_source/depthReduction_cp.glsl
     ${ENGINE_DIR}/renderer/glsl_source/processSurfaces_cp.glsl
+    ${ENGINE_DIR}/renderer/glsl_source/material_cp.glsl
     ${ENGINE_DIR}/renderer/glsl_source/material_vp.glsl
     ${ENGINE_DIR}/renderer/glsl_source/material_fp.glsl
     ${ENGINE_DIR}/renderer/glsl_source/skybox_vp.glsl
@@ -161,6 +162,7 @@ set(GLSLSOURCELIST
     ${ENGINE_DIR}/renderer/glsl_source/cameraEffects_fp.glsl
     ${ENGINE_DIR}/renderer/glsl_source/cameraEffects_vp.glsl
     ${ENGINE_DIR}/renderer/glsl_source/computeLight_fp.glsl
+    ${ENGINE_DIR}/renderer/glsl_source/luminanceReduction_cp.glsl
     ${ENGINE_DIR}/renderer/glsl_source/contrast_fp.glsl
     ${ENGINE_DIR}/renderer/glsl_source/contrast_vp.glsl
     ${ENGINE_DIR}/renderer/glsl_source/debugShadowMap_fp.glsl

src/engine/renderer/Material.h

@@ -291,6 +291,7 @@ enum class BufferBind {
 	PORTAL_SURFACES = 5,
 	GEOMETRY_CACHE_INPUT_VBO = 6,
 	GEOMETRY_CACHE_VBO = 7,
+	LUMINANCE = 3,
 	DEBUG = 10,
 	UNUSED = INT32_MAX
 };

src/engine/renderer/gl_shader.cpp

@@ -54,6 +54,7 @@ GLShader_lightMappingMaterial            *gl_lightMappingShaderMaterial = nullpt
 GLShader_forwardLighting_omniXYZ         *gl_forwardLightingShader_omniXYZ = nullptr;
 GLShader_forwardLighting_projXYZ         *gl_forwardLightingShader_projXYZ = nullptr;
 GLShader_forwardLighting_directionalSun  *gl_forwardLightingShader_directionalSun = nullptr;
+GLShader_luminanceReduction              *gl_luminanceReductionShader = nullptr;
 GLShader_shadowFill                      *gl_shadowFillShader = nullptr;
 GLShader_reflection                      *gl_reflectionShader = nullptr;
 GLShader_reflectionMaterial              *gl_reflectionShaderMaterial = nullptr;
@@ -80,6 +81,7 @@ GLShader_depthtile2                      *gl_depthtile2Shader = nullptr;
 GLShader_lighttile                       *gl_lighttileShader = nullptr;
 GLShader_fxaa                            *gl_fxaaShader = nullptr;
 GLShaderManager                           gl_shaderManager;
+GLBuffer luminanceBuffer( "luminance", Util::ordinal( BufferBind::LUMINANCE ), GL_MAP_WRITE_BIT, GL_MAP_INVALIDATE_RANGE_BIT );
 
 namespace // Implementation details
 {
@@ -405,6 +407,9 @@ static const std::vector<addedExtension_t> fragmentVertexAddedExtensions = {
 	where the core variables have different names. */
 	{ glConfig2.shaderDrawParametersAvailable, -1, "ARB_shader_draw_parameters" },
 	{ glConfig2.SSBOAvailable, 430, "ARB_shader_storage_buffer_object" },
+	{ glConfig2.shadingLanguage420PackAvailable, 420, "ARB_shading_language_420pack" },
+	{ glConfig2.explicitUniformLocationAvailable, 430, "ARB_explicit_uniform_location" },
+	{ glConfig2.shaderAtomicCountersAvailable, 420, "ARB_shader_atomic_counters" },
 	/* Even though these are part of the GL_KHR_shader_subgroup extension, we need to enable
 	the individual extensions for each feature.
 	GL_KHR_shader_subgroup itself can't be used in the shader. */
@@ -552,6 +557,10 @@ static std::string GenVertexHeader() {
 		AddDefine( str, "BIND_LIGHTMAP_DATA", Util::ordinal( BufferBind::LIGHTMAP_DATA ) );
 	}
 
+	if ( glConfig2.adaptiveExposureAvailable ) {
+		AddDefine( str, "BIND_LUMINANCE", Util::ordinal( BufferBind::LUMINANCE ) );
+	}
+
 	return str;
 }
 
@@ -592,6 +601,10 @@ static std::string GenFragmentHeader() {
 		AddDefine( str, "BIND_LIGHTMAP_DATA", Util::ordinal( BufferBind::LIGHTMAP_DATA ) );
 	}
 
+	if ( glConfig2.adaptiveExposureAvailable ) {
+		AddDefine( str, "BIND_LUMINANCE", Util::ordinal( BufferBind::LUMINANCE ) );
+	}
+
 	return str;
 }
 
@@ -617,6 +630,10 @@ static std::string GenComputeHeader() {
 		AddDefine( str, "BIND_DEBUG", Util::ordinal( BufferBind::DEBUG ) );
 	}
 
+	if ( glConfig2.adaptiveExposureAvailable ) {
+		AddDefine( str, "BIND_LUMINANCE", Util::ordinal( BufferBind::LUMINANCE ) );
+	}
+
 	if ( glConfig2.usingBindlessTextures ) {
 		str += "layout(bindless_image) uniform;\n";
 	}
@@ -2640,6 +2657,17 @@ void GLShader_forwardLighting_directionalSun::SetShaderProgramUniforms( shaderPr
 	glUniform1i( glGetUniformLocation( shaderProgram->program, "u_HeightMap" ), 15 );
 }
 
+GLShader_luminanceReduction::GLShader_luminanceReduction( GLShaderManager* manager ) :
+	GLShader( "luminanceReduction", 0, manager, false, false, true ),
+	u_ViewWidth( this ),
+	u_ViewHeight( this ),
+	u_TonemapParms2( this ) {
+}
+
+void GLShader_luminanceReduction::SetShaderProgramUniforms( shaderProgram_t* shaderProgram ) {
+	glUniform1i( glGetUniformLocation( shaderProgram->program, "initialRenderImage" ), 0 );
+}
+
 GLShader_shadowFill::GLShader_shadowFill( GLShaderManager *manager ) :
 	GLShader( "shadowFill", ATTR_POSITION | ATTR_TEXCOORD | ATTR_QTANGENT, manager ),
 	u_ColorMap( this ),
@@ -2910,7 +2938,10 @@ GLShader_cameraEffects::GLShader_cameraEffects( GLShaderManager *manager ) :
 	u_ColorModulate( this ),
 	u_TextureMatrix( this ),
 	u_ModelViewProjectionMatrix( this ),
+	u_ViewWidth( this ),
+	u_ViewHeight( this ),
 	u_Tonemap( this ),
+	u_TonemapAdaptiveExposure( this ),
 	u_TonemapParms( this ),
 	u_TonemapExposure( this ),
 	u_InverseGamma( this )

src/engine/renderer/gl_shader.h

@@ -3807,6 +3807,18 @@ class u_Tonemap :
 	}
 };
 
+class u_TonemapAdaptiveExposure :
+	GLUniform1Bool {
+	public:
+	u_TonemapAdaptiveExposure( GLShader* shader ) :
+		GLUniform1Bool( shader, "u_TonemapAdaptiveExposure", true ) {
+	}
+
+	void SetUniform_TonemapAdaptiveExposure( bool tonemapAdaptiveExposure ) {
+		this->SetValue( tonemapAdaptiveExposure );
+	}
+};
+
 class u_TonemapParms :
 	GLUniform4f {
 	public:
@@ -3819,6 +3831,18 @@ class u_TonemapParms :
 	}
 };
 
+class u_TonemapParms2 :
+	GLUniform4f {
+	public:
+	u_TonemapParms2( GLShader* shader ) :
+		GLUniform4f( shader, "u_TonemapParms2", true ) {
+	}
+
+	void SetUniform_TonemapParms2( vec4_t tonemapParms2 ) {
+		this->SetValue( tonemapParms2 );
+	}
+};
+
 class u_TonemapExposure :
 	GLUniform1f {
 	public:
@@ -4227,6 +4251,16 @@ class GLShader_forwardLighting_directionalSun :
 	void SetShaderProgramUniforms( shaderProgram_t *shaderProgram ) override;
 };
 
+class GLShader_luminanceReduction :
+	public GLShader,
+	public u_ViewWidth,
+	public u_ViewHeight,
+	public u_TonemapParms2 {
+	public:
+	GLShader_luminanceReduction( GLShaderManager* manager );
+	void SetShaderProgramUniforms( shaderProgram_t* shaderProgram ) override;
+};
+
 class GLShader_shadowFill :
 	public GLShader,
 	public u_ColorMap,
@@ -4463,7 +4497,10 @@ class GLShader_cameraEffects :
 	public u_ColorModulate,
 	public u_TextureMatrix,
 	public u_ModelViewProjectionMatrix,
+	public u_ViewWidth,
+	public u_ViewHeight,
 	public u_Tonemap,
+	public u_TonemapAdaptiveExposure,
 	public u_TonemapParms,
 	public u_TonemapExposure,
 	public u_InverseGamma
@@ -4700,6 +4737,7 @@ extern GLShader_lightMappingMaterial            *gl_lightMappingShaderMaterial;
 extern GLShader_forwardLighting_omniXYZ         *gl_forwardLightingShader_omniXYZ;
 extern GLShader_forwardLighting_projXYZ         *gl_forwardLightingShader_projXYZ;
 extern GLShader_forwardLighting_directionalSun  *gl_forwardLightingShader_directionalSun;
+extern GLShader_luminanceReduction              *gl_luminanceReductionShader;
 extern GLShader_shadowFill                      *gl_shadowFillShader;
 extern GLShader_reflection                      *gl_reflectionShader;
 extern GLShader_reflectionMaterial              *gl_reflectionShaderMaterial;
@@ -4726,5 +4764,6 @@ extern GLShader_depthtile2                      *gl_depthtile2Shader;
 extern GLShader_lighttile                       *gl_lighttileShader;
 extern GLShader_fxaa                            *gl_fxaaShader;
 extern GLShaderManager                           gl_shaderManager;
+extern GLBuffer luminanceBuffer;
 
 #endif // GL_SHADER_H

src/engine/renderer/glsl_source/cameraEffects_fp.glsl

@@ -28,18 +28,26 @@ uniform sampler2D u_CurrentMap;
 uniform sampler3D u_ColorMap3D;
 #endif
 
+layout(std140, binding = BIND_LUMINANCE) uniform ub_LuminanceUBO {
+	uint luminanceU;
+};
+
 uniform vec4      u_ColorModulate;
 uniform float     u_InverseGamma;
 
 IN(smooth) vec2		var_TexCoords;
 
 DECLARE_OUTPUT(vec4)
 
+uniform uint u_ViewWidth;
+uniform uint u_ViewHeight;
+
+uniform bool u_Tonemap;
+uniform bool u_TonemapAdaptiveExposure;
 /* x: contrast
 y: highlightsCompressionSpeed
 z: shoulderClip
 w: highlightsCompression */
-uniform bool u_Tonemap;
 uniform vec4 u_TonemapParms;
 uniform float u_TonemapExposure;
 
@@ -57,6 +65,11 @@ void main()
 	vec4 color = texture2D(u_CurrentMap, st);
 
 	if( u_Tonemap ) {
+		if( u_TonemapAdaptiveExposure ) {
+			const float l = float( luminanceU ) / ( 256.0f * u_ViewWidth * u_ViewHeight ) - 8;
+			color.rgb *= clamp( 0.18f / exp2( l * 0.8f + 0.1f ), 0.0f, 2.0f );
+		}
+
 		color.rgb = TonemapLottes( color.rgb * u_TonemapExposure );
 	}
 	color.rgb = clamp( color.rgb, vec3( 0.0f ), vec3( 1.0f ) );
@@ -74,4 +87,5 @@ void main()
 	color.xyz = pow(color.xyz, vec3(u_InverseGamma));
 
 	outputColor = color;
+	// outputColor = vec4( luminance, color.yzw );
 }

src/engine/renderer/glsl_source/common_cp.glsl

@@ -54,41 +54,14 @@ array must be in the form of uvec4 array[] */
                              + gl_GlobalInvocationID.y * gl_NumWorkGroups.x * gl_WorkGroupSize.x\
                              + gl_GlobalInvocationID.x )
 
-/* Common structs */
+/* Macro combinations for subgroup ops */
 
-struct BoundingSphere {
-	vec3 origin;
-	float radius;
-};
+#if defined(HAVE_KHR_shader_subgroup_basic) && defined(HAVE_KHR_shader_subgroup_arithmetic)\
+	&& defined(HAVE_ARB_shader_atomic_counter_ops)
+	#define HAVE_subgroup_atomic
+#endif
 
-struct SurfaceDescriptor {
-	BoundingSphere boundingSphere;
-	uint surfaceCommandIDs[MAX_SURFACE_COMMANDS];
-};
-
-struct PortalSurface {
-	BoundingSphere boundingSphere;
-
-	uint drawSurfID;
-	float distance;
-	vec2 padding;
-};
-
-struct GLIndirectCommand {
-	uint count;
-	uint instanceCount;
-	uint firstIndex;
-	int baseVertex;
-	uint baseInstance;
-};
-
-struct IndirectCompactCommand {
-	uint count;
-	uint firstIndex;
-	uint baseInstance;
-};
-
-struct SurfaceCommand {
-	bool enabled;
-	IndirectCompactCommand drawCommand;
-};
+#if defined(HAVE_KHR_shader_subgroup_basic) && defined(HAVE_KHR_shader_subgroup_arithmetic)\
+	&& defined(HAVE_KHR_shader_subgroup_ballot) && defined(HAVE_ARB_shader_atomic_counter_ops)
+	#define HAVE_subgroup_stream_compaction
+#endif

src/engine/renderer/glsl_source/cull_cp.glsl

@@ -35,6 +35,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /* cull_cp.glsl */
 
 #insert common_cp
+#insert material_cp
 
 // Keep this to 64 because we don't want extra shared mem etc. to be allocated, and to minimize wasted lanes
 layout (local_size_x = 64, local_size_y = 1, local_size_z = 1) in;

src/engine/renderer/glsl_source/luminanceReduction_cp.glsl

@@ -0,0 +1,82 @@
+/*
+===========================================================================
+
+Daemon BSD Source Code
+Copyright (c) 2024-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.
+
+===========================================================================
+*/
+
+/* adaptiveLightingReduction_cp.glsl */
+
+#insert common_cp
+
+// Keep this to 8x8 because we don't want extra shared mem etc. to be allocated, and to minimize wasted lanes
+layout (local_size_x = 8, local_size_y = 8, local_size_z = 1) in;
+
+layout(binding = 0) uniform sampler2D renderImage;
+
+uniform uint u_ViewWidth;
+uniform uint u_ViewHeight;
+
+/* x: log2( HDRMax )
+y: reserved
+z: reserved
+w: reserved */
+uniform vec4 u_TonemapParms2;
+
+layout (binding = BIND_LUMINANCE) uniform atomic_uint atomicLuminance;
+
+float ColorToLuminance( const in vec3 color ) {
+    float luminance = dot( color.rgb, vec3( 0.2126f, 0.7152f, 0.0722f ) ); // sRGB luminance
+
+    return luminance > 0.0f ? clamp( log2( luminance ) + 8, 0.0, u_TonemapParms2.x + 8 ) : 0.0f;
+}
+
+uint FloatLuminanceToUint( const in float luminance ) {
+    return uint( luminance * 256 );
+}
+
+void main() {
+    const ivec2 position = ivec2( gl_GlobalInvocationID.xy );
+    if( position.x >= u_ViewWidth || position.y >= u_ViewHeight ) {
+        return;
+    };
+    
+    const float luminance = ColorToLuminance( texelFetch( renderImage, position, 0 ).rgb );
+
+	#if defined(HAVE_subgroup_atomic)
+		const float luminanceSum = subgroupInclusiveAdd( luminance );
+		
+		if( subgroupElect() ) {
+			atomicCounterAddARB( atomicLuminance, FloatLuminanceToUint( luminanceSum ) );
+		}
+    #else
+        atomicCounterAddARB( atomicLuminance, FloatLuminanceToUint( luminance ) );
+    #endif
+}