remove ColorBlindnessParams

This commit moves `mode` and `enabled` into `ColorBlindnessCamera`,
which allows for multiple cameras with different modes.

This should allow multiple windows to work correctly, but it hasn't been tested yet.

Author: annieversary

crates/bevy_color_blindness/src/lib.rs

@@ -2,12 +2,12 @@
 //! color blindness.
 
 use bevy_app::{App, Plugin};
-use bevy_asset::{load_internal_asset, AssetServer, Assets, Handle, HandleUntyped};
+use bevy_asset::{load_internal_asset, Assets, Handle, HandleUntyped};
 use bevy_core_pipeline::core_2d::Camera2dBundle;
 use bevy_ecs::{
     component::Component,
     entity::Entity,
-    query::Added,
+    query::{Added, Changed},
     system::{Commands, Query, Res, ResMut},
 };
 use bevy_math::{Vec2, Vec3};
@@ -44,9 +44,6 @@ use bevy_window::Windows;
 /// First, add the [`ColorBlindnessPlugin`] to your app, and add [`ColorBlindnessCamera`] to
 /// your main camera.
 ///
-/// You can change the selected mode by inserting [`ColorBlindnessParams`] before the plugin.
-/// You can also skip this, and change the resource at any time in a system.
-///
 /// ```rust,no_run
 /// # use bevy_app::{App, NoopPluginGroup as DefaultPlugins};
 /// # use bevy_color_blindness::*;
@@ -57,10 +54,6 @@ use bevy_window::Windows;
 /// fn main() {
 ///     App::new()
 ///         .add_plugins(DefaultPlugins)
-///         .insert_resource(ColorBlindnessParams {
-///             mode: ColorBlindnessMode::Deuteranomaly,
-///             enable: true,
-///         })
 ///         // add the plugin
 ///         .add_plugin(ColorBlindnessPlugin)
 ///         .add_startup_system(setup)
@@ -73,11 +66,13 @@ use bevy_window::Windows;
 ///     // create the camera
 ///     commands
 ///         .spawn_bundle(Camera3dBundle {
-///           transform: Transform::from_xyz(-2.0, 2.5, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
-///           ..Default::default()
+///             transform: Transform::from_xyz(-2.0, 2.5, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
+///             ..Default::default()
 ///         })
-///         // IMPORTANT: add this component to your main camera
-///         .insert(ColorBlindnessCamera);
+///         .insert(ColorBlindnessCamera {
+///             mode: ColorBlindnessMode::Deuteranopia,
+///             enabled: true,
+///         });
 /// }
 /// ```
 ///
@@ -89,19 +84,15 @@ use bevy_window::Windows;
 pub struct ColorBlindnessPlugin;
 impl Plugin for ColorBlindnessPlugin {
     fn build(&self, app: &mut App) {
-        let world = &mut app.world;
-        world.get_resource_or_insert_with(ColorBlindnessParams::default);
-
         load_internal_asset!(
             app,
             COLOR_BLINDNESS_SHADER_HANDLE,
             "color_blindness.wgsl",
             Shader::from_wgsl
         );
 
-        app.add_plugin(Material2dPlugin::<PostProcessingMaterial>::default())
-            .add_startup_system(setup)
-            .add_system(set_camera_target)
+        app.add_plugin(Material2dPlugin::<ColorBlindnessMaterial>::default())
+            .add_system(setup_new_color_blindness_cameras)
             .add_system(update_percentages);
     }
 }
@@ -110,41 +101,6 @@ impl Plugin for ColorBlindnessPlugin {
 const COLOR_BLINDNESS_SHADER_HANDLE: HandleUntyped =
     HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 3937837360667146578);
 
-/// Resource which selects the type of color blindness to simulate
-///
-/// # Example
-///
-/// This system will only enable the simulation while `Space` is held, and will cycle through
-/// the different modes when `N` is pressed.
-///
-/// ```rust
-/// # use bevy_app::prelude::*;
-/// # use bevy_color_blindness::*;
-/// # use bevy_ecs::prelude::*;
-/// # use bevy_input::prelude::*;
-/// # use bevy_math::prelude::*;
-/// # use bevy_transform::prelude::*;
-/// fn cycle_mode(input: Res<Input<KeyCode>>, mut params: ResMut<ColorBlindnessParams>) {
-///     if input.just_pressed(KeyCode::N) {
-///         params.mode.cycle();
-///         println!("Changed to {:?}", params.mode);
-///     }
-///
-///     params.enable = input.pressed(KeyCode::Space);
-/// }
-/// ```
-#[derive(Default, Debug)]
-pub struct ColorBlindnessParams {
-    /// Selects the color blindness mode to use
-    ///
-    /// Defaults to `ColorBlindnessMode::Normal`
-    pub mode: ColorBlindnessMode,
-    /// Controls whether color blindness simulation is enabled
-    ///
-    /// Defaults to `false`
-    pub enable: bool,
-}
-
 /// The different modes of color blindness simulation supported.
 #[derive(Clone, Default, Debug)]
 pub enum ColorBlindnessMode {
@@ -267,11 +223,16 @@ impl ColorBlindnessMode {
     /// # use bevy_color_blindness::*;
     /// # use bevy_ecs::prelude::*;
     /// # use bevy_input::prelude::*;
-    /// fn cycle_mode(input: Res<Input<KeyCode>>, mut params: ResMut<ColorBlindnessParams>) {
+    /// fn change_mode(input: Res<Input<KeyCode>>, mut cameras: Query<&mut ColorBlindnessCamera>) {
+    ///   for mut camera in &mut cameras {
+    ///     // cycle through the modes by pressing N
     ///     if input.just_pressed(KeyCode::N) {
-    ///         params.mode.cycle();
-    ///         println!("Changed to {:?}", params.mode);
+    ///       camera.mode.cycle();
+    ///       println!("Changed to {:?}", camera.mode);
     ///     }
+    ///
+    ///     camera.enabled = input.pressed(KeyCode::Space);
+    ///   }
     /// }
     /// ```
     pub fn cycle(&mut self) {
@@ -292,7 +253,7 @@ impl ColorBlindnessMode {
 /// Post processing material that applies color blindness simulation to `image`
 #[derive(AsBindGroup, TypeUuid, Clone)]
 #[uuid = "bc2f08eb-a0fb-43f1-a908-54871ea597d5"]
-struct PostProcessingMaterial {
+struct ColorBlindnessMaterial {
     /// In this example, this image will be the result of the main camera.
     #[texture(0)]
     #[sampler(1)]
@@ -302,7 +263,7 @@ struct PostProcessingMaterial {
     percentages: ColorBlindnessPercentages,
 }
 
-impl Material2d for PostProcessingMaterial {
+impl Material2d for ColorBlindnessMaterial {
     fn fragment_shader() -> ShaderRef {
         ShaderRef::Handle(COLOR_BLINDNESS_SHADER_HANDLE.typed())
     }
@@ -320,34 +281,31 @@ impl Material2d for PostProcessingMaterial {
 /// If for some reason this behavior is not desired, please open an issue.
 ///
 /// [`UiCameraConfig`]: bevy_ui::entity::UiCameraConfig
-#[derive(Component)]
-pub struct ColorBlindnessCamera;
-
-/// sets the target for newly added `ColorBlindCamera`s
-fn set_camera_target(
-    mut commands: Commands,
-    mut query: Query<(Entity, &mut Camera), Added<ColorBlindnessCamera>>,
-    inner: Res<InternalResource>,
-) {
-    for (entity, mut camera) in query.iter_mut() {
-        camera.target = RenderTarget::Image(inner.image.clone());
-        commands
-            .entity(entity)
-            .insert(UiCameraConfig { show_ui: false });
-    }
+#[derive(Component, Default)]
+pub struct ColorBlindnessCamera {
+    /// Selects the color blindness mode to use
+    ///
+    /// Defaults to `ColorBlindnessMode::Normal`
+    pub mode: ColorBlindnessMode,
+    /// Controls whether color blindness simulation is enabled
+    ///
+    /// Defaults to `false`
+    pub enabled: bool,
 }
 
-/// updates the percentages in the post processing material when the `ColorBlindnessMode` changes in Params
+/// updates the percentages in the post processing material when the values in `ColorBlindnessCamera` change
 fn update_percentages(
-    params: Res<ColorBlindnessParams>,
-    inner: Res<InternalResource>,
-    mut materials: ResMut<Assets<PostProcessingMaterial>>,
+    cameras: Query<
+        (&Handle<ColorBlindnessMaterial>, &ColorBlindnessCamera),
+        Changed<ColorBlindnessCamera>,
+    >,
+    mut materials: ResMut<Assets<ColorBlindnessMaterial>>,
 ) {
-    if params.is_changed() {
-        let mut mat = materials.get_mut(&inner.post).unwrap();
+    for (handle, camera) in &cameras {
+        let mut mat = materials.get_mut(handle).unwrap();
 
-        let mode = if params.enable {
-            &params.mode
+        let mode = if camera.enabled {
+            &camera.mode
         } else {
             &ColorBlindnessMode::Normal
         };
@@ -356,96 +314,102 @@ fn update_percentages(
     }
 }
 
-/// internal resource which holds the handles
-struct InternalResource {
-    image: Handle<Image>,
-    post: Handle<PostProcessingMaterial>,
-}
-
-/// creates the image, the material, the final camera, and the whole post-processing pipeline
-///
-/// based on the post-processing example
-/// `https://github.com/bevyengine/bevy/blob/main/examples/shader/post_processing.rs`
-fn setup(
+/// sets up post processing for cameras that have had `ColorBlindnessCamera` added
+fn setup_new_color_blindness_cameras(
     mut commands: Commands,
-    mut windows: ResMut<Windows>,
+    windows: Res<Windows>,
     mut meshes: ResMut<Assets<Mesh>>,
-    mut post_processing_materials: ResMut<Assets<PostProcessingMaterial>>,
+    mut post_processing_materials: ResMut<Assets<ColorBlindnessMaterial>>,
     mut images: ResMut<Assets<Image>>,
-    asset_server: Res<AssetServer>,
-    params: Res<ColorBlindnessParams>,
+    mut cameras: Query<(Entity, &mut Camera, &ColorBlindnessCamera), Added<ColorBlindnessCamera>>,
 ) {
-    asset_server.watch_for_changes().unwrap();
+    for (entity, mut camera, color_blindness_camera) in &mut cameras {
+        // Get the size the camera is rendering to
+        let size = match &camera.target {
+            RenderTarget::Window(window_id) => {
+                let window = windows.get(*window_id).expect("ColorBlindnessCamera is rendering to a window, but this window could not be found");
+                Extent3d {
+                    width: window.physical_width(),
+                    height: window.physical_height(),
+                    ..Default::default()
+                }
+            }
+            RenderTarget::Image(handle) => {
+                let image = images.get(handle).expect(
+                    "ColorBlindnessCamera is rendering to an Image, but this Image could not be found",
+                );
+                image.texture_descriptor.size
+            }
+        };
 
-    let window = windows.get_primary_mut().unwrap();
-    let size = Extent3d {
-        width: window.physical_width(),
-        height: window.physical_height(),
-        ..Default::default()
-    };
+        // This is the texture that will be rendered to.
+        let mut image = Image {
+            texture_descriptor: TextureDescriptor {
+                label: None,
+                size,
+                dimension: TextureDimension::D2,
+                format: TextureFormat::bevy_default(),
+                mip_level_count: 1,
+                sample_count: 1,
+                usage: TextureUsages::TEXTURE_BINDING
+                    | TextureUsages::COPY_DST
+                    | TextureUsages::RENDER_ATTACHMENT,
+            },
+            ..Default::default()
+        };
 
-    // This is the texture that will be rendered to.
-    let mut image = Image {
-        texture_descriptor: TextureDescriptor {
-            label: None,
-            size,
-            dimension: TextureDimension::D2,
-            format: TextureFormat::bevy_default(),
-            mip_level_count: 1,
-            sample_count: 1,
-            usage: TextureUsages::TEXTURE_BINDING
-                | TextureUsages::COPY_DST
-                | TextureUsages::RENDER_ATTACHMENT,
-        },
-        ..Default::default()
-    };
+        // fill image.data with zeroes
+        image.resize(size);
 
-    // fill image.data with zeroes
-    image.resize(size);
+        let image_handle = images.add(image);
 
-    let image_handle = images.add(image);
+        // This specifies the layer used for the post processing camera, which will be attached to the post processing camera and 2d quad.
+        let post_processing_pass_layer =
+            RenderLayers::layer((RenderLayers::TOTAL_LAYERS - 1) as u8);
 
-    // This specifies the layer used for the post processing camera, which will be attached to the post processing camera and 2d quad.
-    let post_processing_pass_layer = RenderLayers::layer((RenderLayers::TOTAL_LAYERS - 1) as u8);
+        let quad_handle = meshes.add(Mesh::from(shape::Quad::new(Vec2::new(
+            size.width as f32,
+            size.height as f32,
+        ))));
 
-    let quad_handle = meshes.add(Mesh::from(shape::Quad::new(Vec2::new(
-        size.width as f32,
-        size.height as f32,
-    ))));
+        // This material has the texture that has been rendered.
+        let material_handle = post_processing_materials.add(ColorBlindnessMaterial {
+            source_image: image_handle.clone(),
+            percentages: color_blindness_camera.mode.percentages(),
+        });
 
-    // This material has the texture that has been rendered.
-    let material_handle = post_processing_materials.add(PostProcessingMaterial {
-        source_image: image_handle.clone(),
-        percentages: params.mode.percentages(),
-    });
+        commands
+            .entity(entity)
+            // add the handle to the camera so we can access it and change the percentages
+            .insert(material_handle.clone())
+            // also disable show_ui so UI elements don't get rendered twice
+            .insert(UiCameraConfig { show_ui: false });
 
-    commands.insert_resource(InternalResource {
-        image: image_handle,
-        post: material_handle.clone(),
-    });
+        camera.target = RenderTarget::Image(image_handle);
 
-    // Post processing 2d quad, with material using the render texture done by the main camera, with a custom shader.
-    commands
-        .spawn_bundle(MaterialMesh2dBundle {
-            mesh: quad_handle.into(),
-            material: material_handle,
-            transform: Transform {
-                translation: Vec3::new(0.0, 0.0, 1.5),
+        // Post processing 2d quad, with material using the render texture done by the main camera, with a custom shader.
+        commands
+            .spawn_bundle(MaterialMesh2dBundle {
+                mesh: quad_handle.into(),
+                material: material_handle,
+                transform: Transform {
+                    translation: Vec3::new(0.0, 0.0, 1.5),
+                    ..Default::default()
+                },
                 ..Default::default()
-            },
-            ..Default::default()
-        })
-        .insert(post_processing_pass_layer);
+            })
+            .insert(post_processing_pass_layer);
 
-    // The post-processing pass camera.
-    commands
-        .spawn_bundle(Camera2dBundle {
-            camera: Camera {
-                // renders after the first main camera which has default value: 0.
-                priority: 1,
-                ..Default::default()
-            },
-            ..Camera2dBundle::default()
-        })
-        .insert(post_processing_pass_layer);
+        // The post-processing pass camera.
+        commands
+            .spawn_bundle(Camera2dBundle {
+                camera: Camera {
+                    // renders after the first main camera which has default value: 0.
+                    priority: 1,
+                    ..Default::default()
+                },
+                ..Camera2dBundle::default()
+            })
+            .insert(post_processing_pass_layer);
+    }
 }