
# Objective Fix #8267. Fixes half of #7840. The `ComputedVisibility` component contains two flags: hierarchy visibility, and view visibility (whether its visible to any cameras). Due to the modular and open-ended way that view visibility is computed, it triggers change detection every single frame, even when the value does not change. Since hierarchy visibility is stored in the same component as view visibility, this means that change detection for inherited visibility is completely broken. At the company I work for, this has become a real issue. We are using change detection to only re-render scenes when necessary. The broken state of change detection for computed visibility means that we have to to rely on the non-inherited `Visibility` component for now. This is workable in the early stages of our project, but since we will inevitably want to use the hierarchy, we will have to either: 1. Roll our own solution for computed visibility. 2. Fix the issue for everyone. ## Solution Split the `ComputedVisibility` component into two: `InheritedVisibilty` and `ViewVisibility`. This allows change detection to behave properly for `InheritedVisibility`. View visiblity is still erratic, although it is less useful to be able to detect changes for this flavor of visibility. Overall, this actually simplifies the API. Since the visibility system consists of self-explaining components, it is much easier to document the behavior and usage. This approach is more modular and "ECS-like" -- one could strip out the `ViewVisibility` component entirely if it's not needed, and rely only on inherited visibility. --- ## Changelog - `ComputedVisibility` has been removed in favor of: `InheritedVisibility` and `ViewVisiblity`. ## Migration Guide The `ComputedVisibilty` component has been split into `InheritedVisiblity` and `ViewVisibility`. Replace any usages of `ComputedVisibility::is_visible_in_hierarchy` with `InheritedVisibility::get`, and replace `ComputedVisibility::is_visible_in_view` with `ViewVisibility::get`. ```rust // Before: commands.spawn(VisibilityBundle { visibility: Visibility::Inherited, computed_visibility: ComputedVisibility::default(), }); // After: commands.spawn(VisibilityBundle { visibility: Visibility::Inherited, inherited_visibility: InheritedVisibility::default(), view_visibility: ViewVisibility::default(), }); ``` ```rust // Before: fn my_system(q: Query<&ComputedVisibilty>) { for vis in &q { if vis.is_visible_in_hierarchy() { // After: fn my_system(q: Query<&InheritedVisibility>) { for inherited_visibility in &q { if inherited_visibility.get() { ``` ```rust // Before: fn my_system(q: Query<&ComputedVisibilty>) { for vis in &q { if vis.is_visible_in_view() { // After: fn my_system(q: Query<&ViewVisibility>) { for view_visibility in &q { if view_visibility.get() { ``` ```rust // Before: fn my_system(mut q: Query<&mut ComputedVisibilty>) { for vis in &mut q { vis.set_visible_in_view(); // After: fn my_system(mut q: Query<&mut ViewVisibility>) { for view_visibility in &mut q { view_visibility.set(); ``` --------- Co-authored-by: Robert Swain <robert.swain@gmail.com>
57 lines
2.1 KiB
Rust
57 lines
2.1 KiB
Rust
use crate::{
|
|
texture_atlas::{TextureAtlas, TextureAtlasSprite},
|
|
Sprite,
|
|
};
|
|
use bevy_asset::Handle;
|
|
use bevy_ecs::bundle::Bundle;
|
|
use bevy_render::{
|
|
texture::{Image, DEFAULT_IMAGE_HANDLE},
|
|
view::{InheritedVisibility, ViewVisibility, Visibility},
|
|
};
|
|
use bevy_transform::components::{GlobalTransform, Transform};
|
|
|
|
#[derive(Bundle, Clone)]
|
|
pub struct SpriteBundle {
|
|
pub sprite: Sprite,
|
|
pub transform: Transform,
|
|
pub global_transform: GlobalTransform,
|
|
pub texture: Handle<Image>,
|
|
/// User indication of whether an entity is visible
|
|
pub visibility: Visibility,
|
|
/// Inherited visibility of an entity.
|
|
pub inherited_visibility: InheritedVisibility,
|
|
/// Algorithmically-computed indication of whether an entity is visible and should be extracted for rendering
|
|
pub view_visibility: ViewVisibility,
|
|
}
|
|
|
|
impl Default for SpriteBundle {
|
|
fn default() -> Self {
|
|
Self {
|
|
sprite: Default::default(),
|
|
transform: Default::default(),
|
|
global_transform: Default::default(),
|
|
texture: DEFAULT_IMAGE_HANDLE.typed(),
|
|
visibility: Default::default(),
|
|
inherited_visibility: Default::default(),
|
|
view_visibility: Default::default(),
|
|
}
|
|
}
|
|
}
|
|
/// A Bundle of components for drawing a single sprite from a sprite sheet (also referred
|
|
/// to as a `TextureAtlas`)
|
|
#[derive(Bundle, Clone, Default)]
|
|
pub struct SpriteSheetBundle {
|
|
/// The specific sprite from the texture atlas to be drawn, defaulting to the sprite at index 0.
|
|
pub sprite: TextureAtlasSprite,
|
|
/// A handle to the texture atlas that holds the sprite images
|
|
pub texture_atlas: Handle<TextureAtlas>,
|
|
/// Data pertaining to how the sprite is drawn on the screen
|
|
pub transform: Transform,
|
|
pub global_transform: GlobalTransform,
|
|
/// User indication of whether an entity is visible
|
|
pub visibility: Visibility,
|
|
pub inherited_visibility: InheritedVisibility,
|
|
/// Algorithmically-computed indication of whether an entity is visible and should be extracted for rendering
|
|
pub view_visibility: ViewVisibility,
|
|
}
|