Struct bevy_core_pipeline::motion_blur::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. Motion blur also requires the depth and motion vector prepass, which can be added more easily to the camera with the MotionBlurBundle.

commands.spawn((
    Camera3dBundle::default(),
    MotionBlurBundle::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,

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

A constant indicating the storage type used for this component.

fn register_component_hooks(_hooks: &mut ComponentHooks)

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

impl CreateFrom for MotionBlur

where Self: ShaderType<ExtraMetadata = StructMetadata<2usize>>, for<'__> f32: CreateFrom, for<'__> u32: CreateFrom,

fn create_from<B: BufferRef>(reader: &mut Reader<B>) -> Self

impl Default for MotionBlur

fn default() -> Self

Returns the “default value” for a type.

impl ExtractComponent for MotionBlur

where Self: Clone,

type QueryData = &'static MotionBlur

ECS ReadOnlyQueryData to fetch the components to extract.

type QueryFilter = With<Camera>

Filters the entities with additional constraints.

type Out = MotionBlur

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 Self: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection, u32: FromReflect + TypePath + RegisterForReflection,

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

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 MotionBlur

where Self: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection, u32: FromReflect + TypePath + 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 ReadFrom for MotionBlur

where Self: ShaderType<ExtraMetadata = StructMetadata<2usize>>, for<'__> f32: ReadFrom, for<'__> u32: ReadFrom,

fn read_from<B: BufferRef>(&mut self, reader: &mut Reader<B>)

impl Reflect for MotionBlur

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

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

Returns the TypeInfo of the type represented by this value.

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 reflected value.

fn as_reflect(&self) -> &dyn Reflect

Casts this type to a reflected value.

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

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 try_apply(&mut self, value: &dyn Reflect) -> 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 reflect_partial_eq(&self, value: &dyn Reflect) -> Option<bool>

Returns a “partial equality” comparison result.

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

Applies a reflected value to this value.

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 ShaderSize for MotionBlur

where f32: ShaderSize, u32: ShaderSize,

const SHADER_SIZE: NonZero<u64> = _

Represents WGSL Size (equivalent to ShaderType::min_size)

impl ShaderType for MotionBlur

where f32: ShaderType + ShaderSize, u32: ShaderType,

fn size(&self) -> NonZeroU64

Returns the size of Self at runtime

fn min_size() -> NonZero<u64>

Represents the minimum size of Self (equivalent to GPUBufferBindingLayout.minBindingSize)

fn assert_uniform_compat()

Asserts that Self meets the requirements of the uniform address space restrictions on stored values and the uniform address space layout constraints

impl Struct for MotionBlur

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

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

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>

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>

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>

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 MotionBlur

where Self: 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 Self: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection, u32: FromReflect + TypePath + RegisterForReflection,

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.

impl WriteInto for MotionBlur

where Self: ShaderType<ExtraMetadata = StructMetadata<2usize>>, for<'__> f32: WriteInto, for<'__> u32: WriteInto,

fn write_into<B: BufferMut>(&self, writer: &mut Writer<B>)