Struct RetainedViewEntity 

pub struct RetainedViewEntity {
    pub main_entity: MainEntity,
    pub auxiliary_entity: Option<MainEntity>,
    pub subview_index: u32,
}

Available on crate feature bevy_render only.

An identifier for a view that is stable across frames.

We can’t use Entity for this because render world entities aren’t stable, and we can’t use just MainEntity because some main world views extract to multiple render world views. For example, a directional light extracts to one render world view per cascade, and a point light extracts to one render world view per cubemap face. So we pair the main entity with an auxiliary entity and a subview index, which together uniquely identify a view in the render world in a way that’s stable from frame to frame.

Fields

main_entity: MainEntity

The main entity that this view corresponds to.

auxiliary_entity: Option<MainEntity>

Another entity associated with the view entity.

This is currently used for shadow cascades. If there are multiple cameras, each camera needs to have its own set of shadow cascades. Thus the light and subview index aren’t themselves enough to uniquely identify a shadow cascade: we need the camera that the cascade is associated with as well. This entity stores that camera.

subview_index: u32

The index of the view corresponding to the entity.

For example, for point lights that cast shadows, this is the index of the cubemap face (0 through 5 inclusive). For directional lights, this is the index of the cascade.

Implementations

impl RetainedViewEntity

pub fn new( main_entity: MainEntity, auxiliary_entity: Option<MainEntity>, subview_index: u32, ) -> RetainedViewEntity

Creates a new RetainedViewEntity from the given main world entity, auxiliary main world entity, and subview index.

See RetainedViewEntity::subview_index for an explanation of what auxiliary_entity and subview_index are.

Examples found in repository

examples/shader_advanced/custom_render_phase.rs (line 539)

fn extract_camera_phases(
    mut stencil_phases: ResMut<ViewSortedRenderPhases<Stencil3d>>,
    cameras: Extract<Query<(Entity, &Camera), With<Camera3d>>>,
    mut live_entities: Local<HashSet<RetainedViewEntity>>,
) {
    live_entities.clear();
    for (main_entity, camera) in &cameras {
        if !camera.is_active {
            continue;
        }
        // This is the main camera, so we use the first subview index (0)
        let retained_view_entity = RetainedViewEntity::new(main_entity.into(), None, 0);

        stencil_phases.prepare_for_new_frame(retained_view_entity);
        live_entities.insert(retained_view_entity);
    }

    // Clear out all dead views.
    stencil_phases.retain(|camera_entity, _| live_entities.contains(camera_entity));
}

examples/2d/mesh2d_manual.rs (line 505)

fn extract_colored_mesh2d_camera_phases(
    mut colored_mesh2d_render_phases: ResMut<ViewSortedRenderPhases<TransparentColoredMesh2d>>,
    cameras_2d: Extract<Query<(Entity, &Camera), With<Camera2d>>>,
    mut live_entities: Local<HashSet<RetainedViewEntity>>,
) {
    live_entities.clear();

    for (main_entity, camera) in &cameras_2d {
        if !camera.is_active {
            continue;
        }

        // This is the main 2D camera, so we use the first subview index (0).
        let retained_view_entity = RetainedViewEntity::new(main_entity.into(), None, 0);

        colored_mesh2d_render_phases.prepare_for_new_frame(retained_view_entity);

        live_entities.insert(retained_view_entity);
    }

    // Clear out all dead views.
    colored_mesh2d_render_phases.retain(|camera_entity, _| live_entities.contains(camera_entity));
}

Trait Implementations

impl Clone for RetainedViewEntity

fn clone(&self) -> RetainedViewEntity

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for RetainedViewEntity

impl Debug for RetainedViewEntity

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

Formats the value using the given formatter.

impl Eq for RetainedViewEntity

impl Hash for RetainedViewEntity

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for RetainedViewEntity

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for RetainedViewEntity