Enum ParallaxCorrection 

pub enum ParallaxCorrection {
    None,
    Auto,
    Custom(Vec3),
}

Add this component to a reflection probe to customize parallax correction.

For environment maps added directly to a camera, Bevy renders the reflected scene that a cubemap captures as though it were infinitely far away. This is acceptable if the cubemap captures very distant objects, such as distant mountains in outdoor scenes. It’s less ideal, however, if the cubemap reflects near objects, such as the interior of a room. Therefore, by default for reflection probes Bevy uses parallax-corrected cubemaps (PCCM), which causes Bevy to treat the reflected scene as though it coincided with the boundaries of the light probe.

As an example, for indoor scenes, it’s common to place reflection probes inside each room and to make the boundaries of the reflection probe (as determined by the light probe’s bevy_transform::components::Transform) coincide with the walls of the room. That way, the reflection probes will (1) apply to the objects inside the room and (2) take the positions of those objects into account in order to create a realistic reflection.

Instead of having the simulated boundaries of the reflected area coincide with the boundaries of the light probe, it’s also possible to specify custom parallax correction boundaries, so that the region of influence of the light probe doesn’t correspond with the simulated boundaries used for parallax correction. This is commonly used when the boundaries of the light probe are slightly larger than the room that the light probe contains, for instance in order to avoid artifacts along the edges of the room that occur due to rounding error, or else when the falloff feature is used that blends reflection probes into adjacent ones.

Place this component on an entity that has a LightProbe and EnvironmentMapLight component in order to either (1) opt out of parallax correction via ParallaxCorrection::None or (2) specify custom parallax correction boundaries via ParallaxCorrection::Custom. If you don’t manually place this component on a reflection probe, Bevy will automatically add a ParallaxCorrection::Auto component so that the boundaries of the light probe will coincide with the simulated boundaries used for parallax correction.

See the pccm example for an example of usage of parallax-corrected cubemaps and the light_probe_blending example for an example of use of custom parallax correction boundaries.

Variants

None

No parallax correction is used.

This component causes Bevy to render the reflection as though the reflected surface were infinitely distant.

Auto

The parallax correction boundaries correspond with the boundaries of the light probe.

This is the default value. Bevy automatically adds this component value to reflection probes that don’t have a ParallaxCorrection component. It’s equivalent to ParallaxCorrection::Custom(Vec3::splat(0.5)).

Custom(Vec3)

The parallax correction boundaries are specified manually.

The simulated reflection boundaries are specified as an axis-aligned cube in light probe space with the given half extents. Thus, for example, if you set the parallax correction boundaries to vec3(0.5, 1.0, 2.0) and the scale of the light probe is vec3(3.0, 3.0, 3.0), then the simulated boundaries of the reflected area used for parallax correction will be centered on the reflection probe with a width of 3.0 m, a height of 6.0 m, and a depth of 12.0 m.

Trait Implementations

impl Clone for ParallaxCorrection

fn clone(&self) -> ParallaxCorrection

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Component for ParallaxCorrection

where ParallaxCorrection: Send + Sync + 'static,

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, required_components: &mut RequiredComponentsRegistrator<'_, '_>, )

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 map_entities<M>(this: &mut ParallaxCorrection, mapper: &mut M)

where M: 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]

fn relationship_accessor() -> Option<ComponentRelationshipAccessor<ParallaxCorrection>>

Returns ComponentRelationshipAccessor required for working with relationships in dynamic contexts.

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_discard() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_discard 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.

impl Copy for ParallaxCorrection

impl Default for ParallaxCorrection

fn default() -> ParallaxCorrection

Returns the “default value” for a type.

impl Enum for ParallaxCorrection

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

Returns a reference to the value of the field (in the current variant) with the given name.

fn field_at( &self, __index_param: usize, ) -> Option<&(dyn PartialReflect + 'static)>

Returns a reference to the value of the field (in the current variant) at the given index.

fn field_mut( &mut self, __name_param: &str, ) -> Option<&mut (dyn PartialReflect + 'static)>

Returns a mutable reference to the value of the field (in the current variant) with the given name.

fn field_at_mut( &mut self, __index_param: usize, ) -> Option<&mut (dyn PartialReflect + 'static)>

Returns a mutable reference to the value of the field (in the current variant) at the given index.

fn index_of(&self, __name_param: &str) -> Option<usize>

Returns the index of the field (in the current variant) with the given name.

fn name_at(&self, __index_param: usize) -> Option<&str>

Returns the name of the field (in the current variant) with the given index.

fn iter_fields(&self) -> VariantFieldIter<'_>

Returns an iterator over the values of the current variant’s fields.

fn field_len(&self) -> usize

Returns the number of fields in the current variant.

fn variant_name(&self) -> &str

The name of the current variant.

fn variant_index(&self) -> usize

The index of the current variant.

fn variant_type(&self) -> VariantType

The type of the current variant.

fn to_dynamic_enum(&self) -> DynamicEnum

Creates a new DynamicEnum from this enum.

fn is_variant(&self, variant_type: VariantType) -> bool

Returns true if the current variant’s type matches the given one.

fn variant_path(&self) -> String

Returns the full path to the current variant.

fn get_represented_enum_info(&self) -> Option<&'static EnumInfo>

Will return None if TypeInfo is not available.

impl FromReflect for ParallaxCorrection

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

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 ParallaxCorrection

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 ParallaxCorrection

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_param: &(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<ParallaxCorrection>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn try_into_reflect( self: Box<ParallaxCorrection>, ) -> 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<ParallaxCorrection>, ) -> 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_hash(&self) -> Option<u64>

Returns a hash of the value (which includes the type).

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

Returns a “partial equality” comparison result.

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

Returns a “partial 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 to_dynamic(&self) -> Box<dyn PartialReflect>

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

fn reflect_clone_and_take<T>(&self) -> Result<T, ReflectCloneError>

where T: 'static, Self: Sized + TypePath,

For a type implementing PartialReflect, combines reflect_clone and take in a useful fashion, automatically constructing an appropriate ReflectCloneError if the downcast fails.

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 ParallaxCorrection

fn into_any(self: Box<ParallaxCorrection>) -> 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<ParallaxCorrection>) -> 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 TypePath for ParallaxCorrection

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 ParallaxCorrection

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.