Struct AutoExposure

Help

pub struct AutoExposure {
    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 AutoExposureCopy item path

§Usage Notes

Fields§

§Usage Notes

Trait Implementations§

impl Clone for AutoExposure

fn clone(&self) -> AutoExposure

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

impl Component for AutoExposurewhere Self: Send + Sync + 'static,

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

fn register_required_components( requiree: ComponentId, components: &mut Components, storages: &mut Storages, required_components: &mut RequiredComponents, inheritance_depth: u16, )

fn register_component_hooks(hooks: &mut ComponentHooks)

impl Default for AutoExposure

fn default() -> Self

impl ExtractComponent for AutoExposurewhere Self: Clone,

type QueryData = &'static AutoExposure

type QueryFilter = ()

type Out = AutoExposure

fn extract_component(item: QueryItem<'_, Self::QueryData>) -> Option<Self::Out>

fn from_reflect(reflect: &dyn PartialReflect) -> Option<Self>

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

fn get_type_registration() -> TypeRegistration

fn register_type_dependencies(registry: &mut TypeRegistry)

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

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

fn try_apply(&mut self, value: &dyn PartialReflect) -> Result<(), ApplyError>

fn reflect_kind(&self) -> ReflectKind

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

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

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

fn try_into_reflect( self: Box<Self>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&dyn Reflect>

fn try_as_reflect_mut(&mut self) -> Option<&mut dyn Reflect>

fn into_partial_reflect(self: Box<Self>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &dyn PartialReflect

fn as_partial_reflect_mut(&mut self) -> &mut dyn PartialReflect

fn reflect_partial_eq(&self, value: &dyn PartialReflect) -> Option<bool>

fn apply(&mut self, value: &(dyn PartialReflect + '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 into_any(self: Box<Self>) -> Box<dyn Any>

fn as_any(&self) -> &dyn Any

fn as_any_mut(&mut self) -> &mut dyn Any

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

fn as_reflect(&self) -> &dyn Reflect

fn as_reflect_mut(&mut self) -> &mut dyn Reflect

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

fn field(&self, name: &str) -> Option<&dyn PartialReflect>

fn field_mut(&mut self, name: &str) -> Option<&mut dyn PartialReflect>

fn field_at(&self, index: usize) -> Option<&dyn PartialReflect>

fn field_at_mut(&mut self, index: usize) -> Option<&mut dyn PartialReflect>

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

fn field_len(&self) -> usize

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

fn clone_dynamic(&self) -> DynamicStruct

fn get_represented_struct_info(&self) -> Option<&'static StructInfo>

impl TypePath for AutoExposurewhere AutoExposure: 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 AutoExposure

impl !RefUnwindSafe for AutoExposure

impl Send for AutoExposure

impl Sync for AutoExposure

impl Unpin for AutoExposure

impl !UnwindSafe for AutoExposure

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,

Struct AutoExposure

impl Component for AutoExposure
where Self: Send + Sync + 'static,

impl ExtractComponent for AutoExposure
where Self: Clone,

impl TypePath for AutoExposure
where AutoExposure: 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> CloneToUninit for T
where T: Clone,

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> DynamicTyped for T
where T: Typed,

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>,

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

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

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