Struct Bloom

Source

pub struct Bloom {
    pub intensity: f32,
    pub low_frequency_boost: f32,
    pub low_frequency_boost_curvature: f32,
    pub high_pass_frequency: f32,
    pub prefilter: BloomPrefilter,
    pub composite_mode: BloomCompositeMode,
    pub max_mip_dimension: u32,
    pub scale: Vec2,
}

Expand description

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.

§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 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: BloomPrefilter

Controls the threshold filter used for extracting the brightest regions from the input image before blurring them and compositing back onto the original image.

Changing these settings creates a physically inaccurate image and makes it easy to make the final result look worse. However, they can be useful when emulating the 1990s-2000s game look. See BloomPrefilter for more information.

§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 is used.

§Recommendation

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

§max_mip_dimension: u32

Maximum size of each dimension for the largest mipchain texture used in downscaling/upscaling. Only tweak if you are seeing visual artifacts.

§scale: Vec2

Amount to stretch the bloom on each axis. Artistic control, can be used to emulate anamorphic blur by using a large x-value. For large values, you may need to increase Bloom::max_mip_dimension to reduce sampling artifacts.

Struct BloomCopy item path

§Usage Notes

Fields§

§In energy-conserving mode

§In additive mode

§In energy-conserving mode

§In additive mode

§Recommendation

Implementations§

impl Bloom

pub const NATURAL: Self

pub const ANAMORPHIC: Self

pub const OLD_SCHOOL: Self

pub const SCREEN_BLUR: Self

Trait Implementations§

impl Clone for Bloom

fn clone(&self) -> Bloom

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

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

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

type Mutability = Mutable

fn register_required_components( requiree: ComponentId, components: &mut ComponentsRegistrator<'_>, required_components: &mut RequiredComponents, inheritance_depth: u16, recursion_check_stack: &mut Vec<ComponentId>, )

fn clone_behavior() -> ComponentCloneBehavior

fn register_component_hooks(hooks: &mut ComponentHooks)

fn on_add() -> Option<for<'w> fn(_: DeferredWorld<'w>, _: HookContext)>

fn on_insert() -> Option<for<'w> fn(_: DeferredWorld<'w>, _: HookContext)>

fn on_replace() -> Option<for<'w> fn(_: DeferredWorld<'w>, _: HookContext)>

fn on_remove() -> Option<for<'w> fn(_: DeferredWorld<'w>, _: HookContext)>

fn on_despawn() -> Option<for<'w> fn(_: DeferredWorld<'w>, _: HookContext)>

fn map_entities<E>(_this: &mut Self, _mapper: &mut E)where E: EntityMapper,

impl Default for Bloom

fn default() -> Self

impl ExtractComponent for Bloom

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

type QueryFilter = ()

type Out = (Bloom, BloomUniforms)

fn extract_component( (bloom, camera): 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 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 reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

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

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

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

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

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

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 to_dynamic_struct(&self) -> DynamicStruct

fn clone_dynamic(&self) -> DynamicStruct

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

impl TypePath for Bloomwhere Bloom: Any + Send + Sync,

fn type_path() -> &'static str

Struct Bloom

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

fn map_entities<E>(_this: &mut Self, _mapper: &mut E)
where E: EntityMapper,

impl TypePath for Bloom
where Bloom: 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,

impl<C> BundleFromComponents 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> DowncastSend for T
where T: Any + Send,

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,