Struct bevy::pbr::ScreenSpaceReflectionsSettings

pub struct ScreenSpaceReflectionsSettings {
    pub perceptual_roughness_threshold: f32,
    pub thickness: f32,
    pub linear_steps: u32,
    pub linear_march_exponent: f32,
    pub bisection_steps: u32,
    pub use_secant: bool,
}

Add this component to a camera to enable screen-space reflections (SSR).

Screen-space reflections currently require deferred rendering in order to appear. Therefore, you’ll generally need to add a DepthPrepass and a DeferredPrepass to the camera as well.

SSR currently performs no roughness filtering for glossy reflections, so only very smooth surfaces will reflect objects in screen space. You can adjust the perceptual_roughness_threshold in order to tune the threshold below which screen-space reflections will be traced.

As with all screen-space techniques, SSR can only reflect objects on screen. When objects leave the camera, they will disappear from reflections. Alternatives that don’t suffer from this problem include crate::environment_map::ReflectionProbeBundles. The advantage of SSR is that it can reflect all objects, not just static ones.

SSR is an approximation technique and produces artifacts in some situations. Hand-tuning the settings in this component will likely be useful.

Screen-space reflections are presently unsupported on WebGL 2 because of a bug whereby Naga doesn’t generate correct GLSL when sampling depth buffers, which is required for screen-space raymarching.

Fields

perceptual_roughness_threshold: f32

The maximum PBR roughness level that will enable screen space reflections.

thickness: f32

When marching the depth buffer, we only have 2.5D information and don’t know how thick surfaces are. We shall assume that the depth buffer fragments are cuboids with a constant thickness defined by this parameter.

linear_steps: u32

The number of steps to be taken at regular intervals to find an initial intersection. Must not be zero.

Higher values result in higher-quality reflections, because the raymarching shader is less likely to miss objects. However, they take more GPU time.

linear_march_exponent: f32

Exponent to be applied in the linear part of the march.

A value of 1.0 will result in equidistant steps, and higher values will compress the earlier steps, and expand the later ones. This might be desirable in order to get more detail close to objects.

For optimal performance, this should be a small unsigned integer, such as 1 or 2.

bisection_steps: u32

Number of steps in a bisection (binary search) to perform once the linear search has found an intersection. Helps narrow down the hit, increasing the chance of the secant method finding an accurate hit point.

use_secant: bool

Approximate the root position using the secant method—by solving for line-line intersection between the ray approach rate and the surface gradient.

Trait Implementations

impl Clone for ScreenSpaceReflectionsSettings

fn clone(&self) -> ScreenSpaceReflectionsSettings

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Component for ScreenSpaceReflectionsSettings

where ScreenSpaceReflectionsSettings: 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 Default for ScreenSpaceReflectionsSettings

fn default() -> ScreenSpaceReflectionsSettings

Returns the “default value” for a type.

impl ExtractComponent for ScreenSpaceReflectionsSettings

type QueryData = &'static ScreenSpaceReflectionsSettings

ECS ReadOnlyQueryData to fetch the components to extract.

type QueryFilter = ()

Filters the entities with additional constraints.

type Out = ScreenSpaceReflectionsUniform

The output from extraction.

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

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

impl From<ScreenSpaceReflectionsSettings> for ScreenSpaceReflectionsUniform

fn from( settings: ScreenSpaceReflectionsSettings ) -> ScreenSpaceReflectionsUniform

Converts to this type from the input type.

impl FromReflect for ScreenSpaceReflectionsSettings

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

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

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 ScreenSpaceReflectionsSettings

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

where ScreenSpaceReflectionsSettings: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection, u32: FromReflect + TypePath + RegisterForReflection, bool: 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<ScreenSpaceReflectionsSettings>) -> 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<ScreenSpaceReflectionsSettings>) -> 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 try_apply( &mut self, value: &(dyn Reflect + 'static) ) -> 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<ScreenSpaceReflectionsSettings>) -> 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 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 Struct for ScreenSpaceReflectionsSettings

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

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 ScreenSpaceReflectionsSettings

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

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

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.

impl Copy for ScreenSpaceReflectionsSettings