Struct bevy::render::view::RenderLayers

pub struct RenderLayers(/* private fields */);

Describes which rendering layers an entity belongs to.

Cameras with this component will only render entities with intersecting layers.

Entities may belong to one or more layers, or no layer at all.

The Default instance of RenderLayers contains layer 0, the first layer.

An entity with this component without any layers is invisible.

Entities without this component belong to layer 0.

Implementations

impl RenderLayers

pub const fn layer(n: usize) -> RenderLayers

Create a new RenderLayers belonging to the given layer.

pub const fn none() -> RenderLayers

Create a new RenderLayers that belongs to no layers.

This is distinct from RenderLayers::default, which belongs to the first layer.

pub fn from_layers(layers: &[usize]) -> RenderLayers

Create a RenderLayers from a list of layers.

pub fn with(self, layer: usize) -> RenderLayers

Add the given layer.

This may be called multiple times to allow an entity to belong to multiple rendering layers.

pub fn without(self, layer: usize) -> RenderLayers

Removes the given rendering layer.

pub fn iter(&self) -> impl Iterator<Item = usize>

Get an iterator of the layers.

pub fn intersects(&self, other: &RenderLayers) -> bool

Determine if a RenderLayers intersects another.

RenderLayerss intersect if they share any common layers.

A RenderLayers with no layers will not match any other RenderLayers, even another with no layers.

pub fn bits(&self) -> &[u64]

get the bitmask representation of the contained layers

pub fn intersection(&self, other: &RenderLayers) -> RenderLayers

Returns the set of layers shared by two instances of RenderLayers.

This corresponds to the self & other operation.

pub fn union(&self, other: &RenderLayers) -> RenderLayers

Returns all layers included in either instance of RenderLayers.

This corresponds to the self | other operation.

pub fn symmetric_difference(&self, other: &RenderLayers) -> RenderLayers

Returns all layers included in exactly one of the instances of RenderLayers.

This corresponds to the “exclusive or” (XOR) operation: self ^ other.

Trait Implementations

impl BitAnd for RenderLayers

type Output = RenderLayers

The resulting type after applying the & operator.

fn bitand(self, rhs: RenderLayers) -> <RenderLayers as BitAnd>::Output

Performs the & operation.

impl BitOr for RenderLayers

type Output = RenderLayers

The resulting type after applying the | operator.

fn bitor(self, rhs: RenderLayers) -> <RenderLayers as BitOr>::Output

Performs the | operation.

impl BitXor for RenderLayers

type Output = RenderLayers

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: RenderLayers) -> <RenderLayers as BitXor>::Output

Performs the ^ operation.

impl Clone for RenderLayers

fn clone(&self) -> RenderLayers

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Component for RenderLayers

where RenderLayers: 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 Debug for RenderLayers

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for &RenderLayers

fn default() -> &RenderLayers

Returns the “default value” for a type.

impl Default for RenderLayers

fn default() -> RenderLayers

By default, this structure includes layer 0, which represents the first layer.

This is distinct from RenderLayers::none, which doesn’t belong to any layers.

impl FromIterator<usize> for RenderLayers

fn from_iter<T>(i: T) -> RenderLayers

where T: IntoIterator<Item = usize>,

Creates a value from an iterator.

impl FromReflect for RenderLayers

where RenderLayers: Any + Send + Sync, SmallVec<[u64; 1]>: FromReflect + TypePath + RegisterForReflection,

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

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 RenderLayers

where RenderLayers: Any + Send + Sync, SmallVec<[u64; 1]>: 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 Ord for RenderLayers

fn cmp(&self, other: &RenderLayers) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for RenderLayers

fn eq(&self, other: &RenderLayers) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for RenderLayers

fn partial_cmp(&self, other: &RenderLayers) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Reflect for RenderLayers

where RenderLayers: Any + Send + Sync, SmallVec<[u64; 1]>: 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<RenderLayers>) -> 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<RenderLayers>) -> 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<RenderLayers>) -> 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 TupleStruct for RenderLayers

where RenderLayers: Any + Send + Sync, SmallVec<[u64; 1]>: FromReflect + TypePath + RegisterForReflection,

fn field(&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_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 field_len(&self) -> usize

Returns the number of fields in the tuple struct.

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

Returns an iterator over the values of the tuple struct’s fields.

fn clone_dynamic(&self) -> DynamicTupleStruct

Clones the struct into a DynamicTupleStruct.

impl TypePath for RenderLayers

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

where RenderLayers: Any + Send + Sync, SmallVec<[u64; 1]>: FromReflect + TypePath + RegisterForReflection,

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.

impl Eq for RenderLayers

impl StructuralPartialEq for RenderLayers