Make Msaa a component not a resource.

crates/bevy_core_pipeline/src/core_2d/camera_2d.rs

@@ -5,7 +5,7 @@ use bevy_render::{
     camera::{Camera, CameraProjection, CameraRenderGraph, OrthographicProjection},
     extract_component::ExtractComponent,
     primitives::Frustum,
-    view::VisibleEntities,
+    view::{Msaa, VisibleEntities},
 };
 use bevy_transform::prelude::{GlobalTransform, Transform};
 
@@ -36,6 +36,7 @@ pub struct Camera2dBundle {
     pub global_transform: GlobalTransform,
     pub camera_2d: Camera2d,
     pub tonemapping: Tonemapping,
+    pub msaa: Msaa,
 }
 
 impl Default for Camera2dBundle {
@@ -77,6 +78,7 @@ impl Camera2dBundle {
             camera: Camera::default(),
             camera_2d: Camera2d::default(),
             tonemapping: Tonemapping::Disabled,
+            msaa: Msaa { samples: 1 },
         }
     }
 }

crates/bevy_core_pipeline/src/core_3d/camera_3d.rs

@@ -6,7 +6,7 @@ use bevy_render::{
     extract_component::ExtractComponent,
     primitives::Frustum,
     render_resource::LoadOp,
-    view::VisibleEntities,
+    view::{Msaa, VisibleEntities},
 };
 use bevy_transform::prelude::{GlobalTransform, Transform};
 use serde::{Deserialize, Serialize};
@@ -68,6 +68,7 @@ pub struct Camera3dBundle {
     pub global_transform: GlobalTransform,
     pub camera_3d: Camera3d,
     pub tonemapping: Tonemapping,
+    pub msaa: Msaa,
 }
 
 // NOTE: ideally Perspective and Orthographic defaults can share the same impl, but sadly it breaks rust's type inference
@@ -85,6 +86,7 @@ impl Default for Camera3dBundle {
             transform: Default::default(),
             global_transform: Default::default(),
             camera_3d: Default::default(),
+            msaa: Msaa { samples: 1 },
         }
     }
 }

crates/bevy_core_pipeline/src/core_3d/mod.rs

@@ -250,10 +250,9 @@ pub fn extract_core_3d_camera_phases(
 pub fn prepare_core_3d_depth_textures(
     mut commands: Commands,
     mut texture_cache: ResMut<TextureCache>,
-    msaa: Res<Msaa>,
     render_device: Res<RenderDevice>,
     views_3d: Query<
-        (Entity, &ExtractedCamera),
+        (Entity, &ExtractedCamera, &Msaa),
         (
             With<RenderPhase<Opaque3d>>,
             With<RenderPhase<AlphaMask3d>>,
@@ -262,7 +261,7 @@ pub fn prepare_core_3d_depth_textures(
     >,
 ) {
     let mut textures = HashMap::default();
-    for (entity, camera) in &views_3d {
+    for (entity, camera, msaa) in &views_3d {
         if let Some(physical_target_size) = camera.physical_target_size {
             let cached_texture = textures
                 .entry(camera.target.clone())

crates/bevy_pbr/src/material.rs

@@ -334,7 +334,6 @@ pub fn queue_material_meshes<M: Material>(
     material_pipeline: Res<MaterialPipeline<M>>,
     mut pipelines: ResMut<SpecializedMeshPipelines<MaterialPipeline<M>>>,
     mut pipeline_cache: ResMut<PipelineCache>,
-    msaa: Res<Msaa>,
     render_meshes: Res<RenderAssets<Mesh>>,
     render_materials: Res<RenderMaterials<M>>,
     material_meshes: Query<(&Handle<M>, &Handle<Mesh>, &MeshUniform)>,
@@ -345,6 +344,7 @@ pub fn queue_material_meshes<M: Material>(
         &mut RenderPhase<Opaque3d>,
         &mut RenderPhase<AlphaMask3d>,
         &mut RenderPhase<Transparent3d>,
+        &Msaa,
     )>,
 ) where
     M::Data: PartialEq + Eq + Hash + Clone,
@@ -356,6 +356,7 @@ pub fn queue_material_meshes<M: Material>(
         mut opaque_phase,
         mut alpha_mask_phase,
         mut transparent_phase,
+        msaa,
     ) in &mut views
     {
         let draw_opaque_pbr = opaque_draw_functions.read().id::<DrawMaterial<M>>();

crates/bevy_pbr/src/wireframe.rs

@@ -109,19 +109,23 @@ fn queue_wireframes(
     wireframe_pipeline: Res<WireframePipeline>,
     mut pipelines: ResMut<SpecializedMeshPipelines<WireframePipeline>>,
     mut pipeline_cache: ResMut<PipelineCache>,
-    msaa: Res<Msaa>,
     mut material_meshes: ParamSet<(
         Query<(Entity, &Handle<Mesh>, &MeshUniform)>,
         Query<(Entity, &Handle<Mesh>, &MeshUniform), With<Wireframe>>,
     )>,
-    mut views: Query<(&ExtractedView, &VisibleEntities, &mut RenderPhase<Opaque3d>)>,
+    mut views: Query<(
+        &ExtractedView,
+        &VisibleEntities,
+        &mut RenderPhase<Opaque3d>,
+        &Msaa,
+    )>,
 ) {
     let draw_custom = opaque_3d_draw_functions.read().id::<DrawWireframes>();
-    let msaa_key = MeshPipelineKey::from_msaa_samples(msaa.samples);
-    for (view, visible_entities, mut opaque_phase) in &mut views {
+    for (view, visible_entities, mut opaque_phase, msaa) in &mut views {
         let rangefinder = view.rangefinder3d();
 
-        let view_key = msaa_key | MeshPipelineKey::from_hdr(view.hdr);
+        let view_key =
+            MeshPipelineKey::from_msaa_samples(msaa.samples) | MeshPipelineKey::from_hdr(view.hdr);
         let add_render_phase =
             |(entity, mesh_handle, mesh_uniform): (Entity, &Handle<Mesh>, &MeshUniform)| {
                 if let Some(mesh) = render_meshes.get(mesh_handle) {

crates/bevy_render/src/camera/camera.rs

@@ -3,7 +3,7 @@ use crate::{
     prelude::Image,
     render_asset::RenderAssets,
     render_resource::TextureView,
-    view::{ExtractedView, ExtractedWindows, VisibleEntities},
+    view::{ExtractedView, ExtractedWindows, Msaa, VisibleEntities},
     Extract,
 };
 use bevy_asset::{AssetEvent, Assets, Handle};
@@ -489,10 +489,11 @@ pub fn extract_cameras(
             &CameraRenderGraph,
             &GlobalTransform,
             &VisibleEntities,
+            &Msaa,
         )>,
     >,
 ) {
-    for (entity, camera, camera_render_graph, transform, visible_entities) in query.iter() {
+    for (entity, camera, camera_render_graph, transform, visible_entities, msaa) in query.iter() {
         if !camera.is_active {
             continue;
         }
@@ -525,6 +526,7 @@ pub fn extract_cameras(
                     ),
                 },
                 visible_entities.clone(),
+                msaa.clone(),
             ));
         }
     }

crates/bevy_render/src/view/mod.rs

@@ -6,7 +6,6 @@ pub use window::*;
 
 use crate::{
     camera::ExtractedCamera,
-    extract_resource::{ExtractResource, ExtractResourcePlugin},
     prelude::Image,
     render_asset::RenderAssets,
     render_phase::ViewRangefinder3d,
@@ -37,9 +36,7 @@ impl Plugin for ViewPlugin {
             .register_type::<RenderLayers>()
             .register_type::<Visibility>()
             .register_type::<VisibleEntities>()
-            .init_resource::<Msaa>()
             // NOTE: windows.is_changed() handles cases where a window was resized
-            .add_plugin(ExtractResourcePlugin::<Msaa>::default())
             .add_plugin(VisibilityPlugin);
 
         if let Ok(render_app) = app.get_sub_app_mut(RenderApp) {
@@ -54,18 +51,9 @@ impl Plugin for ViewPlugin {
     }
 }
 
-/// Configuration resource for [Multi-Sample Anti-Aliasing](https://en.wikipedia.org/wiki/Multisample_anti-aliasing).
-///
-/// # Example
-/// ```
-/// # use bevy_app::prelude::App;
-/// # use bevy_render::prelude::Msaa;
-/// App::new()
-///     .insert_resource(Msaa { samples: 4 })
-///     .run();
-/// ```
-#[derive(Resource, Clone, ExtractResource, Reflect)]
-#[reflect(Resource)]
+/// Configuration component for [Multi-Sample Anti-Aliasing](https://en.wikipedia.org/wiki/Multisample_anti-aliasing).
+#[derive(Component, Clone, Reflect)]
+#[reflect(Component)]
 pub struct Msaa {
     /// The number of samples to run for Multi-Sample Anti-Aliasing. Higher numbers result in
     /// smoother edges.
@@ -278,13 +266,12 @@ fn prepare_view_targets(
     mut commands: Commands,
     windows: Res<ExtractedWindows>,
     images: Res<RenderAssets<Image>>,
-    msaa: Res<Msaa>,
     render_device: Res<RenderDevice>,
     mut texture_cache: ResMut<TextureCache>,
-    cameras: Query<(Entity, &ExtractedCamera, &ExtractedView)>,
+    cameras: Query<(Entity, &ExtractedCamera, &ExtractedView, &Msaa)>,
 ) {
     let mut textures = HashMap::default();
-    for (entity, camera, view) in cameras.iter() {
+    for (entity, camera, view, msaa) in cameras.iter() {
         if let Some(target_size) = camera.physical_target_size {
             if let (Some(out_texture_view), Some(out_texture_format)) = (
                 camera.target.get_texture_view(&windows, &images),

crates/bevy_sprite/src/mesh2d/material.rs

@@ -320,7 +320,6 @@ pub fn queue_material2d_meshes<M: Material2d>(
     material2d_pipeline: Res<Material2dPipeline<M>>,
     mut pipelines: ResMut<SpecializedMeshPipelines<Material2dPipeline<M>>>,
     mut pipeline_cache: ResMut<PipelineCache>,
-    msaa: Res<Msaa>,
     render_meshes: Res<RenderAssets<Mesh>>,
     render_materials: Res<RenderMaterials2d<M>>,
     material2d_meshes: Query<(&Handle<M>, &Mesh2dHandle, &Mesh2dUniform)>,
@@ -329,6 +328,7 @@ pub fn queue_material2d_meshes<M: Material2d>(
         &VisibleEntities,
         Option<&Tonemapping>,
         &mut RenderPhase<Transparent2d>,
+        &Msaa,
     )>,
 ) where
     M::Data: PartialEq + Eq + Hash + Clone,
@@ -337,7 +337,7 @@ pub fn queue_material2d_meshes<M: Material2d>(
         return;
     }
 
-    for (view, visible_entities, tonemapping, mut transparent_phase) in &mut views {
+    for (view, visible_entities, tonemapping, mut transparent_phase, msaa) in &mut views {
         let draw_transparent_pbr = transparent_draw_functions.read().id::<DrawMaterial2d<M>>();
 
         let mut view_key = Mesh2dPipelineKey::from_msaa_samples(msaa.samples)

crates/bevy_sprite/src/render/mod.rs

@@ -454,13 +454,13 @@ pub fn queue_sprites(
     mut pipeline_cache: ResMut<PipelineCache>,
     mut image_bind_groups: ResMut<ImageBindGroups>,
     gpu_images: Res<RenderAssets<Image>>,
-    msaa: Res<Msaa>,
     mut extracted_sprites: ResMut<ExtractedSprites>,
     mut views: Query<(
         &mut RenderPhase<Transparent2d>,
         &VisibleEntities,
         &ExtractedView,
         Option<&Tonemapping>,
+        &Msaa,
     )>,
     events: Res<SpriteAssetEvents>,
 ) {
@@ -474,8 +474,6 @@ pub fn queue_sprites(
         };
     }
 
-    let msaa_key = SpritePipelineKey::from_msaa_samples(msaa.samples);
-
     if let Some(view_binding) = view_uniforms.uniforms.binding() {
         let sprite_meta = &mut sprite_meta;
 
@@ -516,8 +514,9 @@ pub fn queue_sprites(
         });
         let image_bind_groups = &mut *image_bind_groups;
 
-        for (mut transparent_phase, visible_entities, view, tonemapping) in &mut views {
-            let mut view_key = SpritePipelineKey::from_hdr(view.hdr) | msaa_key;
+        for (mut transparent_phase, visible_entities, view, tonemapping, msaa) in &mut views {
+            let mut view_key = SpritePipelineKey::from_hdr(view.hdr)
+                | SpritePipelineKey::from_msaa_samples(msaa.samples);
             if let Some(Tonemapping::Enabled { deband_dither }) = tonemapping {
                 if !view.hdr {
                     view_key |= SpritePipelineKey::TONEMAP_IN_SHADER;

examples/3d/fxaa.rs

@@ -14,7 +14,6 @@ use bevy::{
 fn main() {
     App::new()
         // Disable MSAA be default
-        .insert_resource(Msaa { samples: 1 })
         .add_plugins(DefaultPlugins)
         .add_startup_system(setup)
         .add_system(toggle_fxaa)
@@ -105,10 +104,11 @@ fn setup(
                 .looking_at(Vec3::new(0.0, 0.3, 0.0), Vec3::Y),
             ..default()
         })
-        .insert(Fxaa::default());
+        .insert(Fxaa::default())
+        .insert(Msaa::default());
 }
 
-fn toggle_fxaa(keys: Res<Input<KeyCode>>, mut query: Query<&mut Fxaa>, mut msaa: ResMut<Msaa>) {
+fn toggle_fxaa(keys: Res<Input<KeyCode>>, mut cameras: Query<(&mut Fxaa, &mut Msaa)>) {
     let set_no_aa = keys.just_pressed(KeyCode::Key1);
     let set_msaa = keys.just_pressed(KeyCode::Key2);
     let set_fxaa = keys.just_pressed(KeyCode::Key3);
@@ -118,7 +118,7 @@ fn toggle_fxaa(keys: Res<Input<KeyCode>>, mut query: Query<&mut Fxaa>, mut msaa:
     let fxaa_ultra = keys.just_pressed(KeyCode::Key9);
     let fxaa_extreme = keys.just_pressed(KeyCode::Key0);
     let set_fxaa = set_fxaa | fxaa_low | fxaa_med | fxaa_high | fxaa_ultra | fxaa_extreme;
-    for mut fxaa in &mut query {
+    for (mut fxaa, mut msaa) in &mut cameras {
         if set_msaa {
             fxaa.enabled = false;
             msaa.samples = 4;

examples/3d/msaa.rs

@@ -10,7 +10,6 @@ use bevy::prelude::*;
 
 fn main() {
     App::new()
-        .insert_resource(Msaa { samples: 4 })
         .add_plugins(DefaultPlugins)
         .add_startup_system(setup)
         .add_system(cycle_msaa)
@@ -38,14 +37,17 @@ fn setup(
         ..default()
     });
     // camera
-    commands.spawn(Camera3dBundle {
-        transform: Transform::from_xyz(-3.0, 3.0, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
-        ..default()
-    });
+    commands
+        .spawn(Camera3dBundle {
+            transform: Transform::from_xyz(-3.0, 3.0, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
+            ..default()
+        })
+        .insert(Msaa { samples: 4 });
 }
 
-fn cycle_msaa(input: Res<Input<KeyCode>>, mut msaa: ResMut<Msaa>) {
+fn cycle_msaa(input: Res<Input<KeyCode>>, mut msaa: Query<&mut Msaa>) {
     if input.just_pressed(KeyCode::M) {
+        let mut msaa = msaa.single_mut();
         if msaa.samples == 4 {
             info!("Not using MSAA");
             msaa.samples = 1;

examples/3d/transparency_3d.rs

@@ -6,7 +6,6 @@ use bevy::prelude::*;
 
 fn main() {
     App::new()
-        .insert_resource(Msaa { samples: 4 })
         .add_plugins(DefaultPlugins)
         .add_startup_system(setup)
         .add_system(fade_transparency)
@@ -99,10 +98,12 @@ fn setup(
         ..default()
     });
     // camera
-    commands.spawn(Camera3dBundle {
-        transform: Transform::from_xyz(-2.0, 3.0, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
-        ..default()
-    });
+    commands
+        .spawn(Camera3dBundle {
+            transform: Transform::from_xyz(-2.0, 3.0, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
+            ..default()
+        })
+        .insert(Msaa::default());
 }
 
 /// Fades the alpha channel of all materials between 0 and 1 over time.