Struct MotionBlur

pub struct MotionBlur {
    pub shutter_angle: f32,
    pub samples: u32,
}

A component that enables and configures motion blur when added to a camera.

Motion blur is an effect that simulates how moving objects blur as they change position during the exposure of film, a sensor, or an eyeball.

Because rendering simulates discrete steps in time, we use per-pixel motion vectors to estimate the path of objects between frames. This kind of implementation has some artifacts:

• Fast moving objects in front of a stationary object or when in front of empty space, will not have their edges blurred.
• Transparent objects do not write to depth or motion vectors, so they cannot be blurred.

Other approaches, such as A Reconstruction Filter for Plausible Motion Blur produce more correct results, but are more expensive and complex, and have other kinds of artifacts. This implementation is relatively inexpensive and effective.

Usage

Add the MotionBlur component to a camera to enable and configure motion blur for that camera.

commands.spawn((
    Camera3d::default(),
    MotionBlur::default(),
));

Fields

shutter_angle: f32

The strength of motion blur from 0.0 to 1.0.

The shutter angle describes the fraction of a frame that a camera’s shutter is open and exposing the film/sensor. For 24fps cinematic film, a shutter angle of 0.5 (180 degrees) is common. This means that the shutter was open for half of the frame, or 1/48th of a second. The lower the shutter angle, the less exposure time and thus less blur.

A value greater than one is non-physical and results in an object’s blur stretching further than it traveled in that frame. This might be a desirable effect for artistic reasons, but consider allowing users to opt out of this.

This value is intentionally tied to framerate to avoid the aforementioned non-physical over-blurring. If you want to emulate a cinematic look, your options are:

• Framelimit your app to 24fps, and set the shutter angle to 0.5 (180 deg). Note that depending on artistic intent or the action of a scene, it is common to set the shutter angle between 0.125 (45 deg) and 0.5 (180 deg). This is the most faithful way to reproduce the look of film.
• Set the shutter angle greater than one. For example, to emulate the blur strength of film while rendering at 60fps, you would set the shutter angle to 60/24 * 0.5 = 1.25. Note that this will result in artifacts where the motion of objects will stretch further than they moved between frames; users may find this distracting.

samples: u32

The quality of motion blur, corresponding to the number of per-pixel samples taken in each direction during blur.

Setting this to 1 results in each pixel being sampled once in the leading direction, once in the trailing direction, and once in the middle, for a total of 3 samples (1 * 2 + 1). Setting this to 3 will result in 3 * 2 + 1 = 7 samples. Setting this to 0 is equivalent to disabling motion blur.

Trait Implementations

impl Clone for MotionBlur

fn clone(&self) -> MotionBlur

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Component for MotionBlur

where Self: Send + Sync + 'static,

Required Components: DepthPrepass, MotionVectorPrepass.

A component’s Required Components are inserted whenever it is inserted. Note that this will also insert the required components of the required components, recursively, in depth-first order.

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

A constant indicating the storage type used for this component.

type Mutability = Mutable

A marker type to assist Bevy with determining if this component is mutable, or immutable. Mutable components will have [Component<Mutability = Mutable>], while immutable components will instead have [Component<Mutability = Immutable>].

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

Registers required components.

fn clone_behavior() -> ComponentCloneBehavior

Called when registering this component, allowing to override clone function (or disable cloning altogether) for this component.

fn register_component_hooks(hooks: &mut ComponentHooks)

👎Deprecated since 0.16.0: Use the individual hook methods instead (e.g., Component::on_add, etc.)

Called when registering this component, allowing mutable access to its ComponentHooks.

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

Gets the on_add ComponentHook for this Component if one is defined.

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

Gets the on_insert ComponentHook for this Component if one is defined.

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

Gets the on_replace ComponentHook for this Component if one is defined.

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

Gets the on_remove ComponentHook for this Component if one is defined.

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

Gets the on_despawn ComponentHook for this Component if one is defined.

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

where E: EntityMapper,

Maps the entities on this component using the given EntityMapper. This is used to remap entities in contexts like scenes and entity cloning. When deriving Component, this is populated by annotating fields containing entities with #[entities]

impl Default for MotionBlur

fn default() -> Self

Returns the “default value” for a type.

impl ExtractComponent for MotionBlur

type QueryData = &'static MotionBlur

ECS ReadOnlyQueryData to fetch the components to extract.

type QueryFilter = With<Camera>

Filters the entities with additional constraints.

type Out = MotionBlurUniform

The output from extraction.

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

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

impl FromReflect for MotionBlur

where MotionBlur: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

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

Constructs a concrete instance of Self from a reflected value.

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

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

impl GetTypeRegistration for MotionBlur

where MotionBlur: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn get_type_registration() -> TypeRegistration

Returns the default TypeRegistration for this type.

fn register_type_dependencies(registry: &mut TypeRegistry)

Registers other types needed by this type.

impl PartialReflect for MotionBlur

where MotionBlur: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

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

Returns the TypeInfo of the type represented by this value.

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

Tries to apply 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<Self>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

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

Attempts to cast this type to a boxed, fully-reflected value.

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

Attempts to cast this type to a fully-reflected value.

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

Attempts to cast this type to a mutable, fully-reflected value.

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

Casts this type to a boxed, reflected value.

fn as_partial_reflect(&self) -> &dyn PartialReflect

Casts this type to a reflected value.

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

Casts this type to a mutable, reflected value.

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

Returns a “partial equality” comparison result.

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

Attempts to clone Self using reflection.

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

Applies a reflected value to this value.

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

👎Deprecated since 0.16.0: to clone reflected values, prefer using reflect_clone. To convert reflected values to dynamic ones, use to_dynamic.

Clones Self into its dynamic representation.

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

Converts this reflected value into its dynamic representation based on its kind.

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 is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

impl Reflect for MotionBlur

where MotionBlur: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

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

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &dyn Any

Returns the value as a &dyn Any.

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

Returns the value as a &mut dyn Any.

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

Casts this type to a boxed, fully-reflected value.

fn as_reflect(&self) -> &dyn Reflect

Casts this type to a fully-reflected value.

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

Casts this type to a mutable, fully-reflected value.

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

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

impl Struct for MotionBlur

where MotionBlur: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

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

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

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

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

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

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

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

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

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

fn clone_dynamic(&self) -> DynamicStruct

👎Deprecated since 0.16.0: use to_dynamic_struct instead

Clones the struct into a DynamicStruct.

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

Will return None if TypeInfo is not available.

impl TypePath for MotionBlur

where MotionBlur: 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 MotionBlur

where MotionBlur: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.