Easy demo recording (#21243)

# Objective

- Followup on #21237
- It can be hard to share how to record a demo for a specific feature
- Make it easy

## Solution

- Add a dev plugin that can move the camera
- Add plumbing to CI testing to be able to move the camera and control
screen recording
- Demo can be configured in code or in a configuration file

## Testing

- Add to an example:
```rs
let fps = 120; // FPS for the example on your computer

[...]

// Before `DefaultPlugins`:
        .insert_resource(CiTestingConfig {
            events: vec![
                CiTestingEventOnFrame(fps * 1, ci_testing::CiTestingEvent::StartScreenRecording),
                {
                    let transform = Transform::from_xyz(0.7, 0.7, -1.0)
                        .looking_at(Vec3::new(0.0, 0.3, 0.0), Vec3::Y);
                    CiTestingEventOnFrame(
                        fps * 6,
                        ci_testing::CiTestingEvent::MoveCamera {
                            translation: transform.translation,
                            rotation: transform.rotation,
                        },
                    )
                },
                {
                    let transform = Transform::from_xyz(-0.7, 0.7, -1.0)
                        .looking_at(Vec3::new(0.0, 0.3, 0.0), Vec3::Y);
                    CiTestingEventOnFrame(
                        fps * 11,
                        ci_testing::CiTestingEvent::MoveCamera {
                            translation: transform.translation,
                            rotation: transform.rotation,
                        },
                    )
                },
                {
                    let transform = Transform::from_xyz(-0.7, 0.7, 1.0)
                        .looking_at(Vec3::new(0.0, 0.3, 0.0), Vec3::Y);
                    CiTestingEventOnFrame(
                        fps * 16,
                        ci_testing::CiTestingEvent::MoveCamera {
                            translation: transform.translation,
                            rotation: transform.rotation,
                        },
                    )
                },
                {
                    let transform = Transform::from_xyz(0.7, 0.7, 1.0)
                        .looking_at(Vec3::new(0.0, 0.3, 0.0), Vec3::Y);
                    CiTestingEventOnFrame(
                        fps * 21,
                        ci_testing::CiTestingEvent::MoveCamera {
                            translation: transform.translation,
                            rotation: transform.rotation,
                        },
                    )
                },
                CiTestingEventOnFrame(fps * 26, ci_testing::CiTestingEvent::StopScreenRecording),
            ],
            ..default()
        })
```
- Run the example with `--features
bevy_internal/screenrecording,bevy_ci_testing`
- Lay back, enjoy your demo recording
---

## Showcase



https://github.com/user-attachments/assets/bbd9e56d-58c1-41eb-b6b4-1f1db2f2dab5

Author: mockersf

crates/bevy_dev_tools/Cargo.toml

@@ -30,6 +30,7 @@ bevy_render = { path = "../bevy_render", version = "0.18.0-dev" }
 bevy_reflect = { path = "../bevy_reflect", version = "0.18.0-dev" }
 bevy_time = { path = "../bevy_time", version = "0.18.0-dev" }
 bevy_text = { path = "../bevy_text", version = "0.18.0-dev" }
+bevy_transform = { path = "../bevy_transform", version = "0.18.0-dev" }
 bevy_shader = { path = "../bevy_shader", version = "0.18.0-dev" }
 bevy_ui = { path = "../bevy_ui", version = "0.18.0-dev" }
 bevy_ui_render = { path = "../bevy_ui_render", version = "0.18.0-dev" }

crates/bevy_dev_tools/src/ci_testing/config.rs

@@ -1,12 +1,13 @@
 use bevy_ecs::prelude::*;
+use bevy_math::{Quat, Vec3};
 use serde::Deserialize;
 
 /// A configuration struct for automated CI testing.
 ///
 /// It gets used when the `bevy_ci_testing` feature is enabled to automatically
 /// exit a Bevy app when run through the CI. This is needed because otherwise
 /// Bevy apps would be stuck in the game loop and wouldn't allow the CI to progress.
-#[derive(Deserialize, Resource, PartialEq, Debug, Default)]
+#[derive(Deserialize, Resource, PartialEq, Debug, Default, Clone)]
 pub struct CiTestingConfig {
     /// The setup for this test.
     #[serde(default)]
@@ -17,7 +18,7 @@ pub struct CiTestingConfig {
 }
 
 /// Setup for a test.
-#[derive(Deserialize, Default, PartialEq, Debug)]
+#[derive(Deserialize, Default, PartialEq, Debug, Clone)]
 pub struct CiTestingSetup {
     /// The amount of time in seconds between frame updates.
     ///
@@ -28,11 +29,11 @@ pub struct CiTestingSetup {
 }
 
 /// An event to send at a given frame, used for CI testing.
-#[derive(Deserialize, PartialEq, Debug)]
+#[derive(Deserialize, PartialEq, Debug, Clone)]
 pub struct CiTestingEventOnFrame(pub u32, pub CiTestingEvent);
 
 /// An event to send, used for CI testing.
-#[derive(Deserialize, PartialEq, Debug)]
+#[derive(Deserialize, PartialEq, Debug, Clone)]
 pub enum CiTestingEvent {
     /// Takes a screenshot of the entire screen, and saves the results to
     /// `screenshot-{current_frame}.png`.
@@ -47,6 +48,17 @@ pub enum CiTestingEvent {
     ///
     /// [`AppExit::Success`]: bevy_app::AppExit::Success
     AppExit,
+    /// Starts recording the screen.
+    StartScreenRecording,
+    /// Stops recording the screen.
+    StopScreenRecording,
+    /// Smoothly moves the camera to the given position.
+    MoveCamera {
+        /// Position to move the camera to.
+        translation: Vec3,
+        /// Rotation to move the camera to.
+        rotation: Quat,
+    },
     /// Sends a [`CiTestingCustomEvent`] using the given [`String`].
     Custom(String),
 }

crates/bevy_dev_tools/src/ci_testing/mod.rs

@@ -3,6 +3,10 @@
 mod config;
 mod systems;
 
+use crate::EasyCameraMovementPlugin;
+#[cfg(feature = "screenrecording")]
+use crate::EasyScreenRecordPlugin;
+
 pub use self::config::*;
 
 use bevy_app::prelude::*;
@@ -26,24 +30,48 @@ pub struct CiTestingPlugin;
 
 impl Plugin for CiTestingPlugin {
     fn build(&self, app: &mut App) {
-        #[cfg(not(target_arch = "wasm32"))]
-        let config: CiTestingConfig = {
-            let filename = std::env::var("CI_TESTING_CONFIG")
-                .unwrap_or_else(|_| "ci_testing_config.ron".to_string());
-            std::fs::read_to_string(filename)
-                .map(|content| {
-                    ron::from_str(&content)
-                        .expect("error deserializing CI testing configuration file")
-                })
-                .unwrap_or_default()
-        };
+        let config = if !app.world().is_resource_added::<CiTestingConfig>() {
+            // Load configuration from file if not already setup
+            #[cfg(not(target_arch = "wasm32"))]
+            let config: CiTestingConfig = {
+                let filename = std::env::var("CI_TESTING_CONFIG")
+                    .unwrap_or_else(|_| "ci_testing_config.ron".to_string());
+                std::fs::read_to_string(filename)
+                    .map(|content| {
+                        ron::from_str(&content)
+                            .expect("error deserializing CI testing configuration file")
+                    })
+                    .unwrap_or_default()
+            };
+
+            #[cfg(target_arch = "wasm32")]
+            let config: CiTestingConfig = {
+                let config = include_str!("../../../../ci_testing_config.ron");
+                ron::from_str(config).expect("error deserializing CI testing configuration file")
+            };
 
-        #[cfg(target_arch = "wasm32")]
-        let config: CiTestingConfig = {
-            let config = include_str!("../../../../ci_testing_config.ron");
-            ron::from_str(config).expect("error deserializing CI testing configuration file")
+            config
+        } else {
+            app.world().resource::<CiTestingConfig>().clone()
         };
 
+        // Add the `EasyCameraMovementPlugin` to the app if it's not already added.
+        // To configure the movement speed, add the plugin first.
+        if !app.is_plugin_added::<EasyCameraMovementPlugin>() {
+            app.add_plugins(EasyCameraMovementPlugin::default());
+        }
+        // Add the `EasyScreenRecordPlugin` to the app if it's not already added and one of the event is starting screenrecording.
+        // To configure the recording quality, add the plugin first.
+        #[cfg(feature = "screenrecording")]
+        if !app.is_plugin_added::<EasyScreenRecordPlugin>()
+            && config
+                .events
+                .iter()
+                .any(|e| matches!(e.1, CiTestingEvent::StartScreenRecording))
+        {
+            app.add_plugins(EasyScreenRecordPlugin::default());
+        }
+
         // Configure a fixed frame time if specified.
         if let Some(fixed_frame_time) = config.setup.fixed_frame_time {
             app.insert_resource(TimeUpdateStrategy::ManualDuration(Duration::from_secs_f32(

crates/bevy_dev_tools/src/ci_testing/systems.rs

@@ -1,5 +1,8 @@
+use crate::CameraMovement;
+
 use super::config::*;
 use bevy_app::AppExit;
+use bevy_camera::Camera;
 use bevy_ecs::prelude::*;
 use bevy_render::view::screenshot::{save_to_disk, Screenshot};
 use tracing::{debug, info};
@@ -51,6 +54,28 @@ pub(crate) fn send_events(world: &mut World, mut current_frame: Local<u32>) {
                     *current_frame, name
                 );
             }
+            CiTestingEvent::StartScreenRecording => {
+                info!("Started recording screen at frame {}.", *current_frame);
+                #[cfg(feature = "screenrecording")]
+                world.write_message(crate::RecordScreen::Start);
+            }
+            CiTestingEvent::StopScreenRecording => {
+                info!("Stopped recording screen at frame {}.", *current_frame);
+                #[cfg(feature = "screenrecording")]
+                world.write_message(crate::RecordScreen::Stop);
+            }
+            CiTestingEvent::MoveCamera {
+                translation,
+                rotation,
+            } => {
+                info!("Moved camera at frame {}.", *current_frame);
+                if let Ok(camera) = world.query_filtered::<Entity, With<Camera>>().single(world) {
+                    world.entity_mut(camera).insert(CameraMovement {
+                        translation,
+                        rotation,
+                    });
+                }
+            }
             // Custom events are forwarded to the world.
             CiTestingEvent::Custom(event_string) => {
                 world.write_message(CiTestingCustomEvent(event_string));

crates/bevy_dev_tools/src/easy_screenshot.rs

@@ -2,10 +2,14 @@
 use core::time::Duration;
 use std::time::{SystemTime, UNIX_EPOCH};
 
-use bevy_app::{App, Plugin, Update};
+use bevy_app::{App, Plugin, PostUpdate, Update};
+use bevy_camera::Camera;
 use bevy_ecs::prelude::*;
 use bevy_input::{common_conditions::input_just_pressed, keyboard::KeyCode};
+use bevy_math::{Quat, StableInterpolate, Vec3};
 use bevy_render::view::screenshot::{save_to_disk, Screenshot};
+use bevy_time::Time;
+use bevy_transform::{components::Transform, TransformSystems};
 use bevy_window::{PrimaryWindow, Window};
 #[cfg(all(not(target_os = "windows"), feature = "screenrecording"))]
 pub use x264::{Preset, Tune};
@@ -311,3 +315,52 @@ impl Plugin for EasyScreenRecordPlugin {
         }
     }
 }
+
+/// Plugin to move the camera smoothly according to the current time
+pub struct EasyCameraMovementPlugin {
+    /// Decay rate for the camera movement
+    pub decay_rate: f32,
+}
+
+impl Default for EasyCameraMovementPlugin {
+    fn default() -> Self {
+        Self { decay_rate: 1.0 }
+    }
+}
+
+/// Move the camera to the given position
+#[derive(Component)]
+pub struct CameraMovement {
+    /// Target position for the camera movement
+    pub translation: Vec3,
+    /// Target rotation for the camera movement
+    pub rotation: Quat,
+}
+
+impl Plugin for EasyCameraMovementPlugin {
+    fn build(&self, app: &mut App) {
+        let decay_rate = self.decay_rate;
+        app.add_systems(
+            PostUpdate,
+            (move |mut query: Single<(&mut Transform, &CameraMovement), With<Camera>>,
+                   time: Res<Time>| {
+                {
+                    {
+                        let target = query.1;
+                        query.0.translation.smooth_nudge(
+                            &target.translation,
+                            decay_rate,
+                            time.delta_secs(),
+                        );
+                        query.0.rotation.smooth_nudge(
+                            &target.rotation,
+                            decay_rate,
+                            time.delta_secs(),
+                        );
+                    }
+                }
+            })
+            .before(TransformSystems::Propagate),
+        );
+    }
+}