Struct Atmosphere

pub struct Atmosphere {
    pub bottom_radius: f32,
    pub top_radius: f32,
    pub ground_albedo: Vec3,
    pub rayleigh_density_exp_scale: f32,
    pub rayleigh_scattering: Vec3,
    pub mie_density_exp_scale: f32,
    pub mie_scattering: f32,
    pub mie_absorption: f32,
    pub mie_asymmetry: f32,
    pub ozone_layer_altitude: f32,
    pub ozone_layer_width: f32,
    pub ozone_absorption: Vec3,
}

This component describes the atmosphere of a planet, and when added to a camera will enable atmospheric scattering for that camera. This is only compatible with HDR cameras.

Most atmospheric particles scatter and absorb light in two main ways:

Rayleigh scattering occurs among very small particles, like individual gas molecules. It’s wavelength dependent, and causes colors to separate out as light travels through the atmosphere. These particles don’t absorb light.

Mie scattering occurs among slightly larger particles, like dust and sea spray. These particles do absorb light, but Mie scattering and absorption is wavelength independent.

Ozone acts differently from the other two, and is special-cased because it’s very important to the look of Earth’s atmosphere. It’s wavelength dependent, but only absorbs light. Also, while the density of particles participating in Rayleigh and Mie scattering falls off roughly exponentially from the planet’s surface, ozone only exists in a band centered at a fairly high altitude.

Fields

bottom_radius: f32

Radius of the planet

units: m

top_radius: f32

Radius at which we consider the atmosphere to ‘end’ for our calculations (from center of planet)

units: m

ground_albedo: Vec3

An approximation of the average albedo (or color, roughly) of the planet’s surface. This is used when calculating multiscattering.

units: N/A

rayleigh_density_exp_scale: f32

The rate of falloff of rayleigh particulate with respect to altitude: optical density = exp(-rayleigh_density_exp_scale * altitude in meters).

THIS VALUE MUST BE POSITIVE

units: N/A

rayleigh_scattering: Vec3

The scattering optical density of rayleigh particulate, or how much light it scatters per meter

units: m^-1

mie_density_exp_scale: f32

The rate of falloff of mie particulate with respect to altitude: optical density = exp(-mie_density_exp_scale * altitude in meters)

THIS VALUE MUST BE POSITIVE

units: N/A

mie_scattering: f32

The scattering optical density of mie particulate, or how much light it scatters per meter.

units: m^-1

mie_absorption: f32

The absorbing optical density of mie particulate, or how much light it absorbs per meter.

units: m^-1

mie_asymmetry: f32

The “asymmetry” of mie scattering, or how much light tends to scatter forwards, rather than backwards or to the side.

domain: (-1, 1) units: N/A

ozone_layer_altitude: f32

The altitude at which the ozone layer is centered.

units: m

ozone_layer_width: f32

The width of the ozone layer

units: m

ozone_absorption: Vec3

The optical density of ozone, or how much of each wavelength of light it absorbs per meter.

units: m^-1

Implementations

impl Atmosphere

pub const EARTH: Atmosphere

pub fn with_density_multiplier(self, mult: f32) -> Self

Trait Implementations

impl Clone for Atmosphere

fn clone(&self) -> Atmosphere

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Component for Atmosphere

where Self: Send + Sync + 'static,

Required Components: AtmosphereSettings.

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 CreateFrom for Atmosphere

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

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

impl Default for Atmosphere

fn default() -> Self

Returns the “default value” for a type.

impl ExtractComponent for Atmosphere

type QueryData = &'static Atmosphere

ECS ReadOnlyQueryData to fetch the components to extract.

type QueryFilter = With<Camera3d>

Filters the entities with additional constraints.

type Out = Atmosphere

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 Atmosphere

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

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

where Atmosphere: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec3: 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 ReadFrom for Atmosphere

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

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

impl Reflect for Atmosphere

where Atmosphere: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec3: 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 ShaderSize for Atmosphere

where f32: ShaderSize, Vec3: ShaderSize,

const SHADER_SIZE: NonZero<u64> = _

Represents WGSL Size (equivalent to ShaderType::min_size)

impl ShaderType for Atmosphere

where f32: ShaderType + ShaderSize, Vec3: ShaderType + ShaderSize,

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 Atmosphere

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

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

where Atmosphere: Any + Send + Sync, f32: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec3: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.

impl WriteInto for Atmosphere

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

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