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`.

Author: VReaperV

libs/crunch

@@ -143,6 +143,7 @@ set(GLSLSOURCELIST
     ${ENGINE_DIR}/renderer/glsl_source/common_cp.glsl
     ${ENGINE_DIR}/renderer/glsl_source/shaderProfiler_vp.glsl
     ${ENGINE_DIR}/renderer/glsl_source/shaderProfiler_fp.glsl
+    ${ENGINE_DIR}/renderer/glsl_source/clearFrameData_cp.glsl
     ${ENGINE_DIR}/renderer/glsl_source/clearSurfaces_cp.glsl
     ${ENGINE_DIR}/renderer/glsl_source/cull_cp.glsl
     ${ENGINE_DIR}/renderer/glsl_source/depthReduction_cp.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.cmake

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

src/engine/renderer/Material.h

@@ -45,6 +45,7 @@ ShaderKind shaderKind = ShaderKind::Unknown;
 
 GLShader_generic                         *gl_genericShader = nullptr;
 GLShader_genericMaterial                 *gl_genericShaderMaterial = nullptr;
+GLShader_clearFrameData                  *gl_clearFrameDataShader = nullptr;
 GLShader_cull                            *gl_cullShader = nullptr;
 GLShader_depthReduction                  *gl_depthReductionShader = nullptr;
 GLShader_clearSurfaces                   *gl_clearSurfacesShader = nullptr;
@@ -54,6 +55,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 +82,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
 {
@@ -429,6 +432,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. */
@@ -576,6 +582,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;
 }
 
@@ -616,6 +626,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;
 }
 
@@ -641,6 +655,11 @@ static std::string GenComputeHeader() {
 		AddDefine( str, "BIND_DEBUG", Util::ordinal( BufferBind::DEBUG ) );
 	}
 
+	if ( glConfig2.adaptiveExposureAvailable ) {
+		AddDefine( str, "BIND_LUMINANCE", Util::ordinal( BufferBind::LUMINANCE ) );
+		AddDefine( str, "BIND_LUMINANCE_STORAGE", Util::ordinal( BufferBind::LUMINANCE_STORAGE ) );
+	}
+
 	if ( glConfig2.usingBindlessTextures ) {
 		str += "layout(bindless_image) uniform;\n";
 	}
@@ -2772,6 +2791,17 @@ void GLShader_forwardLighting_directionalSun::SetShaderProgramUniforms( ShaderPr
 	glUniform1i( glGetUniformLocation( shaderProgram->id, "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( ShaderProgramDescriptor* shaderProgram ) {
+	glUniform1i( glGetUniformLocation( shaderProgram->id, "initialRenderImage" ), 0 );
+}
+
 GLShader_shadowFill::GLShader_shadowFill( GLShaderManager *manager ) :
 	GLShader( "shadowFill", ATTR_POSITION | ATTR_TEXCOORD | ATTR_QTANGENT, manager ),
 	u_ColorMap( this ),
@@ -3043,7 +3073,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 )
@@ -3256,6 +3289,10 @@ void GLShader_fxaa::SetShaderProgramUniforms( ShaderProgramDescriptor *shaderPro
 	glUniform1i( glGetUniformLocation( shaderProgram->id, "u_ColorMap" ), 0 );
 }
 
+GLShader_clearFrameData::GLShader_clearFrameData( GLShaderManager* manager ) :
+	GLShader( "clearFrameData", 0, manager, false, false, true ) {
+}
+
 GLShader_cull::GLShader_cull( GLShaderManager* manager ) :
 	GLShader( "cull", ATTR_POSITION, manager, false, false, true ),
 	u_Frame( this ),

src/engine/renderer/gl_shader.cpp

@@ -3934,6 +3934,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:
@@ -3946,6 +3958,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:
@@ -4354,6 +4378,16 @@ class GLShader_forwardLighting_directionalSun :
 	void SetShaderProgramUniforms( ShaderProgramDescriptor *shaderProgram ) override;
 };
 
+class GLShader_luminanceReduction :
+	public GLShader,
+	public u_ViewWidth,
+	public u_ViewHeight,
+	public u_TonemapParms2 {
+	public:
+	GLShader_luminanceReduction( GLShaderManager* manager );
+	void SetShaderProgramUniforms( ShaderProgramDescriptor* shaderProgram ) override;
+};
+
 class GLShader_shadowFill :
 	public GLShader,
 	public u_ColorMap,
@@ -4591,7 +4625,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
@@ -4765,6 +4802,12 @@ class GLShader_fxaa :
 	void SetShaderProgramUniforms( ShaderProgramDescriptor *shaderProgram ) override;
 };
 
+class GLShader_clearFrameData :
+	public GLShader {
+	public:
+	GLShader_clearFrameData( GLShaderManager* manager );
+};
+
 class GLShader_cull :
 	public GLShader,
 	public u_Frame,
@@ -4819,6 +4862,7 @@ extern ShaderKind shaderKind;
 
 extern GLShader_generic                         *gl_genericShader;
 extern GLShader_genericMaterial                 *gl_genericShaderMaterial;
+extern GLShader_clearFrameData                  *gl_clearFrameDataShader;
 extern GLShader_cull                            *gl_cullShader;
 extern GLShader_depthReduction                  *gl_depthReductionShader;
 extern GLShader_clearSurfaces                   *gl_clearSurfacesShader;
@@ -4828,6 +4872,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;
@@ -4854,5 +4899,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/gl_shader.h

@@ -25,24 +25,34 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 uniform sampler2D u_CurrentMap;
 
 #if defined(r_colorGrading)
-uniform sampler3D u_ColorMap3D;
+	uniform sampler3D u_ColorMap3D;
 #endif
 
-uniform vec4      u_ColorModulate;
-uniform float     u_GlobalLightFactor; // 1 / tr.identityLight
-uniform float     u_InverseGamma;
+#if defined(HAVE_ARB_explicit_uniform_location) && defined(HAVE_ARB_shader_atomic_counters)
+	layout(std140, binding = BIND_LUMINANCE) uniform ub_LuminanceUBO {
+		uint luminanceU;
+	};
+#endif
+
+uniform vec4 u_ColorModulate;
+uniform float u_GlobalLightFactor; // 1 / tr.identityLight
+uniform float u_InverseGamma;
 
-IN(smooth) vec2		var_TexCoords;
+IN(smooth) vec2 var_TexCoords;
 
 DECLARE_OUTPUT(vec4)
 
 // Tone mapping is not available when high-precision float framebuffer isn't enabled or supported.
 #if defined(r_highPrecisionRendering) && defined(HAVE_ARB_texture_float)
+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;
 
@@ -53,8 +63,11 @@ vec3 TonemapLottes( vec3 color ) {
 }
 #endif
 
-void main()
-{
+float GetAverageLuminance( const in uint luminance ) {
+    return float( luminanceU ) / ( 256.0f * u_ViewWidth * u_ViewHeight );
+}
+
+void main() {
 	// calculate the screen texcoord in the 0.0 to 1.0 range
 	vec2 st = gl_FragCoord.st / r_FBufSize;
 
@@ -63,6 +76,13 @@ void main()
 
 #if defined(r_highPrecisionRendering) && defined(HAVE_ARB_texture_float)
 	if( u_Tonemap ) {
+		#if defined(HAVE_ARB_explicit_uniform_location) && defined(HAVE_ARB_shader_atomic_counters)
+			if( u_TonemapAdaptiveExposure ) {
+					const float l = GetAverageLuminance( luminanceU ) - 8;
+					color.rgb *= clamp( 0.18f / exp2( l * 0.8f + 0.1f ), 0.0f, 2.0f );
+			}
+		#endif
+
 		color.rgb = TonemapLottes( color.rgb * u_TonemapExposure );
 	}
 #endif
@@ -82,4 +102,5 @@ void main()
 	color.xyz = pow(color.xyz, vec3(u_InverseGamma));
 
 	outputColor = color;
+	// outputColor = vec4( luminance, color.yzw );
 }

src/engine/renderer/glsl_source/cameraEffects_fp.glsl

@@ -0,0 +1,53 @@
+/*
+===========================================================================
+
+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.
+
+===========================================================================
+*/
+
+/* clearFrameData_cp.glsl */
+
+#insert common_cp
+
+layout (local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
+
+layout(std430, binding = BIND_LUMINANCE_STORAGE) writeonly buffer luminanceBuffer {
+    uint luminance;
+};
+
+uniform uint u_Frame;
+
+void main() {
+    const uint globalInvocationID = GLOBAL_INVOCATION_ID;
+    if( globalInvocationID >= 1 ) {
+        return;
+    }
+    luminance = 0;
+}

src/engine/renderer/glsl_source/clearFrameData_cp.glsl

@@ -56,6 +56,11 @@ array must be in the form of uvec4 array[] */
 
 /* Macro combinations for subgroup ops */
 
+#if defined(HAVE_KHR_shader_subgroup_basic) && defined(HAVE_KHR_shader_subgroup_arithmetic)\
+	&& defined(HAVE_ARB_shader_atomic_counter_ops)
+	#define SUBGROUP_ATOMIC
+#endif
+
 #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 SUBGROUP_STREAM_COMPACTION