Alternate wireframe override api

crates/bevy_pbr/src/wireframe.rs

@@ -23,8 +23,9 @@ use bevy_render::{
     RenderApp, RenderSet,
 };
 use bevy_render::{Extract, ExtractSchedule, Render};
+use bevy_utils::hashbrown::HashSet;
 use bevy_utils::tracing::error;
-use bevy_utils::EntityHashMap;
+use bevy_utils::{EntityHash, EntityHashMap, EntityHashSet};
 
 pub const WIREFRAME_SHADER_HANDLE: Handle<Shader> = Handle::weak_from_u128(192598014480025766);
 
@@ -41,6 +42,7 @@ impl Plugin for WireframePlugin {
         );
 
         app.register_type::<Wireframe>()
+            .register_type::<NeverRenderWireframe>()
             .register_type::<WireframeConfig>()
             .init_resource::<WireframeConfig>()
             .add_plugins((ExtractResourcePlugin::<WireframeConfig>::default(),));
@@ -50,6 +52,7 @@ impl Plugin for WireframePlugin {
                 .add_render_command::<Opaque3d, DrawWireframes>()
                 .init_resource::<SpecializedMeshPipelines<WireframePipeline>>()
                 .init_resource::<Wireframes>()
+                .init_resource::<NeverRenderWireframes>()
                 .add_systems(ExtractSchedule, extract_wireframes)
                 .add_systems(Render, queue_wireframes.in_set(RenderSet::QueueMeshes));
         }
@@ -62,38 +65,46 @@ impl Plugin for WireframePlugin {
     }
 }
 
-/// Overrides the global [`WireframeConfig`] for a single mesh.
+/// Enables wireframe rendering for any entity it is attached to.
+/// It will ignore the [`WireframeConfig`] global setting.
+///
+/// This requires the [`WireframePlugin`] to be enabled.
 #[derive(Component, Debug, Clone, Default, Reflect, Eq, PartialEq)]
 #[reflect(Component, Default)]
-pub enum Wireframe {
-    /// Always render the wireframe for this entity, regardless of global config.
-    #[default]
-    AlwaysRender,
-    /// Never render the wireframe for this entity, regardless of global config.
-    NeverRender,
-}
+pub struct Wireframe;
+
+/// Disables wireframe rendering for any entity it is attached to.
+/// It will ignore the [`WireframeConfig`] global setting.
+///
+/// This requires the [`WireframePlugin`] to be enabled.
+#[derive(Component, Debug, Clone, Default, Reflect, Eq, PartialEq)]
+#[reflect(Component, Default)]
+pub struct NeverRenderWireframe;
 
 #[derive(Resource, Debug, Clone, Default, ExtractResource, Reflect)]
 #[reflect(Resource)]
 pub struct WireframeConfig {
     /// Whether to show wireframes for all meshes.
-    /// Can be overridden for individual meshes by adding a [`Wireframe`] component.
+    /// Can be overridden for individual meshes by adding a [`Wireframe`] or [`NeverRenderWireframe`] component.
     pub global: bool,
 }
 
 #[derive(Resource, Default, Deref, DerefMut)]
-pub struct Wireframes(EntityHashMap<Entity, Wireframe>);
+pub struct Wireframes(EntityHashSet<Entity>);
+
+#[derive(Resource, Default, Deref, DerefMut)]
+pub struct NeverRenderWireframes(EntityHashSet<Entity>);
 
 fn extract_wireframes(
     mut wireframes: ResMut<Wireframes>,
-    query: Extract<Query<(Entity, &Wireframe)>>,
+    mut never_render_wireframes: ResMut<NeverRenderWireframes>,
+    wireframe_query: Extract<Query<Entity, With<Wireframe>>>,
+    never_render_wireframe_query: Extract<Query<Entity, With<NeverRenderWireframe>>>,
 ) {
     wireframes.clear();
-    wireframes.extend(
-        query
-            .iter()
-            .map(|(entity, wireframe)| (entity, wireframe.clone())),
-    );
+    wireframes.extend(wireframe_query.iter().map(|entity| entity));
+    never_render_wireframes.clear();
+    never_render_wireframes.extend(never_render_wireframe_query.iter().map(|entity| entity));
 }
 
 #[derive(Resource, Clone)]
@@ -137,6 +148,7 @@ fn queue_wireframes(
     render_meshes: Res<RenderAssets<Mesh>>,
     render_mesh_instances: Res<RenderMeshInstances>,
     wireframes: Res<Wireframes>,
+    never_render_wireframes: Res<NeverRenderWireframes>,
     wireframe_config: Res<WireframeConfig>,
     wireframe_pipeline: Res<WireframePipeline>,
     mut pipelines: ResMut<SpecializedMeshPipelines<WireframePipeline>>,
@@ -185,11 +197,11 @@ fn queue_wireframes(
             .entities
             .iter()
             .filter_map(|visible_entity| {
-                let wireframe_override = wireframes.get(visible_entity);
+                if never_render_wireframes.get(visible_entity).is_some() {
+                    return None;
+                }
 
-                if (wireframe_config.global || wireframe_override == Some(&Wireframe::AlwaysRender))
-                    && wireframe_override != Some(&Wireframe::NeverRender)
-                {
+                if wireframe_config.global || wireframes.get(visible_entity).is_some() {
                     render_mesh_instances
                         .get(visible_entity)
                         .map(|mesh_instance| (*visible_entity, mesh_instance))

examples/3d/wireframe.rs

@@ -1,7 +1,7 @@
 //! Showcases wireframe rendering.
 
 use bevy::{
-    pbr::wireframe::{Wireframe, WireframeConfig, WireframePlugin},
+    pbr::wireframe::{NeverRenderWireframe, Wireframe, WireframeConfig, WireframePlugin},
     prelude::*,
     render::{render_resource::WgpuFeatures, settings::WgpuSettings, RenderPlugin},
 };
@@ -48,7 +48,7 @@ fn setup(
             transform: Transform::from_xyz(-1.0, 0.5, -1.0),
             ..default()
         })
-        .insert(Wireframe::NeverRender);
+        .insert(NeverRenderWireframe);
     // Orange cube: Follows global wireframe setting
     commands.spawn(PbrBundle {
         mesh: meshes.add(Mesh::from(shape::Cube { size: 1.0 })),
@@ -64,7 +64,7 @@ fn setup(
             transform: Transform::from_xyz(1.0, 0.5, 1.0),
             ..default()
         })
-        .insert(Wireframe::AlwaysRender);
+        .insert(Wireframe);
 
     // light
     commands.spawn(PointLightBundle {