Struct ScreenSpaceReflections

pub struct ScreenSpaceReflections {
    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, they also need the DepthPrepass and DeferredPrepass components, which are inserted automatically.

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. An alternative that doesn’t suffer from this problem is the combination of a LightProbe and EnvironmentMapLight. 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 ScreenSpaceReflections

fn clone(&self) -> ScreenSpaceReflections

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Component for ScreenSpaceReflections

where ScreenSpaceReflections: Send + Sync + 'static,

Required Components: DepthPrepass, DeferredPrepass.

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.

fn register_required_components( requiree: ComponentId, components: &mut Components, storages: &mut Storages, required_components: &mut RequiredComponents, inheritance_depth: u16, )

Registers required components.

fn register_component_hooks(hooks: &mut ComponentHooks)

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

impl Default for ScreenSpaceReflections

fn default() -> ScreenSpaceReflections

Returns the “default value” for a type.

impl ExtractComponent for ScreenSpaceReflections

type QueryData = &'static ScreenSpaceReflections

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: <<ScreenSpaceReflections as ExtractComponent>::QueryData as WorldQuery>::Item<'_>, ) -> Option<<ScreenSpaceReflections as ExtractComponent>::Out>

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

impl From<ScreenSpaceReflections> for ScreenSpaceReflectionsUniform

fn from(settings: ScreenSpaceReflections) -> ScreenSpaceReflectionsUniform

Converts to this type from the input type.

impl FromReflect for ScreenSpaceReflections

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

fn from_reflect( reflect: &(dyn PartialReflect + 'static), ) -> Option<ScreenSpaceReflections>

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 ScreenSpaceReflections

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

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

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

Returns the TypeInfo of the type represented by this value.

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

Clones the value as a Reflect trait object.

fn try_apply( &mut self, value: &(dyn PartialReflect + '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<ScreenSpaceReflections>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn try_into_reflect( self: Box<ScreenSpaceReflections>, ) -> 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 + 'static)>

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

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

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

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

Casts this type to a boxed, reflected value.

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

Casts this type to a reflected value.

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

Casts this type to a mutable, reflected value.

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

Returns a “partial equality” comparison result.

fn apply(&mut self, value: &(dyn PartialReflect + '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 Reflect for ScreenSpaceReflections

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

fn into_any(self: Box<ScreenSpaceReflections>) -> 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<ScreenSpaceReflections>) -> Box<dyn Reflect>

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

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

Casts this type to a fully-reflected value.

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

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 ScreenSpaceReflections

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

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

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 + 'static)>

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 + 'static)>

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 + 'static)>

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

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 ScreenSpaceReflections

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

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

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.

impl Copy for ScreenSpaceReflections