flesh out the visibility integration

blamelessgames · blamelessgames · commit d251dfb2f927 · 2025-12-06T22:20:06.000-08:00
- add a visibility class to the gizmo
- calculate AABBs for the gizmos
- start a new example for retained gizmos
diff --git a/Cargo.toml b/Cargo.toml
@@ -4123,6 +4123,18 @@ description = "A scene showcasing light gizmos"
 category = "Gizmos"
 wasm = true
 
+[[example]]
+name = "retained_gizmos"
+path = "examples/gizmos/retained_gizmos.rs"
+doc-scrape-examples = true
+required-features = ["free_camera"]
+
+[package.metadata.example.retained_gizmos]
+name = "Retained Gizmos"
+description = "A scene showcasing retained gizmos"
+category = "Gizmos"
+wasm = true
+
 [[example]]
 name = "custom_gltf_vertex_attribute"
 path = "examples/gltf/custom_gltf_vertex_attribute.rs"
diff --git a/crates/bevy_gizmos_render/Cargo.toml b/crates/bevy_gizmos_render/Cargo.toml
@@ -29,6 +29,7 @@ bevy_render = { path = "../bevy_render", version = "0.18.0-dev" }
 bevy_utils = { path = "../bevy_utils", version = "0.18.0-dev" }
 bevy_core_pipeline = { path = "../bevy_core_pipeline", version = "0.18.0-dev" }
 bevy_transform = { path = "../bevy_transform", version = "0.18.0-dev" }
+bevy_platform = { path = "../bevy_platform", version = "0.18.0-dev" }
 
 # other
 bytemuck = "1.0"
diff --git a/crates/bevy_gizmos_render/src/lib.rs b/crates/bevy_gizmos_render/src/lib.rs
@@ -24,36 +24,39 @@ mod pipeline_2d;
 #[cfg(feature = "bevy_pbr")]
 mod pipeline_3d;
 
-use bevy_app::{App, Plugin};
-use bevy_camera::visibility::{add_visibility_class, Visibility, VisibilityClass};
-use bevy_ecs::{
-    resource::Resource,
-    schedule::{IntoScheduleConfigs, SystemSet},
-    system::Res,
-};
-
-use {bevy_gizmos::config::GizmoMeshConfig, bevy_mesh::VertexBufferLayout};
-
 use {
-    crate::retained::extract_linegizmos,
-    bevy_asset::AssetId,
+    crate::retained::{
+        calculate_bounds, extract_linegizmos, mark_gizmos_as_changed_if_their_assets_changed,
+    },
+    bevy_app::{App, Plugin, PostUpdate},
+    bevy_asset::{AssetEventSystems, AssetId},
+    bevy_camera::visibility::{self, Visibility, VisibilityClass, VisibilitySystems},
     bevy_ecs::{
         component::Component,
         entity::Entity,
         query::ROQueryItem,
+        resource::Resource,
+        schedule::{IntoScheduleConfigs, SystemSet},
         system::{
             lifetimeless::{Read, SRes},
-            Commands, SystemParamItem,
+            Commands, Res, SystemParamItem,
         },
     },
+    bevy_gizmos::{
+        config::{GizmoConfigStore, GizmoLineJoint, GizmoMeshConfig},
+        prelude::Gizmo,
+        GizmoAsset, GizmoHandles,
+    },
     bevy_math::{Affine3, Affine3A, Vec4},
+    bevy_mesh::VertexBufferLayout,
     bevy_render::{
         extract_component::{ComponentUniforms, DynamicUniformIndex, UniformComponentPlugin},
         render_asset::{PrepareAssetError, RenderAsset, RenderAssetPlugin, RenderAssets},
         render_phase::{PhaseItem, RenderCommand, RenderCommandResult, TrackedRenderPass},
         render_resource::{
-            binding_types::uniform_buffer, BindGroup, BindGroupEntries, BindGroupLayoutEntries,
-            Buffer, BufferInitDescriptor, BufferUsages, ShaderStages, ShaderType, VertexFormat,
+            binding_types::uniform_buffer, BindGroup, BindGroupEntries, BindGroupLayoutDescriptor,
+            BindGroupLayoutEntries, Buffer, BufferInitDescriptor, BufferUsages, PipelineCache,
+            ShaderStages, ShaderType, VertexAttribute, VertexFormat, VertexStepMode,
         },
         renderer::RenderDevice,
         sync_world::{MainEntity, TemporaryRenderEntity},
@@ -62,16 +65,6 @@ use {
     bytemuck::cast_slice,
 };
 
-use bevy_render::render_resource::{
-    BindGroupLayoutDescriptor, PipelineCache, VertexAttribute, VertexStepMode,
-};
-
-use bevy_gizmos::{
-    config::{GizmoConfigStore, GizmoLineJoint},
-    prelude::Gizmo,
-    GizmoAsset, GizmoHandles,
-};
-
 /// A [`Plugin`] that provides an immediate mode drawing api for visual debugging.
 ///
 /// Requires to be loaded after [`PbrPlugin`](bevy_pbr::PbrPlugin) or [`SpriteRenderPlugin`](bevy_sprite_render::SpriteRenderPlugin).
@@ -87,7 +80,20 @@ impl Plugin for GizmoRenderPlugin {
         }
 
         app.add_plugins(UniformComponentPlugin::<LineGizmoUniform>::default())
-            .add_plugins(RenderAssetPlugin::<GpuLineGizmo>::default());
+            .add_plugins(RenderAssetPlugin::<GpuLineGizmo>::default())
+            .register_required_components::<Gizmo, Visibility>()
+            .register_required_components::<Gizmo, VisibilityClass>()
+            .add_systems(
+                PostUpdate,
+                (
+                    calculate_bounds.in_set(VisibilitySystems::CalculateBounds),
+                    mark_gizmos_as_changed_if_their_assets_changed.after(AssetEventSystems),
+                ),
+            );
+
+        app.world_mut()
+            .register_component_hooks::<Gizmo>()
+            .on_add(visibility::add_visibility_class::<Gizmo>);
 
         if let Some(render_app) = app.get_sub_app_mut(RenderApp) {
             render_app.add_systems(RenderStartup, init_line_gizmo_uniform_bind_group_layout);
@@ -114,8 +120,6 @@ impl Plugin for GizmoRenderPlugin {
         } else {
             tracing::warn!("bevy_render feature is enabled but RenderApp was not detected. Are you sure you loaded GizmoPlugin after RenderPlugin?");
         }
-
-        app.register_required_components::<Gizmo, Visibility>();
     }
 }
 
diff --git a/crates/bevy_gizmos_render/src/retained.rs b/crates/bevy_gizmos_render/src/retained.rs
@@ -1,27 +1,35 @@
 //! This module is for 'retained' alternatives to the 'immediate mode' [`Gizmos`](bevy_gizmos::gizmos::Gizmos) system parameter.
 
-use crate::LineGizmoUniform;
-use bevy_camera::visibility::{InheritedVisibility, RenderLayers, ViewVisibility};
-use bevy_gizmos::retained::Gizmo;
-use bevy_math::Affine3;
-use bevy_render::{
-    sync_world::{MainEntity, TemporaryRenderEntity},
-    view,
-};
-use bevy_utils::once;
-use tracing::warn;
 use {
+    crate::LineGizmoUniform,
+    bevy_asset::{AssetEvent, AssetId, Assets},
+    bevy_camera::{
+        primitives::Aabb,
+        visibility::{NoFrustumCulling, RenderLayers, ViewVisibility},
+    },
     bevy_ecs::{
+        change_detection::DetectChangesMut,
         entity::Entity,
-        system::{Commands, Local, Query},
+        message::MessageReader,
+        query::{Changed, Or, Without},
+        system::{Commands, Local, Query, Res},
+    },
+    bevy_gizmos::{
+        config::{GizmoLineJoint, GizmoLineStyle},
+        retained::Gizmo,
+        GizmoAsset,
+    },
+    bevy_math::{bounding::Aabb3d, Affine3, Isometry3d, Vec3A},
+    bevy_platform::{collections::HashSet, hash::FixedHasher},
+    bevy_render::{
+        sync_world::{MainEntity, TemporaryRenderEntity},
+        Extract,
     },
-    bevy_gizmos::config::GizmoLineJoint,
-    bevy_render::Extract,
     bevy_transform::components::GlobalTransform,
+    bevy_utils::once,
+    tracing::warn,
 };
 
-use bevy_gizmos::config::GizmoLineStyle;
-
 pub(crate) fn extract_linegizmos(
     mut commands: Commands,
     mut previous_len: Local<usize>,
@@ -30,15 +38,13 @@ pub(crate) fn extract_linegizmos(
             Entity,
             &Gizmo,
             &GlobalTransform,
-            &InheritedVisibility,
             &ViewVisibility,
             Option<&RenderLayers>,
         )>,
     >,
 ) {
     let mut values = Vec::with_capacity(*previous_len);
-    for (entity, gizmo, transform, visibility, view_visibility, render_layers) in &query {
-        println!("{visibility:?} {view_visibility:?}");
+    for (entity, gizmo, transform, view_visibility, render_layers) in &query {
         if !view_visibility.get() {
             continue;
         }
@@ -91,3 +97,56 @@ pub(crate) fn extract_linegizmos(
     *previous_len = values.len();
     commands.spawn_batch(values);
 }
+
+pub(crate) fn calculate_bounds(
+    mut commands: Commands,
+    gizmo_assets: Res<Assets<GizmoAsset>>,
+    without_aabb: Query<
+        (Entity, &Gizmo),
+        (
+            Or<(Changed<Gizmo>, Without<Aabb>)>,
+            Without<NoFrustumCulling>,
+        ),
+    >,
+) {
+    for (entity, gizmo) in &without_aabb {
+        if let Some(gizmo_asset) = gizmo_assets.get(&gizmo.handle) {
+            println!("Calculating AABB for gizmo entity {:?}", entity);
+            let aabb_3d = Aabb3d::from_point_cloud(
+                Isometry3d::IDENTITY,
+                gizmo_asset
+                    .list_positions
+                    .iter()
+                    .chain(gizmo_asset.strip_positions.iter())
+                    // infinite points show up in here for some reason
+                    // i am brutally filtering them for now
+                    .filter(|p| p.is_finite())
+                    .map(|&p| Vec3A::from(p)),
+            );
+            let aabb: Aabb = aabb_3d.into();
+            commands.entity(entity).insert(aabb);
+        }
+    }
+}
+
+pub(crate) fn mark_gizmos_as_changed_if_their_assets_changed(
+    mut gizmos: Query<&mut Gizmo>,
+    mut gizmo_asset_events: MessageReader<AssetEvent<GizmoAsset>>,
+) {
+    let mut changed_gizmos: HashSet<AssetId<GizmoAsset>, FixedHasher> = HashSet::default();
+    for mesh_asset_event in gizmo_asset_events.read() {
+        if let AssetEvent::Modified { id } = mesh_asset_event {
+            changed_gizmos.insert(*id);
+        }
+    }
+
+    if changed_gizmos.is_empty() {
+        return;
+    }
+
+    for mut gizmo in &mut gizmos {
+        if changed_gizmos.contains(&gizmo.handle.id()) {
+            gizmo.set_changed();
+        }
+    }
+}
diff --git a/examples/gizmos/3d_gizmos.rs b/examples/gizmos/3d_gizmos.rs
@@ -12,14 +12,7 @@ fn main() {
         .add_plugins((DefaultPlugins, FreeCameraPlugin))
         .init_gizmo_group::<MyRoundGizmos>()
         .add_systems(Startup, setup)
-        .add_systems(
-            Update,
-            (
-                draw_example_collection,
-                update_config,
-                update_retained_gizmo_visibility,
-            ),
-        )
+        .add_systems(Update, (draw_example_collection, update_config))
         .run();
 }
 
@@ -33,29 +26,6 @@ fn setup(
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
-    let mut gizmo = GizmoAsset::new();
-
-    // When drawing a lot of static lines a Gizmo component can have
-    // far better performance than the Gizmos system parameter,
-    // but the system parameter will perform better for smaller lines that update often.
-
-    // A sphere made out of 30_000 lines!
-    gizmo
-        .sphere(Isometry3d::IDENTITY, 0.5, LIGHT_GOLDENROD_YELLOW)
-        .resolution(30_000 / 3);
-
-    commands.spawn((
-        Gizmo {
-            handle: gizmo_assets.add(gizmo),
-            line_config: GizmoLineConfig {
-                width: 5.,
-                ..default()
-            },
-            ..default()
-        },
-        Transform::from_xyz(4., 1., 0.),
-    ));
-
     commands.spawn((
         Camera3d::default(),
         Transform::from_xyz(0., 1.5, 6.).looking_at(Vec3::ZERO, Vec3::Y),
@@ -89,7 +59,6 @@ fn setup(
             Hold 'Left' or 'Right' to change the line width of straight gizmos\n\
             Hold 'Up' or 'Down' to change the line width of round gizmos\n\
             Press '1' or '2' to toggle the visibility of straight gizmos or round gizmos\n\
-            Press '3' to toggle the visibility of retained gizmos\n\
             Press 'B' to show all AABB boxes\n\
             Press 'U' or 'I' to cycle through line styles for straight or round gizmos\n\
             Press 'J' or 'K' to cycle through line joins for straight or round gizmos",
@@ -298,14 +267,3 @@ fn update_config(
         config_store.config_mut::<AabbGizmoConfigGroup>().1.draw_all ^= true;
     }
 }
-
-fn update_retained_gizmo_visibility(
-    keyboard: Res<ButtonInput<KeyCode>>,
-    mut gizmos: Query<&mut Visibility, With<Gizmo>>,
-) {
-    if keyboard.just_pressed(KeyCode::Digit3) {
-        for mut visibility in &mut gizmos {
-            visibility.toggle_inherited_hidden();
-        }
-    }
-}
diff --git a/examples/gizmos/retained_gizmos.rs b/examples/gizmos/retained_gizmos.rs
@@ -0,0 +1,55 @@
+//! This example demonstrates Bevy's visual debugging using retained gizmos.
+
+use bevy::{
+    camera_controller::free_camera::{FreeCamera, FreeCameraPlugin},
+    color::palettes::css::*,
+    prelude::*,
+};
+
+fn main() {
+    App::new()
+        .add_plugins((DefaultPlugins, FreeCameraPlugin))
+        //.init_gizmo_group::<MyRoundGizmos>()
+        .add_systems(Startup, setup)
+        // .add_systems(
+        //     Update,
+        //     (
+        //         draw_example_collection,
+        //         update_config,
+        //         update_retained_gizmo_visibility,
+        //     ),
+        // )
+        .run();
+}
+
+fn setup(mut commands: Commands, mut gizmo_assets: ResMut<Assets<GizmoAsset>>) {
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(0., 1.5, 6.).looking_at(Vec3::NEG_Z, Vec3::Y),
+        FreeCamera::default(),
+    ));
+
+    let mut gizmo = GizmoAsset::new();
+
+    // When drawing a lot of static lines a Gizmo component can have
+    // far better performance than the Gizmos system parameter,
+    // but the system parameter will perform better for smaller lines that update often.
+
+    // we'll sprinkle spheres made of 3,000 lines throughout the scene
+    // and make the blink
+    gizmo
+        .sphere(Isometry3d::IDENTITY, 0.5, LIGHT_GOLDENROD_YELLOW)
+        .resolution(3_000 / 3);
+
+    commands.spawn((
+        Gizmo {
+            handle: gizmo_assets.add(gizmo),
+            line_config: GizmoLineConfig {
+                width: 2.,
+                ..default()
+            },
+            ..default()
+        },
+        Transform::IDENTITY,
+    ));
+}
