Allow overriding global wireframe setting by adding a Wireframe component. (#7309)

Author: Wcubed

crates/bevy_pbr/src/wireframe.rs

@@ -52,21 +52,24 @@ impl Plugin for WireframePlugin {
     }
 }
 
-fn extract_wireframes(mut commands: Commands, query: Extract<Query<Entity, With<Wireframe>>>) {
-    for entity in &query {
-        commands.get_or_spawn(entity).insert(Wireframe);
+fn extract_wireframes(mut commands: Commands, query: Extract<Query<(Entity, &Wireframe)>>) {
+    for (entity, wireframe) in &query {
+        commands.get_or_spawn(entity).insert(wireframe.clone());
     }
 }
 
-/// Controls whether an entity should rendered in wireframe-mode if the [`WireframePlugin`] is enabled
-#[derive(Component, Debug, Clone, Default, Reflect)]
+/// Overrides the global [`WireframeConfig`] for a single mesh.
+#[derive(Component, Debug, Clone, Default, Reflect, Eq, PartialEq)]
 #[reflect(Component, Default)]
-pub struct Wireframe;
+pub struct Wireframe {
+    pub enable: bool,
+}
 
 #[derive(Resource, Debug, Clone, Default, ExtractResource, Reflect)]
 #[reflect(Resource)]
 pub struct WireframeConfig {
-    /// Whether to show wireframes for all meshes. If `false`, only meshes with a [Wireframe] component will be rendered.
+    /// Whether to show wireframes for all meshes.
+    /// Can be overridden for individual meshes by adding a [`Wireframe`] component.
     pub global: bool,
 }
 
@@ -110,10 +113,7 @@ fn queue_wireframes(
     mut pipelines: ResMut<SpecializedMeshPipelines<WireframePipeline>>,
     pipeline_cache: Res<PipelineCache>,
     msaa: Res<Msaa>,
-    mut material_meshes: ParamSet<(
-        Query<(Entity, &Handle<Mesh>, &MeshUniform)>,
-        Query<(Entity, &Handle<Mesh>, &MeshUniform), With<Wireframe>>,
-    )>,
+    material_meshes: Query<(Entity, &Handle<Mesh>, &MeshUniform, Option<&Wireframe>)>,
     mut views: Query<(&ExtractedView, &VisibleEntities, &mut RenderPhase<Opaque3d>)>,
 ) {
     let draw_custom = opaque_3d_draw_functions.read().id::<DrawWireframes>();
@@ -123,7 +123,7 @@ fn queue_wireframes(
 
         let view_key = msaa_key | MeshPipelineKey::from_hdr(view.hdr);
         let add_render_phase =
-            |(entity, mesh_handle, mesh_uniform): (Entity, &Handle<Mesh>, &MeshUniform)| {
+            |(entity, mesh_handle, mesh_uniform, _): (Entity, &Handle<Mesh>, &MeshUniform, _)| {
                 if let Some(mesh) = render_meshes.get(mesh_handle) {
                     let key = view_key
                         | MeshPipelineKey::from_primitive_topology(mesh.primitive_topology);
@@ -149,21 +149,16 @@ fn queue_wireframes(
                 }
             };
 
-        if wireframe_config.global {
-            let query = material_meshes.p0();
-            visible_entities
-                .entities
-                .iter()
-                .filter_map(|visible_entity| query.get(*visible_entity).ok())
-                .for_each(add_render_phase);
-        } else {
-            let query = material_meshes.p1();
-            visible_entities
-                .entities
-                .iter()
-                .filter_map(|visible_entity| query.get(*visible_entity).ok())
-                .for_each(add_render_phase);
-        }
+        visible_entities
+            .entities
+            .iter()
+            .filter_map(|visible_entity| material_meshes.get(*visible_entity).ok())
+            .filter(|mesh| {
+                let wireframe_override = mesh.3;
+                (wireframe_config.global || wireframe_override == Some(&Wireframe { enable: true }))
+                    && wireframe_override != Some(&Wireframe { enable: false })
+            })
+            .for_each(add_render_phase);
     }
 }
 

examples/3d/wireframe.rs

@@ -26,25 +26,27 @@ fn setup(
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
-    // To draw the wireframe on all entities, set this to 'true'
-    wireframe_config.global = false;
+    // This enables drawing of wireframes on every mesh.
+    // To instead enable it on individual meshes, make this `false`, and add a `Wireframe` component
+    // with `enable: true` to the meshes that should have wireframe enabled.
+    wireframe_config.global = true;
     // plane
-    commands.spawn(PbrBundle {
-        mesh: meshes.add(Mesh::from(shape::Plane { size: 5.0 })),
-        material: materials.add(Color::rgb(0.3, 0.5, 0.3).into()),
-        ..default()
-    });
-    // cube
     commands.spawn((
         PbrBundle {
-            mesh: meshes.add(Mesh::from(shape::Cube { size: 1.0 })),
-            material: materials.add(Color::rgb(0.8, 0.7, 0.6).into()),
-            transform: Transform::from_xyz(0.0, 0.5, 0.0),
+            mesh: meshes.add(Mesh::from(shape::Plane { size: 5.0 })),
+            material: materials.add(Color::rgb(0.3, 0.5, 0.3).into()),
             ..default()
         },
-        // This enables wireframe drawing on this entity
-        Wireframe,
+        // This disables wireframe rendering for this entity.
+        Wireframe { enable: false },
     ));
+    // cube
+    commands.spawn(PbrBundle {
+        mesh: meshes.add(Mesh::from(shape::Cube { size: 1.0 })),
+        material: materials.add(Color::rgb(0.8, 0.7, 0.6).into()),
+        transform: Transform::from_xyz(0.0, 0.5, 0.0),
+        ..default()
+    });
     // light
     commands.spawn(PointLightBundle {
         transform: Transform::from_xyz(4.0, 8.0, 4.0),