Struct bevy::render::view::ViewVisibility

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

Expand description

Algorithmically-computed indication of whether an entity is visible and should be extracted for rendering.

Each frame, this will be reset to false during VisibilityPropagate systems in PostUpdate. Later in the frame, systems in CheckVisibility will mark any visible entities using ViewVisibility::set. Because of this, values of this type will be marked as changed every frame, even when they do not change.

If you wish to add custom visibility system that sets this value, make sure you add it to the CheckVisibility set.

Implementations§

§

impl ViewVisibility

pub const HIDDEN: ViewVisibility = _

An entity that cannot be seen from any views.

pub fn get(self) -> bool

Returns true if the entity is visible in any view. Otherwise, returns false.

Examples found in repository ?

examples/stress_tests/many_cubes.rs (line 485)

fn print_mesh_count(
    time: Res<Time>,
    mut timer: Local<PrintingTimer>,
    sprites: Query<(&Handle<Mesh>, &ViewVisibility)>,
) {
    timer.tick(time.delta());

    if timer.just_finished() {
        info!(
            "Meshes: {} - Visible Meshes {}",
            sprites.iter().len(),
            sprites.iter().filter(|(_, vis)| vis.get()).count(),
        );
    }
}

More examples

Hide additional examples

examples/math/render_primitives.rs (line 568)

fn rotate_primitive_2d_meshes(
    mut primitives_2d: Query<
        (&mut Transform, &ViewVisibility),
        (With<PrimitiveData>, With<MeshDim2>),
    >,
    time: Res<Time>,
) {
    let rotation_2d = Quat::from_mat3(&Mat3::from_angle(time.elapsed_seconds()));
    primitives_2d
        .iter_mut()
        .filter(|(_, vis)| vis.get())
        .for_each(|(mut transform, _)| {
            transform.rotation = rotation_2d;
        });
}

fn rotate_primitive_3d_meshes(
    mut primitives_3d: Query<
        (&mut Transform, &ViewVisibility),
        (With<PrimitiveData>, With<MeshDim3>),
    >,
    time: Res<Time>,
) {
    let rotation_3d = Quat::from_rotation_arc(
        Vec3::Z,
        Vec3::new(
            time.elapsed_seconds().sin(),
            time.elapsed_seconds().cos(),
            time.elapsed_seconds().sin() * 0.5,
        )
        .try_normalize()
        .unwrap_or(Vec3::Z),
    );
    primitives_3d
        .iter_mut()
        .filter(|(_, vis)| vis.get())
        .for_each(|(mut transform, _)| {
            transform.rotation = rotation_3d;
        });
}

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

pub fn extract_colored_mesh2d(
    mut commands: Commands,
    mut previous_len: Local<usize>,
    // When extracting, you must use `Extract` to mark the `SystemParam`s
    // which should be taken from the main world.
    query: Extract<
        Query<(Entity, &ViewVisibility, &GlobalTransform, &Mesh2dHandle), With<ColoredMesh2d>>,
    >,
    mut render_mesh_instances: ResMut<RenderColoredMesh2dInstances>,
) {
    let mut values = Vec::with_capacity(*previous_len);
    for (entity, view_visibility, transform, handle) in &query {
        if !view_visibility.get() {
            continue;
        }

        let transforms = Mesh2dTransforms {
            transform: (&transform.affine()).into(),
            flags: MeshFlags::empty().bits(),
        };

        values.push((entity, ColoredMesh2d));
        render_mesh_instances.insert(
            entity,
            RenderMesh2dInstance {
                mesh_asset_id: handle.0.id(),
                transforms,
                material_bind_group_id: Material2dBindGroupId::default(),
                automatic_batching: false,
            },
        );
    }
    *previous_len = values.len();
    commands.insert_or_spawn_batch(values);
}

pub fn set(&mut self)

Sets the visibility to true. This should not be considered reversible for a given frame, as this component tracks whether or not the entity visible in any view.

This will be automatically reset to false every frame in VisibilityPropagate and then set to the proper value in CheckVisibility.

You should only manually set this if you are defining a custom visibility system, in which case the system should be placed in the CheckVisibility set. For normal user-defined entity visibility, see Visibility.