Struct bevy_internal::core_pipeline::bloom::BloomSettings

pub struct BloomSettings {
    pub intensity: f32,
    pub low_frequency_boost: f32,
    pub low_frequency_boost_curvature: f32,
    pub high_pass_frequency: f32,
    pub prefilter_settings: BloomPrefilterSettings,
    pub composite_mode: BloomCompositeMode,
}

Applies a bloom effect to an HDR-enabled 2d or 3d camera.

Bloom emulates an effect found in real cameras and the human eye, causing halos to appear around very bright parts of the scene.

See also https://en.wikipedia.org/wiki/Bloom_(shader_effect).

Usage Notes

Bloom is currently not compatible with WebGL2.

Often used in conjunction with bevy_pbr::StandardMaterial::emissive for 3d meshes.

Bloom is best used alongside a tonemapping function that desaturates bright colors, such as crate::tonemapping::Tonemapping::TonyMcMapface.

Bevy’s implementation uses a parametric curve to blend between a set of blurred (lower frequency) images generated from the camera’s view. See https://starlederer.github.io/bloom/ for a visualization of the parametric curve used in Bevy as well as a visualization of the curve’s respective scattering profile.

Fields

intensity: f32

Controls the baseline of how much the image is scattered (default: 0.15).

This parameter should be used only to control the strength of the bloom for the scene as a whole. Increasing it too much will make the scene appear blurry and over-exposed.

To make a mesh glow brighter, rather than increase the bloom intensity, you should increase the mesh’s emissive value.

In energy-conserving mode

The value represents how likely the light is to scatter.

The value should be between 0.0 and 1.0 where:

• 0.0 means no bloom
• 1.0 means the light is scattered as much as possible

In additive mode

The value represents how much scattered light is added to the image to create the glow effect.

In this configuration:

• 0.0 means no bloom
• Greater than 0.0 means a proportionate amount of scattered light is added

low_frequency_boost: f32

Low frequency contribution boost. Controls how much more likely the light is to scatter completely sideways (low frequency image).

Comparable to a low shelf boost on an equalizer.

In energy-conserving mode

The value should be between 0.0 and 1.0 where:

• 0.0 means low frequency light uses base intensity for blend factor calculation
• 1.0 means low frequency light contributes at full power

In additive mode

The value represents how much scattered light is added to the image to create the glow effect.

In this configuration:

• 0.0 means no bloom
• Greater than 0.0 means a proportionate amount of scattered light is added

low_frequency_boost_curvature: f32

Low frequency contribution boost curve. Controls the curvature of the blend factor function making frequencies next to the lowest ones contribute more.

Somewhat comparable to the Q factor of an equalizer node.

Valid range:

• 0.0 - base base intensity and boosted intensity are linearly interpolated
• 1.0 - all frequencies below maximum are at boosted intensity level

high_pass_frequency: f32

Tightens how much the light scatters (default: 1.0).

Valid range:

• 0.0 - maximum scattering angle is 0 degrees (no scattering)
• 1.0 - maximum scattering angle is 90 degrees

prefilter_settings: BloomPrefilterSettings

composite_mode: BloomCompositeMode

Controls whether bloom textures are blended between or added to each other. Useful if image brightening is desired and a must-change if prefilter_settings are used.

Recommendation

Set to BloomCompositeMode::Additive if prefilter_settings are configured in a non-energy-conserving way, otherwise set to BloomCompositeMode::EnergyConserving.

Implementations

impl BloomSettings

pub const NATURAL: BloomSettings = _

The default bloom preset.

pub const OLD_SCHOOL: BloomSettings = _

A preset that’s similar to how older games did bloom.

pub const SCREEN_BLUR: BloomSettings = _

A preset that applies a very strong bloom, and blurs the whole screen.

Trait Implementations

impl Clone for BloomSettings

fn clone(&self) -> BloomSettings

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Component for BloomSettings

where BloomSettings: Send + Sync + 'static,

type Storage = TableStorage

A marker type indicating the storage type used for this component. This must be either TableStorage or SparseStorage.

impl Default for BloomSettings

fn default() -> BloomSettings

Returns the “default value” for a type.

impl ExtractComponent for BloomSettings

type QueryData = (&'static BloomSettings, &'static Camera)

ECS ReadOnlyQueryData to fetch the components to extract.

type QueryFilter = ()

Filters the entities with additional constraints.

type Out = (BloomSettings, BloomUniforms)

The output from extraction.

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

Defines how the component is transferred into the “render world”.

impl FromReflect for BloomSettings

where BloomSettings: Any + Send + Sync, f32: FromReflect + TypePath, BloomPrefilterSettings: FromReflect + TypePath, BloomCompositeMode: FromReflect + TypePath,

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

Constructs a concrete instance of Self from a reflected value.

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

Attempts to downcast the given value to Self using, constructing the value using from_reflect if that fails.

impl GetTypeRegistration for BloomSettings

where BloomSettings: Any + Send + Sync, f32: FromReflect + TypePath, BloomPrefilterSettings: FromReflect + TypePath, BloomCompositeMode: FromReflect + TypePath,

fn get_type_registration() -> TypeRegistration

impl Reflect for BloomSettings

where BloomSettings: Any + Send + Sync, f32: FromReflect + TypePath, BloomPrefilterSettings: FromReflect + TypePath, BloomCompositeMode: FromReflect + TypePath,

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

Returns the TypeInfo of the type represented by this value.

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

Returns the value as a Box<dyn Any>.

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

Returns the value as a &dyn Any.

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

Returns the value as a &mut dyn Any.

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

Casts this type to a boxed reflected value.

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

Casts this type to a reflected value.

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

Casts this type to a mutable reflected value.

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

Clones the value as a Reflect trait object.

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

Performs a type-checked assignment of a reflected value to this value.

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

Applies a reflected value to this value.

fn reflect_kind(&self) -> ReflectKind

Returns a zero-sized enumeration of “kinds” of type.

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

Returns an immutable enumeration of “kinds” of type.

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

Returns a mutable enumeration of “kinds” of type.

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

Returns an owned enumeration of “kinds” of type.

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

Returns a “partial equality” comparison result.

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

Returns a hash of the value (which includes the type).

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

Debug formatter for the value.

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

Returns a serializable version of the value.

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

impl Struct for BloomSettings

where BloomSettings: Any + Send + Sync, f32: FromReflect + TypePath, BloomPrefilterSettings: FromReflect + TypePath, BloomCompositeMode: FromReflect + TypePath,

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

Returns a reference to the value of the field named name as a &dyn Reflect.

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

Returns a mutable reference to the value of the field named name as a &mut dyn Reflect.

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

Returns a reference to the value of the field with index index as a &dyn Reflect.

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

Returns a mutable reference to the value of the field with index index as a &mut dyn Reflect.

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

Returns the name of the field with index index.

fn field_len(&self) -> usize

Returns the number of fields in the struct.

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

Returns an iterator over the values of the reflectable fields for this struct.

fn clone_dynamic(&self) -> DynamicStruct

Clones the struct into a DynamicStruct.

impl TypePath for BloomSettings

where BloomSettings: Any + Send + Sync,

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type.

fn short_type_path() -> &'static str

Returns a short, pretty-print enabled path to the type.

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

Returns the name of the type, or None if it is anonymous.

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

Returns the name of the crate the type is in, or None if it is anonymous.

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

Returns the path to the module the type is in, or None if it is anonymous.

impl Typed for BloomSettings

where BloomSettings: Any + Send + Sync, f32: FromReflect + TypePath, BloomPrefilterSettings: FromReflect + TypePath, BloomCompositeMode: FromReflect + TypePath,

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.