fixed hdr auto exposure

Author: mrDIMAS

fyrox-graphics-gl/src/shaders/shared.glsl

@@ -416,12 +416,12 @@ vec3 S_ConvertYxyToXyz(vec3 Yxy)
 	return xyz;
 }
 
-vec3 convertRGB2Yxy(vec3 rgb)
+vec3 S_ConvertRgbToYxy(vec3 rgb)
 {
 	return S_ConvertXyzToYxy(S_ConvertRgbToXyz(rgb));
 }
 
-vec3 convertYxy2RGB(vec3 Yxy)
+vec3 S_ConvertYxyToRgb(vec3 Yxy)
 {
 	return S_ConvertXyzToRgb(S_ConvertYxyToXyz(Yxy));
 }

fyrox-impl/src/renderer/hdr/mod.rs

@@ -310,20 +310,18 @@ impl HighDynamicRangeRenderer {
             })
             .unwrap_or((&self.stub_lut, &renderer_resources.nearest_clamp_sampler));
 
-        let (is_auto, key_value, min_luminance, max_luminance, fixed_exposure) = match exposure {
+        let (is_auto, min_luminance, max_luminance, fixed_exposure) = match exposure {
             Exposure::Auto {
-                key_value,
                 min_luminance,
                 max_luminance,
-            } => (true, key_value, min_luminance, max_luminance, 0.0),
-            Exposure::Manual(fixed_exposure) => (false, 0.0, 0.0, 0.0, fixed_exposure),
+            } => (true, min_luminance, max_luminance, 0.0),
+            Exposure::Manual(fixed_exposure) => (false, 0.0, 0.0, fixed_exposure),
         };
 
         let color_grading_enabled = use_color_grading && color_grading_lut.is_some();
         let properties = PropertyGroup::from([
             property("worldViewProjection", &frame_matrix),
             property("useColorGrading", &color_grading_enabled),
-            property("keyValue", &key_value),
             property("minLuminance", &min_luminance),
             property("maxLuminance", &max_luminance),
             property("autoExposure", &is_auto),

fyrox-impl/src/renderer/shaders/hdr_map.shader

@@ -26,7 +26,6 @@
             kind: PropertyGroup([
                 (name: "worldViewProjection", kind: Matrix4()),
                 (name: "useColorGrading", kind: Bool()),
-                (name: "keyValue", kind: Float()),
                 (name: "minLuminance", kind: Float()),
                 (name: "maxLuminance", kind: Float()),
                 (name: "autoExposure", kind: Bool()),
@@ -89,21 +88,33 @@
                         return texture(colorMapSampler, scale * color + offset).rgb;
                     }
 
-                    void main() {
-                        vec4 hdrColor = texture(hdrSampler, texCoord);
+                    // Narkowicz 2015, "ACES Filmic Tone Mapping Curve"
+                    float TonemapACES(float x) {
+                        const float a = 2.51;
+                        const float b = 0.03;
+                        const float c = 2.43;
+                        const float d = 0.59;
+                        const float e = 0.14;
+                        return (x * (a * x + b)) / (x * (c * x + d) + e);
+                    }
 
-                        hdrColor += texture(bloomSampler, texCoord);
+                    void main() {
+                        vec4 hdrColor = texture(hdrSampler, texCoord) + texture(bloomSampler, texCoord);
 
-                        float luminance = texture(lumSampler, vec2(0.5, 0.5)).r;
+                        vec3 Yxy = S_ConvertRgbToYxy(hdrColor.rgb);
 
-                        float exposure;
+                        float lp;
                         if (properties.autoExposure) {
-                            exposure = properties.keyValue / clamp(luminance, properties.minLuminance, properties.maxLuminance);
+                            float avgLum = texture(lumSampler, vec2(0.5, 0.5)).r;
+                            float clampedAvgLum = clamp(avgLum, properties.minLuminance, properties.maxLuminance);
+                            lp = Yxy.x / (9.6 * clampedAvgLum + 0.0001);
                         } else {
-                            exposure = properties.fixedExposure;
+                            lp = Yxy.x * properties.fixedExposure;
                         }
 
-                        vec4 ldrColor = vec4(vec3(1.0) - exp(-hdrColor.rgb * exposure), hdrColor.a);
+                        Yxy.x = TonemapACES(lp);
+
+                        vec4 ldrColor = vec4(S_ConvertYxyToRgb(Yxy), hdrColor.a);
 
                         if (properties.useColorGrading) {
                             outLdrColor = vec4(ColorGrading(S_LinearToSRGB(ldrColor).rgb), ldrColor.a);

fyrox-impl/src/scene/camera.rs

@@ -290,39 +290,43 @@ impl Default for Projection {
 
 /// Exposure is a parameter that describes how many light should be collected for one
 /// frame. The higher the value, the more brighter the final frame will be and vice versa.
-#[derive(Visit, Copy, Clone, PartialEq, Debug, Reflect, AsRefStr, EnumString, VariantNames)]
+#[derive(
+    Visit,
+    Copy,
+    Clone,
+    PartialEq,
+    Debug,
+    Reflect,
+    AsRefStr,
+    EnumString,
+    VariantNames,
+    Serialize,
+    Deserialize,
+)]
 pub enum Exposure {
     /// Automatic exposure based on the frame luminance. High luminance values will result
-    /// in lower exposure levels and vice versa. This is default option.
-    ///
-    /// # Equation
-    ///
-    /// `exposure = key_value / clamp(avg_luminance, min_luminance, max_luminance)`
+    /// in lower exposure levels and vice versa.
     Auto {
-        /// A key value in the formula above. Default is 0.01556.
-        #[reflect(min_value = 0.0, step = 0.1)]
-        key_value: f32,
-        /// A min luminance value in the formula above. Default is 0.00778.
+        /// A min luminance value. The lower the value, the higher exposure values will be used for
+        /// dark images. The default value is 0.035.
         #[reflect(min_value = 0.0, step = 0.1)]
         min_luminance: f32,
-        /// A max luminance value in the formula above. Default is 64.0.
+        /// A max luminance value. The higher the value, the lower exposure values will be used for
+        /// bright images. The default value is 10.0.
         #[reflect(min_value = 0.0, step = 0.1)]
         max_luminance: f32,
     },
 
-    /// Specific exposure level. To "disable" any HDR effects use [`std::f32::consts::E`] as a value.
+    /// Specific exposure level. To "disable" any HDR effects use 1.0 as a value. This is the default
+    /// option.
     Manual(f32),
 }
 
 uuid_provider!(Exposure = "0e35ee3d-8baa-4b0c-b3dd-6c31a08c121e");
 
 impl Default for Exposure {
     fn default() -> Self {
-        Self::Auto {
-            key_value: 0.18,
-            min_luminance: 0.001,
-            max_luminance: 24.0,
-        }
+        Self::Manual(1.0)
     }
 }
 
@@ -1040,7 +1044,7 @@ impl CameraBuilder {
             z_far: 2048.0,
             viewport: Rect::new(0.0, 0.0, 1.0, 1.0),
             environment: None,
-            exposure: Exposure::Manual(std::f32::consts::E),
+            exposure: Default::default(),
             color_grading_lut: None,
             color_grading_enabled: false,
             projection: Projection::default(),