Exposure settings

crates/bevy_pbr/src/render/light.rs

@@ -854,18 +854,6 @@ pub fn prepare_lights(
             flags |= DirectionalLightFlags::SHADOWS_ENABLED;
         }
 
-        // convert from illuminance (lux) to candelas
-        //
-        // exposure is hard coded at the moment but should be replaced
-        // by values coming from the camera
-        // see: https://google.github.io/filament/Filament.html#imagingpipeline/physicallybasedcamera/exposuresettings
-        const APERTURE: f32 = 4.0;
-        const SHUTTER_SPEED: f32 = 1.0 / 250.0;
-        const SENSITIVITY: f32 = 100.0;
-        let ev100 = f32::log2(APERTURE * APERTURE / SHUTTER_SPEED) - f32::log2(SENSITIVITY / 100.0);
-        let exposure = 1.0 / (f32::powf(2.0, ev100) * 1.2);
-        let intensity = light.illuminance * exposure;
-
         let num_cascades = light
             .cascade_shadow_config
             .bounds
@@ -876,7 +864,7 @@ pub fn prepare_lights(
             cascades: [GpuDirectionalCascade::default(); MAX_CASCADES_PER_LIGHT],
             // premultiply color by intensity
             // we don't use the alpha at all, so no reason to multiply only [0..3]
-            color: Vec4::from_slice(&light.color.as_linear_rgba_f32()) * intensity,
+            color: Vec4::from_slice(&light.color.as_linear_rgba_f32()) * light.illuminance,
             // direction is negated to be ready for N.L
             dir_to_light: light.transform.back(),
             flags: flags.bits,

crates/bevy_pbr/src/render/pbr_functions.wgsl

@@ -254,7 +254,7 @@ fn pbr(
 
     // Total light
     output_color = vec4<f32>(
-        direct_light + indirect_light + emissive_light,
+        view.exposure * (direct_light + indirect_light + emissive_light),
         output_color.a
     );
 

crates/bevy_render/src/camera/camera.rs

@@ -76,6 +76,36 @@ pub struct ComputedCameraValues {
     old_viewport_size: Option<UVec2>,
 }
 
+#[derive(Component)]
+pub struct ExposureSettings {
+    pub aperture_f_stops: f32,
+    pub shutter_speed_s: f32,
+    pub sensitivity_iso: f32,
+}
+
+impl Default for ExposureSettings {
+    fn default() -> Self {
+        Self {
+            aperture_f_stops: 4.0,
+            shutter_speed_s: 1.0 / 250.0,
+            sensitivity_iso: 100.0,
+        }
+    }
+}
+
+impl ExposureSettings {
+    #[inline]
+    pub fn ev100(&self) -> f32 {
+        (self.aperture_f_stops * self.aperture_f_stops / self.shutter_speed_s).log2()
+            - (self.sensitivity_iso / 100.0).log2()
+    }
+
+    #[inline]
+    pub fn exposure(&self) -> f32 {
+        1.0 / (2.0f32.powf(self.ev100()) * 1.2)
+    }
+}
+
 /// The defining component for camera entities, storing information about how and what to render
 /// through this camera.
 ///
@@ -573,6 +603,7 @@ pub struct ExtractedCamera {
     pub output_mode: CameraOutputMode,
     pub msaa_writeback: bool,
     pub sorted_camera_index_for_target: usize,
+    pub exposure: f32,
 }
 
 pub fn extract_cameras(
@@ -585,6 +616,7 @@ pub fn extract_cameras(
             &GlobalTransform,
             &VisibleEntities,
             Option<&ColorGrading>,
+            Option<&ExposureSettings>,
             Option<&TemporalJitter>,
         )>,
     >,
@@ -598,6 +630,7 @@ pub fn extract_cameras(
         transform,
         visible_entities,
         color_grading,
+        exposure_settings,
         temporal_jitter,
     ) in query.iter()
     {
@@ -630,6 +663,9 @@ pub fn extract_cameras(
                     msaa_writeback: camera.msaa_writeback,
                     // this will be set in sort_cameras
                     sorted_camera_index_for_target: 0,
+                    exposure: exposure_settings
+                        .map(|e| e.exposure())
+                        .unwrap_or_else(|| ExposureSettings::default().exposure()),
                 },
                 ExtractedView {
                     projection: camera.projection_matrix(),

crates/bevy_render/src/view/mod.rs

@@ -6,7 +6,7 @@ pub use visibility::*;
 pub use window::*;
 
 use crate::{
-    camera::{ExtractedCamera, TemporalJitter},
+    camera::{ExposureSettings, ExtractedCamera, TemporalJitter},
     extract_resource::{ExtractResource, ExtractResourcePlugin},
     prelude::{Image, Shader},
     render_asset::RenderAssets,
@@ -168,6 +168,7 @@ pub struct ViewUniform {
     projection: Mat4,
     inverse_projection: Mat4,
     world_position: Vec3,
+    exposure: f32,
     // viewport(x_origin, y_origin, width, height)
     viewport: Vec4,
     color_grading: ColorGrading,
@@ -313,26 +314,31 @@ pub fn prepare_view_uniforms(
     render_device: Res<RenderDevice>,
     render_queue: Res<RenderQueue>,
     mut view_uniforms: ResMut<ViewUniforms>,
-    views: Query<(Entity, &ExtractedView, Option<&TemporalJitter>)>,
+    views: Query<(
+        Entity,
+        Option<&ExtractedCamera>,
+        &ExtractedView,
+        Option<&TemporalJitter>,
+    )>,
 ) {
     view_uniforms.uniforms.clear();
 
-    for (entity, camera, temporal_jitter) in &views {
-        let viewport = camera.viewport.as_vec4();
-        let unjittered_projection = camera.projection;
+    for (entity, extracted_camera, extracted_view, temporal_jitter) in &views {
+        let viewport = extracted_view.viewport.as_vec4();
+        let unjittered_projection = extracted_view.projection;
         let mut projection = unjittered_projection;
 
         if let Some(temporal_jitter) = temporal_jitter {
             temporal_jitter.jitter_projection(&mut projection, viewport.zw());
         }
 
         let inverse_projection = projection.inverse();
-        let view = camera.transform.compute_matrix();
+        let view = extracted_view.transform.compute_matrix();
         let inverse_view = view.inverse();
 
         let view_uniforms = ViewUniformOffset {
             offset: view_uniforms.uniforms.push(ViewUniform {
-                view_proj: camera
+                view_proj: extracted_view
                     .view_projection
                     .unwrap_or_else(|| projection * inverse_view),
                 unjittered_view_proj: unjittered_projection * inverse_view,
@@ -341,9 +347,12 @@ pub fn prepare_view_uniforms(
                 inverse_view,
                 projection,
                 inverse_projection,
-                world_position: camera.transform.translation(),
+                world_position: extracted_view.transform.translation(),
+                exposure: extracted_camera
+                    .map(|c| c.exposure)
+                    .unwrap_or_else(|| ExposureSettings::default().exposure()),
                 viewport,
-                color_grading: camera.color_grading,
+                color_grading: extracted_view.color_grading,
             }),
         };
 

crates/bevy_render/src/view/view.wgsl

@@ -16,6 +16,7 @@ struct View {
     projection: mat4x4<f32>,
     inverse_projection: mat4x4<f32>,
     world_position: vec3<f32>,
+    exposure: f32,
     // viewport(x_origin, y_origin, width, height)
     viewport: vec4<f32>,
     color_grading: ColorGrading,

examples/3d/lighting.rs

@@ -3,13 +3,13 @@
 
 use std::f32::consts::PI;
 
-use bevy::{pbr::CascadeShadowConfigBuilder, prelude::*};
+use bevy::{pbr::CascadeShadowConfigBuilder, prelude::*, render::camera::ExposureSettings};
 
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
         .add_systems(Startup, setup)
-        .add_systems(Update, (movement, animate_light_direction))
+        .add_systems(Update, (update_exposure, movement, animate_light_direction))
         .run();
 }
 
@@ -207,6 +207,7 @@ fn setup(
     // directional 'sun' light
     commands.spawn(DirectionalLightBundle {
         directional_light: DirectionalLight {
+            illuminance: 1000.0,
             shadows_enabled: true,
             ..default()
         },
@@ -227,11 +228,101 @@ fn setup(
         ..default()
     });
 
+    let exposure_settings = ExposureSettings::default();
+    let style = TextStyle {
+        font: asset_server.load("fonts/FiraMono-Medium.ttf"),
+        font_size: 18.0,
+        color: Color::WHITE,
+    };
+
+    commands.spawn(
+        TextBundle::from_sections(vec![
+            TextSection::new(
+                format!("Aperture: f/{:.0}\n", exposure_settings.aperture_f_stops),
+                style.clone(),
+            ),
+            TextSection::new(
+                format!(
+                    "Shutter speed: 1/{:.0}s\n",
+                    1.0 / exposure_settings.shutter_speed_s
+                ),
+                style.clone(),
+            ),
+            TextSection::new(
+                format!(
+                    "Sensitivity: ISO {:.0}\n",
+                    exposure_settings.sensitivity_iso
+                ),
+                style.clone(),
+            ),
+            TextSection::new("\n\n", style.clone()),
+            TextSection::new("Controls\n", style.clone()),
+            TextSection::new("---------------\n", style.clone()),
+            TextSection::new("1/2 - Decrease/Increase aperture\n", style.clone()),
+            TextSection::new("3/4 - Decrease/Increase shutter speed\n", style.clone()),
+            TextSection::new("5/6 - Decrease/Increase sensitivity\n", style),
+        ])
+        .with_style(Style {
+            position_type: PositionType::Absolute,
+            top: Val::Px(10.0),
+            left: Val::Px(10.0),
+            ..default()
+        }),
+    );
+
     // camera
-    commands.spawn(Camera3dBundle {
-        transform: Transform::from_xyz(-2.0, 2.5, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
-        ..default()
-    });
+    commands.spawn((
+        Camera3dBundle {
+            transform: Transform::from_xyz(-2.0, 2.5, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
+            ..default()
+        },
+        exposure_settings,
+    ));
+}
+
+fn update_exposure(
+    key_input: Res<Input<KeyCode>>,
+    mut query: Query<&mut ExposureSettings>,
+    mut text: Query<&mut Text>,
+) {
+    let mut text = text.single_mut();
+    let mut exposure_settings = query.single_mut();
+    if key_input.just_pressed(KeyCode::Key2) {
+        exposure_settings.aperture_f_stops *= 2.0;
+        text.sections[0].value = format!("Aperture: f/{:.0}\n", exposure_settings.aperture_f_stops);
+    } else if key_input.just_pressed(KeyCode::Key1) {
+        exposure_settings.aperture_f_stops *= 0.5;
+        text.sections[0].value = format!("Aperture: f/{:.0}\n", exposure_settings.aperture_f_stops);
+    }
+    if key_input.just_pressed(KeyCode::Key4) {
+        exposure_settings.shutter_speed_s *= 2.0;
+        text.sections[1].value = format!(
+            "Shutter speed: 1/{:.0}s\n",
+            1.0 / exposure_settings.shutter_speed_s
+        );
+    } else if key_input.just_pressed(KeyCode::Key3) {
+        exposure_settings.shutter_speed_s *= 0.5;
+        text.sections[1].value = format!(
+            "Shutter speed: 1/{:.0}s\n",
+            1.0 / exposure_settings.shutter_speed_s
+        );
+    }
+    if key_input.just_pressed(KeyCode::Key6) {
+        exposure_settings.sensitivity_iso += 100.0;
+        text.sections[2].value = format!(
+            "Sensitivity: ISO {:.0}\n",
+            exposure_settings.sensitivity_iso
+        );
+    } else if key_input.just_pressed(KeyCode::Key5) {
+        exposure_settings.sensitivity_iso -= 100.0;
+        text.sections[2].value = format!(
+            "Sensitivity: ISO {:.0}\n",
+            exposure_settings.sensitivity_iso
+        );
+    }
+    if key_input.just_pressed(KeyCode::D) {
+        *exposure_settings = ExposureSettings::default();
+    }
 }
 
 fn animate_light_direction(