Struct bevy::core_pipeline::auto_exposure::AutoExposureSettings

source ·

pub struct AutoExposureSettings {
    pub range: RangeInclusive<f32>,
    pub filter: RangeInclusive<f32>,
    pub speed_brighten: f32,
    pub speed_darken: f32,
    pub exponential_transition_distance: f32,
    pub metering_mask: Handle<Image>,
    pub compensation_curve: Handle<AutoExposureCompensationCurve>,
}

Expand description

Component that enables auto exposure for an HDR-enabled 2d or 3d camera.

Auto exposure adjusts the exposure of the camera automatically to simulate the human eye’s ability to adapt to different lighting conditions.

Bevy’s implementation builds a 64 bin histogram of the scene’s luminance, and then adjusts the exposure so that the average brightness of the final render will be middle gray. Because it’s using a histogram, some details can be selectively ignored or emphasized. Outliers like shadows and specular highlights can be ignored, and certain areas can be given more (or less) weight based on a mask.

§Usage Notes

Auto Exposure requires compute shaders and is not compatible with WebGL2.

Fields§

§range: RangeInclusive<f32>

The range of exposure values for the histogram.

Pixel values below this range will be ignored, and pixel values above this range will be clamped in the sense that they will count towards the highest bin in the histogram. The default value is -8.0..=8.0.

§filter: RangeInclusive<f32>

The portion of the histogram to consider when metering.

By default, the darkest 10% and the brightest 10% of samples are ignored, so the default value is 0.10..=0.90.

§speed_brighten: f32

The speed at which the exposure adapts from dark to bright scenes, in F-stops per second.

§speed_darken: f32

The speed at which the exposure adapts from bright to dark scenes, in F-stops per second.

§exponential_transition_distance: f32

The distance in F-stops from the target exposure from where to transition from animating in linear fashion to animating exponentially. This helps against jittering when the target exposure keeps on changing slightly from frame to frame, while still maintaining a relatively slow animation for big changes in scene brightness.

ev
                      ➔●┐
|              ⬈         ├ exponential section
│        ⬈               ┘
│    ⬈                   ┐
│  ⬈                     ├ linear section
│⬈                       ┘
●───────────────────────── time

The default value is 1.5.

§metering_mask: Handle<Image>

The mask to apply when metering. The mask will cover the entire screen, where:

(0.0, 0.0) is the top-left corner,
(1.0, 1.0) is the bottom-right corner. Only the red channel of the texture is used. The sample at the current screen position will be used to weight the contribution of each pixel to the histogram:
0.0 means the pixel will not contribute to the histogram,
1.0 means the pixel will contribute fully to the histogram.

The default value is a white image, so all pixels contribute equally.

§Usage Notes

The mask is quantized to 16 discrete levels because of limitations in the compute shader implementation.

§compensation_curve: Handle<AutoExposureCompensationCurve>

Exposure compensation curve to apply after metering. The default value is a flat line at 0.0. For more information, see AutoExposureCompensationCurve.

Struct bevy::core_pipeline::auto_exposure::AutoExposureSettingsCopy item path

§Usage Notes

Fields§

§Usage Notes

Trait Implementations§

impl Clone for AutoExposureSettings

fn clone(&self) -> AutoExposureSettings

fn clone_from(&mut self, source: &Self)

impl Component for AutoExposureSettingswhere AutoExposureSettings: Send + Sync + 'static,

const STORAGE_TYPE: StorageType = bevy_ecs::component::StorageType::Table

fn register_component_hooks(_hooks: &mut ComponentHooks)

impl Default for AutoExposureSettings

fn default() -> AutoExposureSettings

impl ExtractComponent for AutoExposureSettingswhere AutoExposureSettings: Clone,

type QueryData = &'static AutoExposureSettings

type QueryFilter = ()

type Out = AutoExposureSettings

fn extract_component( item: <<AutoExposureSettings as ExtractComponent>::QueryData as WorldQuery>::Item<'_> ) -> Option<<AutoExposureSettings as ExtractComponent>::Out>

fn from_reflect( reflect: &(dyn Reflect + 'static) ) -> Option<AutoExposureSettings>

fn take_from_reflect( reflect: Box<dyn Reflect> ) -> Result<Self, Box<dyn Reflect>>

fn get_type_registration() -> TypeRegistration

fn register_type_dependencies(registry: &mut TypeRegistry)

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

fn into_any(self: Box<AutoExposureSettings>) -> Box<dyn Any>

fn as_any(&self) -> &(dyn Any + 'static)

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

fn into_reflect(self: Box<AutoExposureSettings>) -> Box<dyn Reflect>

fn as_reflect(&self) -> &(dyn Reflect + 'static)

fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)

fn clone_value(&self) -> Box<dyn Reflect>

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

fn try_apply( &mut self, value: &(dyn Reflect + 'static) ) -> Result<(), ApplyError>

fn reflect_kind(&self) -> ReflectKind

fn reflect_ref(&self) -> ReflectRef<'_>

fn reflect_mut(&mut self) -> ReflectMut<'_>

fn reflect_owned(self: Box<AutoExposureSettings>) -> ReflectOwned

fn reflect_partial_eq(&self, value: &(dyn Reflect + 'static)) -> Option<bool>

fn apply(&mut self, value: &(dyn Reflect + 'static))

fn reflect_hash(&self) -> Option<u64>

fn debug(&self, f: &mut Formatter<'_>) -> Result<(), Error>

fn serializable(&self) -> Option<Serializable<'_>>

fn is_dynamic(&self) -> bool

fn field(&self, name: &str) -> Option<&(dyn Reflect + 'static)>

fn field_mut(&mut self, name: &str) -> Option<&mut (dyn Reflect + 'static)>

fn field_at(&self, index: usize) -> Option<&(dyn Reflect + 'static)>

fn field_at_mut(&mut self, index: usize) -> Option<&mut (dyn Reflect + 'static)>

fn name_at(&self, index: usize) -> Option<&str>

fn field_len(&self) -> usize

fn iter_fields(&self) -> FieldIter<'_> ⓘ

fn clone_dynamic(&self) -> DynamicStruct

impl TypePath for AutoExposureSettingswhere AutoExposureSettings: Any + Send + Sync,

fn type_path() -> &'static str

fn short_type_path() -> &'static str

fn type_ident() -> Option<&'static str>

fn crate_name() -> Option<&'static str>

fn module_path() -> Option<&'static str>

fn type_info() -> &'static TypeInfo

Auto Trait Implementations§

impl Freeze for AutoExposureSettings

impl !RefUnwindSafe for AutoExposureSettings

impl Send for AutoExposureSettings

impl Sync for AutoExposureSettings

impl Unpin for AutoExposureSettings

impl !UnwindSafe for AutoExposureSettings

Blanket Implementations§

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T, U> AsBindGroupShaderType<U> for Twhere U: ShaderType, &'a T: for<'a> Into<U>,

fn as_bind_group_shader_type(&self, _images: &RenderAssets<GpuImage>) -> U

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<C> Bundle for Cwhere C: Component,

fn component_ids( components: &mut Components, storages: &mut Storages, ids: &mut impl FnMut(ComponentId) )

unsafe fn from_components<T, F>(ctx: &mut T, func: &mut F) -> Cwhere F: for<'a> FnMut(&'a mut T) -> OwningPtr<'a>,

fn get_component_ids( components: &Components, ids: &mut impl FnMut(Option<ComponentId>) )

impl<T> Downcast<T> for T

fn downcast(&self) -> &T

impl<T> Downcast for Twhere T: Any,

Struct bevy::core_pipeline::auto_exposure::AutoExposureSettings

impl Component for AutoExposureSettings
where AutoExposureSettings: Send + Sync + 'static,

impl ExtractComponent for AutoExposureSettings
where AutoExposureSettings: Clone,

impl TypePath for AutoExposureSettings
where AutoExposureSettings: Any + Send + Sync,

impl<T> Any for T
where T: 'static + ?Sized,

impl<T, U> AsBindGroupShaderType<U> for T
where U: ShaderType, &'a T: for<'a> Into<U>,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

impl<C> Bundle for C
where C: Component,

unsafe fn from_components<T, F>(ctx: &mut T, func: &mut F) -> C
where F: for<'a> FnMut(&'a mut T) -> OwningPtr<'a>,

impl<T> Downcast for T
where T: Any,

impl<T> DowncastSync for T
where T: Any + Send + Sync,

impl<C> DynamicBundle for C
where C: Component,

impl<T> DynamicTypePath for T
where T: TypePath,

impl<T> FromWorld for T
where T: Default,

impl<S> GetField for S
where S: Struct,

fn get_field<T>(&self, name: &str) -> Option<&T>
where T: Reflect,

fn get_field_mut<T>(&mut self, name: &str) -> Option<&mut T>
where T: Reflect,

impl<T> GetPath for T
where T: Reflect + ?Sized,

fn path<'p, T>( &self, path: impl ReflectPath<'p> ) -> Result<&T, ReflectPathError<'p>>
where T: Reflect,

fn path_mut<'p, T>( &mut self, path: impl ReflectPath<'p> ) -> Result<&mut T, ReflectPathError<'p>>
where T: Reflect,

impl<T, U> Into<U> for T
where U: From<T>,

impl<T> ToOwned for T
where T: Clone,

impl<T, U> ToSample<U> for T
where U: FromSample<T>,

impl<T, U> TryFrom<U> for T
where U: Into<T>,

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

impl<T> TypeData for T
where T: 'static + Send + Sync + Clone,

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> ⓘ
where S: Into<Dispatch>,

impl<T> ConditionalSend for T
where T: Send,

impl<S, T> Duplex<S> for T
where T: FromSample<S> + ToSample<S>,

impl<T> Settings for T
where T: 'static + Send + Sync,

impl<T> WasmNotSend for T
where T: Send,

impl<T> WasmNotSendSync for T
where T: WasmNotSend + WasmNotSync,

impl<T> WasmNotSync for T
where T: Sync,