Struct RenderVisibleEntitiesClass 

pub struct RenderVisibleEntitiesClass {
    pub entities_cpu_culling: Vec<(Entity, MainEntity)>,
    pub entities_gpu_culling: HashMap<MainEntity, Entity, EntityHash>,
    pub added_entities: Vec<(Entity, MainEntity)>,
    pub removed_entities: Vec<(Entity, MainEntity)>,
}

Stores a list of all entities that are visible from a single view for a single VisibilityClass, as well as the change lists.

Note that all lists in this component are guaranteed to be sorted. Thus you can test for the presence of an entity in these lists via binary search.

Note also that, for 3D meshes, the render-world Entity values will always be Entity::PLACEHOLDER. The render-world entities are kept for legacy systems that still need to process visibility of render-world entities.

The collect_visible_cpu_culled_entities and collect_gpu_culled_meshes systems populate this object from the corresponding RenderExtractedVisibleEntitiesClass object and the RenderGpuCulledEntities resource, respectively.

Fields

entities_cpu_culling: Vec<(Entity, MainEntity)>

A sorted list of all entities that don’t have NoCpuCulling components and are visible from this view.

entities_gpu_culling: HashMap<MainEntity, Entity, EntityHash>

A table of all entities that have NoCpuCulling components and have bevy_camera::visibility::InheritedVisibility set to true.

The collect_gpu_culled_meshes system keeps this up to date.

added_entities: Vec<(Entity, MainEntity)>

A sorted list of all entities that were invisible last frame (including ones that didn’t exist at all last frame) and became visible this frame.

removed_entities: Vec<(Entity, MainEntity)>

A sorted list of all entities that were visible last frame and became invisible this frame, including those that were despawned this frame.

Implementations

impl RenderVisibleEntitiesClass

pub fn prepare_for_new_frame(&mut self)

Clears out the lists of added and removed entities in preparation for a new frame.

pub fn update_cpu_culled_entities( &mut self, visible_mesh_entities_cpu_culling: &[(Entity, MainEntity)], )

Processes a list of visible entities for a new frame, computing the set of newly-added and newly-removed entities as it goes.

This function only handles entities that are culled on CPU (i.e. don’t have NoCpuCulling components). Entities that use only GPU culling are instead fetched from the main world and added to the RenderGpuCulledEntities table.

pub fn add_entity(&mut self, pair: (Entity, MainEntity))

Adds a new entity to the Self::added_entities list.

After calling this method one or more times, you must call Self::sort_added_entities to ensure the Self::added_entities list is sorted.

pub fn added_entities(&self) -> &[(Entity, MainEntity)]

Returns the list of newly-added entities.

pub fn entity_pair_is_visible( &self, entity: Entity, main_entity: MainEntity, ) -> bool

Returns true if the given entity pair is known to be visible.

This checks both the CPU culling visible entries table and the no-CPU-culling visible entries table.

pub fn iter_visible<'a>( &'a self, ) -> impl Iterator<Item = (&'a Entity, &'a MainEntity)>

Iterates over all visible entities.

This is an expensive operation, so try to avoid doing it unless necessary (e.g. the view key changed).

pub fn sort_added_entities(&mut self)

Sorts the Self::added_entities list.

You must call this after adding entities to the list via Self::add_entity.

Trait Implementations

impl Clone for RenderVisibleEntitiesClass

fn clone(&self) -> RenderVisibleEntitiesClass

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RenderVisibleEntitiesClass

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

Formats the value using the given formatter.

impl Default for RenderVisibleEntitiesClass

fn default() -> RenderVisibleEntitiesClass

Returns the “default value” for a type.

impl FromReflect for RenderVisibleEntitiesClass

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

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 RenderVisibleEntitiesClass

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 RenderVisibleEntitiesClass

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 + '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<RenderVisibleEntitiesClass>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn try_into_reflect( self: Box<RenderVisibleEntitiesClass>, ) -> 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<RenderVisibleEntitiesClass>, ) -> 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 reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

Returns a “partial comparison” result.

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

Debug formatter for the value.

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 reflect_hash(&self) -> Option<u64>

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

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

impl Reflect for RenderVisibleEntitiesClass

fn into_any(self: Box<RenderVisibleEntitiesClass>) -> 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<RenderVisibleEntitiesClass>) -> 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 RenderVisibleEntitiesClass

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

Gets 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)>

Gets 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)>

Gets 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)>

Gets 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>

Gets the name of the field with index index.

fn index_of_name(&self, name: &str) -> Option<usize>

Gets the index of the field with the given name.

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

Creates a new DynamicStruct from this struct.

fn get_represented_struct_info(&self) -> Option<&'static StructInfo>

Will return None if TypeInfo is not available.

impl TypePath for RenderVisibleEntitiesClass

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 RenderVisibleEntitiesClass

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.