mirror of
https://github.com/bevyengine/bevy
synced 2024-12-21 10:33:08 +00:00
5c52d0aeee
# Objective Add interactive system debugging capabilities to bevy, providing step/break/continue style capabilities to running system schedules. * Original implementation: #8063 - `ignore_stepping()` everywhere was too much complexity * Schedule-config & Resource discussion: #8168 - Decided on selective adding of Schedules & Resource-based control ## Solution Created `Stepping` Resource. This resource can be used to enable stepping on a per-schedule basis. Systems within schedules can be individually configured to: * AlwaysRun: Ignore any stepping state and run every frame * NeverRun: Never run while stepping is enabled - this allows for disabling of systems while debugging * Break: If we're running the full frame, stop before this system is run Stepping provides two modes of execution that reflect traditional debuggers: * Step-based: Only execute one system at a time * Continue/Break: Run all systems, but stop before running a system marked as Break ### Demo https://user-images.githubusercontent.com/857742/233630981-99f3bbda-9ca6-4cc4-a00f-171c4946dc47.mov Breakout has been modified to use Stepping. The game runs normally for a couple of seconds, then stepping is enabled and the game appears to pause. A list of Schedules & Systems appears with a cursor at the first System in the list. The demo then steps forward full frames using the spacebar until the ball is about to hit a brick. Then we step system by system as the ball impacts a brick, showing the cursor moving through the individual systems. Finally the demo switches back to frame stepping as the ball changes course. ### Limitations Due to architectural constraints in bevy, there are some cases systems stepping will not function as a user would expect. #### Event-driven systems Stepping does not support systems that are driven by `Event`s as events are flushed after 1-2 frames. Although game systems are not running while stepping, ignored systems are still running every frame, so events will be flushed. This presents to the user as stepping the event-driven system never executes the system. It does execute, but the events have already been flushed. This can be resolved by changing event handling to use a buffer for events, and only dropping an event once all readers have read it. The work-around to allow these systems to properly execute during stepping is to have them ignore stepping: `app.add_systems(event_driven_system.ignore_stepping())`. This was done in the breakout example to ensure sound played even while stepping. #### Conditional Systems When a system is stepped, it is given an opportunity to run. If the conditions of the system say it should not run, it will not. Similar to Event-driven systems, if a system is conditional, and that condition is only true for a very small time window, then stepping the system may not execute the system. This includes depending on any sort of external clock. This exhibits to the user as the system not always running when it is stepped. A solution to this limitation is to ensure any conditions are consistent while stepping is enabled. For example, all systems that modify any state the condition uses should also enable stepping. #### State-transition Systems Stepping is configured on the per-`Schedule` level, requiring the user to have a `ScheduleLabel`. To support state-transition systems, bevy generates needed schedules dynamically. Currently it’s very difficult (if not impossible, I haven’t verified) for the user to get the labels for these schedules. Without ready access to the dynamically generated schedules, and a resolution for the `Event` lifetime, **stepping of the state-transition systems is not supported** --- ## Changelog - `Schedule::run()` updated to consult `Stepping` Resource to determine which Systems to run each frame - Added `Schedule.label` as a `BoxedSystemLabel`, along with supporting `Schedule::set_label()` and `Schedule::label()` methods - `Stepping` needed to know which `Schedule` was running, and prior to this PR, `Schedule` didn't track its own label - Would have preferred to add `Schedule::with_label()` and remove `Schedule::new()`, but this PR touches enough already - Added calls to `Schedule.set_label()` to `App` and `World` as needed - Added `Stepping` resource - Added `Stepping::begin_frame()` system to `MainSchedulePlugin` - Run before `Main::run_main()` - Notifies any `Stepping` Resource a new render frame is starting ## Migration Guide - Add a call to `Schedule::set_label()` for any custom `Schedule` - This is only required if the `Schedule` will be stepped --------- Co-authored-by: Carter Anderson <mcanders1@gmail.com>
1158 lines
39 KiB
Rust
1158 lines
39 KiB
Rust
//! Contains APIs for ordering systems and executing them on a [`World`](crate::world::World)
|
|
|
|
mod condition;
|
|
mod config;
|
|
mod executor;
|
|
mod graph_utils;
|
|
#[allow(clippy::module_inception)]
|
|
mod schedule;
|
|
mod set;
|
|
mod state;
|
|
mod stepping;
|
|
|
|
pub use self::condition::*;
|
|
pub use self::config::*;
|
|
pub use self::executor::*;
|
|
use self::graph_utils::*;
|
|
pub use self::schedule::*;
|
|
pub use self::set::*;
|
|
pub use self::state::*;
|
|
|
|
pub use self::graph_utils::NodeId;
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use std::sync::atomic::{AtomicU32, Ordering};
|
|
|
|
pub use crate as bevy_ecs;
|
|
pub use crate::schedule::{IntoSystemSetConfigs, Schedule, SystemSet};
|
|
pub use crate::system::{Res, ResMut};
|
|
pub use crate::{prelude::World, system::Resource};
|
|
|
|
#[derive(SystemSet, Clone, Debug, PartialEq, Eq, Hash)]
|
|
enum TestSet {
|
|
A,
|
|
B,
|
|
C,
|
|
D,
|
|
X,
|
|
}
|
|
|
|
#[derive(Resource, Default)]
|
|
struct SystemOrder(Vec<u32>);
|
|
|
|
#[derive(Resource, Default)]
|
|
struct RunConditionBool(pub bool);
|
|
|
|
#[derive(Resource, Default)]
|
|
struct Counter(pub AtomicU32);
|
|
|
|
fn make_exclusive_system(tag: u32) -> impl FnMut(&mut World) {
|
|
move |world| world.resource_mut::<SystemOrder>().0.push(tag)
|
|
}
|
|
|
|
fn make_function_system(tag: u32) -> impl FnMut(ResMut<SystemOrder>) {
|
|
move |mut resource: ResMut<SystemOrder>| resource.0.push(tag)
|
|
}
|
|
|
|
fn named_system(mut resource: ResMut<SystemOrder>) {
|
|
resource.0.push(u32::MAX);
|
|
}
|
|
|
|
fn named_exclusive_system(world: &mut World) {
|
|
world.resource_mut::<SystemOrder>().0.push(u32::MAX);
|
|
}
|
|
|
|
fn counting_system(counter: Res<Counter>) {
|
|
counter.0.fetch_add(1, Ordering::Relaxed);
|
|
}
|
|
|
|
mod system_execution {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn run_system() {
|
|
let mut world = World::default();
|
|
let mut schedule = Schedule::default();
|
|
|
|
world.init_resource::<SystemOrder>();
|
|
|
|
schedule.add_systems(make_function_system(0));
|
|
schedule.run(&mut world);
|
|
|
|
assert_eq!(world.resource::<SystemOrder>().0, vec![0]);
|
|
}
|
|
|
|
#[test]
|
|
fn run_exclusive_system() {
|
|
let mut world = World::default();
|
|
let mut schedule = Schedule::default();
|
|
|
|
world.init_resource::<SystemOrder>();
|
|
|
|
schedule.add_systems(make_exclusive_system(0));
|
|
schedule.run(&mut world);
|
|
|
|
assert_eq!(world.resource::<SystemOrder>().0, vec![0]);
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(not(miri))]
|
|
fn parallel_execution() {
|
|
use bevy_tasks::{ComputeTaskPool, TaskPool};
|
|
use std::sync::{Arc, Barrier};
|
|
|
|
let mut world = World::default();
|
|
let mut schedule = Schedule::default();
|
|
let thread_count = ComputeTaskPool::get_or_init(TaskPool::default).thread_num();
|
|
|
|
let barrier = Arc::new(Barrier::new(thread_count));
|
|
|
|
for _ in 0..thread_count {
|
|
let inner = barrier.clone();
|
|
schedule.add_systems(move || {
|
|
inner.wait();
|
|
});
|
|
}
|
|
|
|
schedule.run(&mut world);
|
|
}
|
|
}
|
|
|
|
mod system_ordering {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn order_systems() {
|
|
let mut world = World::default();
|
|
let mut schedule = Schedule::default();
|
|
|
|
world.init_resource::<SystemOrder>();
|
|
|
|
schedule.add_systems((
|
|
named_system,
|
|
make_function_system(1).before(named_system),
|
|
make_function_system(0)
|
|
.after(named_system)
|
|
.in_set(TestSet::A),
|
|
));
|
|
schedule.run(&mut world);
|
|
|
|
assert_eq!(world.resource::<SystemOrder>().0, vec![1, u32::MAX, 0]);
|
|
|
|
world.insert_resource(SystemOrder::default());
|
|
|
|
assert_eq!(world.resource::<SystemOrder>().0, vec![]);
|
|
|
|
// modify the schedule after it's been initialized and test ordering with sets
|
|
schedule.configure_sets(TestSet::A.after(named_system));
|
|
schedule.add_systems((
|
|
make_function_system(3)
|
|
.before(TestSet::A)
|
|
.after(named_system),
|
|
make_function_system(4).after(TestSet::A),
|
|
));
|
|
schedule.run(&mut world);
|
|
|
|
assert_eq!(
|
|
world.resource::<SystemOrder>().0,
|
|
vec![1, u32::MAX, 3, 0, 4]
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn order_exclusive_systems() {
|
|
let mut world = World::default();
|
|
let mut schedule = Schedule::default();
|
|
|
|
world.init_resource::<SystemOrder>();
|
|
|
|
schedule.add_systems((
|
|
named_exclusive_system,
|
|
make_exclusive_system(1).before(named_exclusive_system),
|
|
make_exclusive_system(0).after(named_exclusive_system),
|
|
));
|
|
schedule.run(&mut world);
|
|
|
|
assert_eq!(world.resource::<SystemOrder>().0, vec![1, u32::MAX, 0]);
|
|
}
|
|
|
|
#[test]
|
|
fn add_systems_correct_order() {
|
|
let mut world = World::new();
|
|
let mut schedule = Schedule::default();
|
|
|
|
world.init_resource::<SystemOrder>();
|
|
|
|
schedule.add_systems(
|
|
(
|
|
make_function_system(0),
|
|
make_function_system(1),
|
|
make_exclusive_system(2),
|
|
make_function_system(3),
|
|
)
|
|
.chain(),
|
|
);
|
|
|
|
schedule.run(&mut world);
|
|
assert_eq!(world.resource::<SystemOrder>().0, vec![0, 1, 2, 3]);
|
|
}
|
|
|
|
#[test]
|
|
fn add_systems_correct_order_nested() {
|
|
let mut world = World::new();
|
|
let mut schedule = Schedule::default();
|
|
|
|
world.init_resource::<SystemOrder>();
|
|
|
|
schedule.add_systems(
|
|
(
|
|
(make_function_system(0), make_function_system(1)).chain(),
|
|
make_function_system(2),
|
|
(make_function_system(3), make_function_system(4)).chain(),
|
|
(
|
|
make_function_system(5),
|
|
(make_function_system(6), make_function_system(7)),
|
|
),
|
|
(
|
|
(make_function_system(8), make_function_system(9)).chain(),
|
|
make_function_system(10),
|
|
),
|
|
)
|
|
.chain(),
|
|
);
|
|
|
|
schedule.run(&mut world);
|
|
let order = &world.resource::<SystemOrder>().0;
|
|
assert_eq!(
|
|
&order[0..5],
|
|
&[0, 1, 2, 3, 4],
|
|
"first five items should be exactly ordered"
|
|
);
|
|
let unordered = &order[5..8];
|
|
assert!(
|
|
unordered.contains(&5) && unordered.contains(&6) && unordered.contains(&7),
|
|
"unordered must be 5, 6, and 7 in any order"
|
|
);
|
|
let partially_ordered = &order[8..11];
|
|
assert!(
|
|
partially_ordered == [8, 9, 10] || partially_ordered == [10, 8, 9],
|
|
"partially_ordered must be [8, 9, 10] or [10, 8, 9]"
|
|
);
|
|
assert_eq!(order.len(), 11, "must have exactly 11 order entries");
|
|
}
|
|
}
|
|
|
|
mod conditions {
|
|
use crate::change_detection::DetectChanges;
|
|
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn system_with_condition() {
|
|
let mut world = World::default();
|
|
let mut schedule = Schedule::default();
|
|
|
|
world.init_resource::<RunConditionBool>();
|
|
world.init_resource::<SystemOrder>();
|
|
|
|
schedule.add_systems(
|
|
make_function_system(0).run_if(|condition: Res<RunConditionBool>| condition.0),
|
|
);
|
|
|
|
schedule.run(&mut world);
|
|
assert_eq!(world.resource::<SystemOrder>().0, vec![]);
|
|
|
|
world.resource_mut::<RunConditionBool>().0 = true;
|
|
schedule.run(&mut world);
|
|
assert_eq!(world.resource::<SystemOrder>().0, vec![0]);
|
|
}
|
|
|
|
#[test]
|
|
fn systems_with_distributive_condition() {
|
|
let mut world = World::default();
|
|
let mut schedule = Schedule::default();
|
|
|
|
world.insert_resource(RunConditionBool(true));
|
|
world.init_resource::<SystemOrder>();
|
|
|
|
fn change_condition(mut condition: ResMut<RunConditionBool>) {
|
|
condition.0 = false;
|
|
}
|
|
|
|
schedule.add_systems(
|
|
(
|
|
make_function_system(0),
|
|
change_condition,
|
|
make_function_system(1),
|
|
)
|
|
.chain()
|
|
.distributive_run_if(|condition: Res<RunConditionBool>| condition.0),
|
|
);
|
|
|
|
schedule.run(&mut world);
|
|
assert_eq!(world.resource::<SystemOrder>().0, vec![0]);
|
|
}
|
|
|
|
#[test]
|
|
fn run_exclusive_system_with_condition() {
|
|
let mut world = World::default();
|
|
let mut schedule = Schedule::default();
|
|
|
|
world.init_resource::<RunConditionBool>();
|
|
world.init_resource::<SystemOrder>();
|
|
|
|
schedule.add_systems(
|
|
make_exclusive_system(0).run_if(|condition: Res<RunConditionBool>| condition.0),
|
|
);
|
|
|
|
schedule.run(&mut world);
|
|
assert_eq!(world.resource::<SystemOrder>().0, vec![]);
|
|
|
|
world.resource_mut::<RunConditionBool>().0 = true;
|
|
schedule.run(&mut world);
|
|
assert_eq!(world.resource::<SystemOrder>().0, vec![0]);
|
|
}
|
|
|
|
#[test]
|
|
fn multiple_conditions_on_system() {
|
|
let mut world = World::default();
|
|
let mut schedule = Schedule::default();
|
|
|
|
world.init_resource::<Counter>();
|
|
|
|
schedule.add_systems((
|
|
counting_system.run_if(|| false).run_if(|| false),
|
|
counting_system.run_if(|| true).run_if(|| false),
|
|
counting_system.run_if(|| false).run_if(|| true),
|
|
counting_system.run_if(|| true).run_if(|| true),
|
|
));
|
|
|
|
schedule.run(&mut world);
|
|
assert_eq!(world.resource::<Counter>().0.load(Ordering::Relaxed), 1);
|
|
}
|
|
|
|
#[test]
|
|
fn multiple_conditions_on_system_sets() {
|
|
let mut world = World::default();
|
|
let mut schedule = Schedule::default();
|
|
|
|
world.init_resource::<Counter>();
|
|
|
|
schedule.configure_sets(TestSet::A.run_if(|| false).run_if(|| false));
|
|
schedule.add_systems(counting_system.in_set(TestSet::A));
|
|
schedule.configure_sets(TestSet::B.run_if(|| true).run_if(|| false));
|
|
schedule.add_systems(counting_system.in_set(TestSet::B));
|
|
schedule.configure_sets(TestSet::C.run_if(|| false).run_if(|| true));
|
|
schedule.add_systems(counting_system.in_set(TestSet::C));
|
|
schedule.configure_sets(TestSet::D.run_if(|| true).run_if(|| true));
|
|
schedule.add_systems(counting_system.in_set(TestSet::D));
|
|
|
|
schedule.run(&mut world);
|
|
assert_eq!(world.resource::<Counter>().0.load(Ordering::Relaxed), 1);
|
|
}
|
|
|
|
#[test]
|
|
fn systems_nested_in_system_sets() {
|
|
let mut world = World::default();
|
|
let mut schedule = Schedule::default();
|
|
|
|
world.init_resource::<Counter>();
|
|
|
|
schedule.configure_sets(TestSet::A.run_if(|| false));
|
|
schedule.add_systems(counting_system.in_set(TestSet::A).run_if(|| false));
|
|
schedule.configure_sets(TestSet::B.run_if(|| true));
|
|
schedule.add_systems(counting_system.in_set(TestSet::B).run_if(|| false));
|
|
schedule.configure_sets(TestSet::C.run_if(|| false));
|
|
schedule.add_systems(counting_system.in_set(TestSet::C).run_if(|| true));
|
|
schedule.configure_sets(TestSet::D.run_if(|| true));
|
|
schedule.add_systems(counting_system.in_set(TestSet::D).run_if(|| true));
|
|
|
|
schedule.run(&mut world);
|
|
assert_eq!(world.resource::<Counter>().0.load(Ordering::Relaxed), 1);
|
|
}
|
|
|
|
#[test]
|
|
fn system_conditions_and_change_detection() {
|
|
#[derive(Resource, Default)]
|
|
struct Bool2(pub bool);
|
|
|
|
let mut world = World::default();
|
|
world.init_resource::<Counter>();
|
|
world.init_resource::<RunConditionBool>();
|
|
world.init_resource::<Bool2>();
|
|
let mut schedule = Schedule::default();
|
|
|
|
schedule.add_systems(
|
|
counting_system
|
|
.run_if(|res1: Res<RunConditionBool>| res1.is_changed())
|
|
.run_if(|res2: Res<Bool2>| res2.is_changed()),
|
|
);
|
|
|
|
// both resource were just added.
|
|
schedule.run(&mut world);
|
|
assert_eq!(world.resource::<Counter>().0.load(Ordering::Relaxed), 1);
|
|
|
|
// nothing has changed
|
|
schedule.run(&mut world);
|
|
assert_eq!(world.resource::<Counter>().0.load(Ordering::Relaxed), 1);
|
|
|
|
// RunConditionBool has changed, but counting_system did not run
|
|
world.get_resource_mut::<RunConditionBool>().unwrap().0 = false;
|
|
schedule.run(&mut world);
|
|
assert_eq!(world.resource::<Counter>().0.load(Ordering::Relaxed), 1);
|
|
|
|
// internal state for the bool2 run criteria was updated in the
|
|
// previous run, so system still does not run
|
|
world.get_resource_mut::<Bool2>().unwrap().0 = false;
|
|
schedule.run(&mut world);
|
|
assert_eq!(world.resource::<Counter>().0.load(Ordering::Relaxed), 1);
|
|
|
|
// internal state for bool2 was updated, so system still does not run
|
|
world.get_resource_mut::<RunConditionBool>().unwrap().0 = false;
|
|
schedule.run(&mut world);
|
|
assert_eq!(world.resource::<Counter>().0.load(Ordering::Relaxed), 1);
|
|
|
|
// now check that it works correctly changing Bool2 first and then RunConditionBool
|
|
world.get_resource_mut::<Bool2>().unwrap().0 = false;
|
|
world.get_resource_mut::<RunConditionBool>().unwrap().0 = false;
|
|
schedule.run(&mut world);
|
|
assert_eq!(world.resource::<Counter>().0.load(Ordering::Relaxed), 2);
|
|
}
|
|
|
|
#[test]
|
|
fn system_set_conditions_and_change_detection() {
|
|
#[derive(Resource, Default)]
|
|
struct Bool2(pub bool);
|
|
|
|
let mut world = World::default();
|
|
world.init_resource::<Counter>();
|
|
world.init_resource::<RunConditionBool>();
|
|
world.init_resource::<Bool2>();
|
|
let mut schedule = Schedule::default();
|
|
|
|
schedule.configure_sets(
|
|
TestSet::A
|
|
.run_if(|res1: Res<RunConditionBool>| res1.is_changed())
|
|
.run_if(|res2: Res<Bool2>| res2.is_changed()),
|
|
);
|
|
|
|
schedule.add_systems(counting_system.in_set(TestSet::A));
|
|
|
|
// both resource were just added.
|
|
schedule.run(&mut world);
|
|
assert_eq!(world.resource::<Counter>().0.load(Ordering::Relaxed), 1);
|
|
|
|
// nothing has changed
|
|
schedule.run(&mut world);
|
|
assert_eq!(world.resource::<Counter>().0.load(Ordering::Relaxed), 1);
|
|
|
|
// RunConditionBool has changed, but counting_system did not run
|
|
world.get_resource_mut::<RunConditionBool>().unwrap().0 = false;
|
|
schedule.run(&mut world);
|
|
assert_eq!(world.resource::<Counter>().0.load(Ordering::Relaxed), 1);
|
|
|
|
// internal state for the bool2 run criteria was updated in the
|
|
// previous run, so system still does not run
|
|
world.get_resource_mut::<Bool2>().unwrap().0 = false;
|
|
schedule.run(&mut world);
|
|
assert_eq!(world.resource::<Counter>().0.load(Ordering::Relaxed), 1);
|
|
|
|
// internal state for bool2 was updated, so system still does not run
|
|
world.get_resource_mut::<RunConditionBool>().unwrap().0 = false;
|
|
schedule.run(&mut world);
|
|
assert_eq!(world.resource::<Counter>().0.load(Ordering::Relaxed), 1);
|
|
|
|
// the system only runs when both are changed on the same run
|
|
world.get_resource_mut::<Bool2>().unwrap().0 = false;
|
|
world.get_resource_mut::<RunConditionBool>().unwrap().0 = false;
|
|
schedule.run(&mut world);
|
|
assert_eq!(world.resource::<Counter>().0.load(Ordering::Relaxed), 2);
|
|
}
|
|
|
|
#[test]
|
|
fn mixed_conditions_and_change_detection() {
|
|
#[derive(Resource, Default)]
|
|
struct Bool2(pub bool);
|
|
|
|
let mut world = World::default();
|
|
world.init_resource::<Counter>();
|
|
world.init_resource::<RunConditionBool>();
|
|
world.init_resource::<Bool2>();
|
|
let mut schedule = Schedule::default();
|
|
|
|
schedule
|
|
.configure_sets(TestSet::A.run_if(|res1: Res<RunConditionBool>| res1.is_changed()));
|
|
|
|
schedule.add_systems(
|
|
counting_system
|
|
.run_if(|res2: Res<Bool2>| res2.is_changed())
|
|
.in_set(TestSet::A),
|
|
);
|
|
|
|
// both resource were just added.
|
|
schedule.run(&mut world);
|
|
assert_eq!(world.resource::<Counter>().0.load(Ordering::Relaxed), 1);
|
|
|
|
// nothing has changed
|
|
schedule.run(&mut world);
|
|
assert_eq!(world.resource::<Counter>().0.load(Ordering::Relaxed), 1);
|
|
|
|
// RunConditionBool has changed, but counting_system did not run
|
|
world.get_resource_mut::<RunConditionBool>().unwrap().0 = false;
|
|
schedule.run(&mut world);
|
|
assert_eq!(world.resource::<Counter>().0.load(Ordering::Relaxed), 1);
|
|
|
|
// we now only change bool2 and the system also should not run
|
|
world.get_resource_mut::<Bool2>().unwrap().0 = false;
|
|
schedule.run(&mut world);
|
|
assert_eq!(world.resource::<Counter>().0.load(Ordering::Relaxed), 1);
|
|
|
|
// internal state for the bool2 run criteria was updated in the
|
|
// previous run, so system still does not run
|
|
world.get_resource_mut::<RunConditionBool>().unwrap().0 = false;
|
|
schedule.run(&mut world);
|
|
assert_eq!(world.resource::<Counter>().0.load(Ordering::Relaxed), 1);
|
|
|
|
// the system only runs when both are changed on the same run
|
|
world.get_resource_mut::<Bool2>().unwrap().0 = false;
|
|
world.get_resource_mut::<RunConditionBool>().unwrap().0 = false;
|
|
schedule.run(&mut world);
|
|
assert_eq!(world.resource::<Counter>().0.load(Ordering::Relaxed), 2);
|
|
}
|
|
}
|
|
|
|
mod schedule_build_errors {
|
|
use super::*;
|
|
|
|
#[test]
|
|
#[should_panic]
|
|
fn dependency_loop() {
|
|
let mut schedule = Schedule::default();
|
|
schedule.configure_sets(TestSet::X.after(TestSet::X));
|
|
}
|
|
|
|
#[test]
|
|
fn dependency_cycle() {
|
|
let mut world = World::new();
|
|
let mut schedule = Schedule::default();
|
|
|
|
schedule.configure_sets(TestSet::A.after(TestSet::B));
|
|
schedule.configure_sets(TestSet::B.after(TestSet::A));
|
|
|
|
let result = schedule.initialize(&mut world);
|
|
assert!(matches!(
|
|
result,
|
|
Err(ScheduleBuildError::DependencyCycle(_))
|
|
));
|
|
|
|
fn foo() {}
|
|
fn bar() {}
|
|
|
|
let mut world = World::new();
|
|
let mut schedule = Schedule::default();
|
|
|
|
schedule.add_systems((foo.after(bar), bar.after(foo)));
|
|
let result = schedule.initialize(&mut world);
|
|
assert!(matches!(
|
|
result,
|
|
Err(ScheduleBuildError::DependencyCycle(_))
|
|
));
|
|
}
|
|
|
|
#[test]
|
|
#[should_panic]
|
|
fn hierarchy_loop() {
|
|
let mut schedule = Schedule::default();
|
|
schedule.configure_sets(TestSet::X.in_set(TestSet::X));
|
|
}
|
|
|
|
#[test]
|
|
fn hierarchy_cycle() {
|
|
let mut world = World::new();
|
|
let mut schedule = Schedule::default();
|
|
|
|
schedule.configure_sets(TestSet::A.in_set(TestSet::B));
|
|
schedule.configure_sets(TestSet::B.in_set(TestSet::A));
|
|
|
|
let result = schedule.initialize(&mut world);
|
|
assert!(matches!(result, Err(ScheduleBuildError::HierarchyCycle(_))));
|
|
}
|
|
|
|
#[test]
|
|
fn system_type_set_ambiguity() {
|
|
// Define some systems.
|
|
fn foo() {}
|
|
fn bar() {}
|
|
|
|
let mut world = World::new();
|
|
let mut schedule = Schedule::default();
|
|
|
|
// Schedule `bar` to run after `foo`.
|
|
schedule.add_systems((foo, bar.after(foo)));
|
|
|
|
// There's only one `foo`, so it's fine.
|
|
let result = schedule.initialize(&mut world);
|
|
assert!(result.is_ok());
|
|
|
|
// Schedule another `foo`.
|
|
schedule.add_systems(foo);
|
|
|
|
// When there are multiple instances of `foo`, dependencies on
|
|
// `foo` are no longer allowed. Too much ambiguity.
|
|
let result = schedule.initialize(&mut world);
|
|
assert!(matches!(
|
|
result,
|
|
Err(ScheduleBuildError::SystemTypeSetAmbiguity(_))
|
|
));
|
|
|
|
// same goes for `ambiguous_with`
|
|
let mut schedule = Schedule::default();
|
|
schedule.add_systems(foo);
|
|
schedule.add_systems(bar.ambiguous_with(foo));
|
|
let result = schedule.initialize(&mut world);
|
|
assert!(result.is_ok());
|
|
schedule.add_systems(foo);
|
|
let result = schedule.initialize(&mut world);
|
|
assert!(matches!(
|
|
result,
|
|
Err(ScheduleBuildError::SystemTypeSetAmbiguity(_))
|
|
));
|
|
}
|
|
|
|
#[test]
|
|
#[should_panic]
|
|
fn configure_system_type_set() {
|
|
fn foo() {}
|
|
let mut schedule = Schedule::default();
|
|
schedule.configure_sets(foo.into_system_set());
|
|
}
|
|
|
|
#[test]
|
|
fn hierarchy_redundancy() {
|
|
let mut world = World::new();
|
|
let mut schedule = Schedule::default();
|
|
|
|
schedule.set_build_settings(ScheduleBuildSettings {
|
|
hierarchy_detection: LogLevel::Error,
|
|
..Default::default()
|
|
});
|
|
|
|
// Add `A`.
|
|
schedule.configure_sets(TestSet::A);
|
|
|
|
// Add `B` as child of `A`.
|
|
schedule.configure_sets(TestSet::B.in_set(TestSet::A));
|
|
|
|
// Add `X` as child of both `A` and `B`.
|
|
schedule.configure_sets(TestSet::X.in_set(TestSet::A).in_set(TestSet::B));
|
|
|
|
// `X` cannot be the `A`'s child and grandchild at the same time.
|
|
let result = schedule.initialize(&mut world);
|
|
assert!(matches!(
|
|
result,
|
|
Err(ScheduleBuildError::HierarchyRedundancy(_))
|
|
));
|
|
}
|
|
|
|
#[test]
|
|
fn cross_dependency() {
|
|
let mut world = World::new();
|
|
let mut schedule = Schedule::default();
|
|
|
|
// Add `B` and give it both kinds of relationships with `A`.
|
|
schedule.configure_sets(TestSet::B.in_set(TestSet::A));
|
|
schedule.configure_sets(TestSet::B.after(TestSet::A));
|
|
let result = schedule.initialize(&mut world);
|
|
assert!(matches!(
|
|
result,
|
|
Err(ScheduleBuildError::CrossDependency(_, _))
|
|
));
|
|
}
|
|
|
|
#[test]
|
|
fn sets_have_order_but_intersect() {
|
|
let mut world = World::new();
|
|
let mut schedule = Schedule::default();
|
|
|
|
fn foo() {}
|
|
|
|
// Add `foo` to both `A` and `C`.
|
|
schedule.add_systems(foo.in_set(TestSet::A).in_set(TestSet::C));
|
|
|
|
// Order `A -> B -> C`.
|
|
schedule.configure_sets((
|
|
TestSet::A,
|
|
TestSet::B.after(TestSet::A),
|
|
TestSet::C.after(TestSet::B),
|
|
));
|
|
|
|
let result = schedule.initialize(&mut world);
|
|
// `foo` can't be in both `A` and `C` because they can't run at the same time.
|
|
assert!(matches!(
|
|
result,
|
|
Err(ScheduleBuildError::SetsHaveOrderButIntersect(_, _))
|
|
));
|
|
}
|
|
|
|
#[test]
|
|
fn ambiguity() {
|
|
#[derive(Resource)]
|
|
struct X;
|
|
|
|
fn res_ref(_x: Res<X>) {}
|
|
fn res_mut(_x: ResMut<X>) {}
|
|
|
|
let mut world = World::new();
|
|
let mut schedule = Schedule::default();
|
|
|
|
schedule.set_build_settings(ScheduleBuildSettings {
|
|
ambiguity_detection: LogLevel::Error,
|
|
..Default::default()
|
|
});
|
|
|
|
schedule.add_systems((res_ref, res_mut));
|
|
let result = schedule.initialize(&mut world);
|
|
assert!(matches!(result, Err(ScheduleBuildError::Ambiguity(_))));
|
|
}
|
|
}
|
|
|
|
mod system_ambiguity {
|
|
use std::collections::BTreeSet;
|
|
|
|
use super::*;
|
|
// Required to make the derive macro behave
|
|
use crate as bevy_ecs;
|
|
use crate::event::Events;
|
|
use crate::prelude::*;
|
|
|
|
#[derive(Resource)]
|
|
struct R;
|
|
|
|
#[derive(Component)]
|
|
struct A;
|
|
|
|
#[derive(Component)]
|
|
struct B;
|
|
|
|
// An event type
|
|
#[derive(Event)]
|
|
struct E;
|
|
|
|
fn empty_system() {}
|
|
fn res_system(_res: Res<R>) {}
|
|
fn resmut_system(_res: ResMut<R>) {}
|
|
fn nonsend_system(_ns: NonSend<R>) {}
|
|
fn nonsendmut_system(_ns: NonSendMut<R>) {}
|
|
fn read_component_system(_query: Query<&A>) {}
|
|
fn write_component_system(_query: Query<&mut A>) {}
|
|
fn with_filtered_component_system(_query: Query<&mut A, With<B>>) {}
|
|
fn without_filtered_component_system(_query: Query<&mut A, Without<B>>) {}
|
|
fn event_reader_system(_reader: EventReader<E>) {}
|
|
fn event_writer_system(_writer: EventWriter<E>) {}
|
|
fn event_resource_system(_events: ResMut<Events<E>>) {}
|
|
fn read_world_system(_world: &World) {}
|
|
fn write_world_system(_world: &mut World) {}
|
|
|
|
// Tests for conflict detection
|
|
|
|
#[test]
|
|
fn one_of_everything() {
|
|
let mut world = World::new();
|
|
world.insert_resource(R);
|
|
world.spawn(A);
|
|
world.init_resource::<Events<E>>();
|
|
|
|
let mut schedule = Schedule::default();
|
|
schedule
|
|
// nonsendmut system deliberately conflicts with resmut system
|
|
.add_systems((resmut_system, write_component_system, event_writer_system));
|
|
|
|
let _ = schedule.initialize(&mut world);
|
|
|
|
assert_eq!(schedule.graph().conflicting_systems().len(), 0);
|
|
}
|
|
|
|
#[test]
|
|
fn read_only() {
|
|
let mut world = World::new();
|
|
world.insert_resource(R);
|
|
world.spawn(A);
|
|
world.init_resource::<Events<E>>();
|
|
|
|
let mut schedule = Schedule::default();
|
|
schedule.add_systems((
|
|
empty_system,
|
|
empty_system,
|
|
res_system,
|
|
res_system,
|
|
nonsend_system,
|
|
nonsend_system,
|
|
read_component_system,
|
|
read_component_system,
|
|
event_reader_system,
|
|
event_reader_system,
|
|
read_world_system,
|
|
read_world_system,
|
|
));
|
|
|
|
let _ = schedule.initialize(&mut world);
|
|
|
|
assert_eq!(schedule.graph().conflicting_systems().len(), 0);
|
|
}
|
|
|
|
#[test]
|
|
fn read_world() {
|
|
let mut world = World::new();
|
|
world.insert_resource(R);
|
|
world.spawn(A);
|
|
world.init_resource::<Events<E>>();
|
|
|
|
let mut schedule = Schedule::default();
|
|
schedule.add_systems((
|
|
resmut_system,
|
|
write_component_system,
|
|
event_writer_system,
|
|
read_world_system,
|
|
));
|
|
|
|
let _ = schedule.initialize(&mut world);
|
|
|
|
assert_eq!(schedule.graph().conflicting_systems().len(), 3);
|
|
}
|
|
|
|
#[test]
|
|
fn resources() {
|
|
let mut world = World::new();
|
|
world.insert_resource(R);
|
|
|
|
let mut schedule = Schedule::default();
|
|
schedule.add_systems((resmut_system, res_system));
|
|
|
|
let _ = schedule.initialize(&mut world);
|
|
|
|
assert_eq!(schedule.graph().conflicting_systems().len(), 1);
|
|
}
|
|
|
|
#[test]
|
|
fn nonsend() {
|
|
let mut world = World::new();
|
|
world.insert_resource(R);
|
|
|
|
let mut schedule = Schedule::default();
|
|
schedule.add_systems((nonsendmut_system, nonsend_system));
|
|
|
|
let _ = schedule.initialize(&mut world);
|
|
|
|
assert_eq!(schedule.graph().conflicting_systems().len(), 1);
|
|
}
|
|
|
|
#[test]
|
|
fn components() {
|
|
let mut world = World::new();
|
|
world.spawn(A);
|
|
|
|
let mut schedule = Schedule::default();
|
|
schedule.add_systems((read_component_system, write_component_system));
|
|
|
|
let _ = schedule.initialize(&mut world);
|
|
|
|
assert_eq!(schedule.graph().conflicting_systems().len(), 1);
|
|
}
|
|
|
|
#[test]
|
|
#[ignore = "Known failing but fix is non-trivial: https://github.com/bevyengine/bevy/issues/4381"]
|
|
fn filtered_components() {
|
|
let mut world = World::new();
|
|
world.spawn(A);
|
|
|
|
let mut schedule = Schedule::default();
|
|
schedule.add_systems((
|
|
with_filtered_component_system,
|
|
without_filtered_component_system,
|
|
));
|
|
|
|
let _ = schedule.initialize(&mut world);
|
|
|
|
assert_eq!(schedule.graph().conflicting_systems().len(), 0);
|
|
}
|
|
|
|
#[test]
|
|
fn events() {
|
|
let mut world = World::new();
|
|
world.init_resource::<Events<E>>();
|
|
|
|
let mut schedule = Schedule::default();
|
|
schedule.add_systems((
|
|
// All of these systems clash
|
|
event_reader_system,
|
|
event_writer_system,
|
|
event_resource_system,
|
|
));
|
|
|
|
let _ = schedule.initialize(&mut world);
|
|
|
|
assert_eq!(schedule.graph().conflicting_systems().len(), 3);
|
|
}
|
|
|
|
#[test]
|
|
fn exclusive() {
|
|
let mut world = World::new();
|
|
world.insert_resource(R);
|
|
world.spawn(A);
|
|
world.init_resource::<Events<E>>();
|
|
|
|
let mut schedule = Schedule::default();
|
|
schedule.add_systems((
|
|
// All 3 of these conflict with each other
|
|
write_world_system,
|
|
write_world_system,
|
|
res_system,
|
|
));
|
|
|
|
let _ = schedule.initialize(&mut world);
|
|
|
|
assert_eq!(schedule.graph().conflicting_systems().len(), 3);
|
|
}
|
|
|
|
// Tests for silencing and resolving ambiguities
|
|
#[test]
|
|
fn before_and_after() {
|
|
let mut world = World::new();
|
|
world.init_resource::<Events<E>>();
|
|
|
|
let mut schedule = Schedule::default();
|
|
schedule.add_systems((
|
|
event_reader_system.before(event_writer_system),
|
|
event_writer_system,
|
|
event_resource_system.after(event_writer_system),
|
|
));
|
|
|
|
let _ = schedule.initialize(&mut world);
|
|
|
|
assert_eq!(schedule.graph().conflicting_systems().len(), 0);
|
|
}
|
|
|
|
#[test]
|
|
fn ignore_all_ambiguities() {
|
|
let mut world = World::new();
|
|
world.insert_resource(R);
|
|
|
|
let mut schedule = Schedule::default();
|
|
schedule.add_systems((
|
|
resmut_system.ambiguous_with_all(),
|
|
res_system,
|
|
nonsend_system,
|
|
));
|
|
|
|
let _ = schedule.initialize(&mut world);
|
|
|
|
assert_eq!(schedule.graph().conflicting_systems().len(), 0);
|
|
}
|
|
|
|
#[test]
|
|
fn ambiguous_with_label() {
|
|
let mut world = World::new();
|
|
world.insert_resource(R);
|
|
|
|
#[derive(SystemSet, Hash, PartialEq, Eq, Debug, Clone)]
|
|
struct IgnoreMe;
|
|
|
|
let mut schedule = Schedule::default();
|
|
schedule.add_systems((
|
|
resmut_system.ambiguous_with(IgnoreMe),
|
|
res_system.in_set(IgnoreMe),
|
|
nonsend_system.in_set(IgnoreMe),
|
|
));
|
|
|
|
let _ = schedule.initialize(&mut world);
|
|
|
|
assert_eq!(schedule.graph().conflicting_systems().len(), 0);
|
|
}
|
|
|
|
#[test]
|
|
fn ambiguous_with_system() {
|
|
let mut world = World::new();
|
|
|
|
let mut schedule = Schedule::default();
|
|
schedule.add_systems((
|
|
write_component_system.ambiguous_with(read_component_system),
|
|
read_component_system,
|
|
));
|
|
let _ = schedule.initialize(&mut world);
|
|
|
|
assert_eq!(schedule.graph().conflicting_systems().len(), 0);
|
|
}
|
|
|
|
#[derive(ScheduleLabel, Hash, PartialEq, Eq, Debug, Clone)]
|
|
struct TestSchedule;
|
|
|
|
// Tests that the correct ambiguities were reported in the correct order.
|
|
#[test]
|
|
fn correct_ambiguities() {
|
|
fn system_a(_res: ResMut<R>) {}
|
|
fn system_b(_res: ResMut<R>) {}
|
|
fn system_c(_res: ResMut<R>) {}
|
|
fn system_d(_res: ResMut<R>) {}
|
|
fn system_e(_res: ResMut<R>) {}
|
|
|
|
let mut world = World::new();
|
|
world.insert_resource(R);
|
|
|
|
let mut schedule = Schedule::new(TestSchedule);
|
|
schedule.add_systems((
|
|
system_a,
|
|
system_b,
|
|
system_c.ambiguous_with_all(),
|
|
system_d.ambiguous_with(system_b),
|
|
system_e.after(system_a),
|
|
));
|
|
|
|
schedule.graph_mut().initialize(&mut world);
|
|
let _ = schedule.graph_mut().build_schedule(
|
|
world.components(),
|
|
TestSchedule.intern(),
|
|
&BTreeSet::new(),
|
|
);
|
|
|
|
let ambiguities: Vec<_> = schedule
|
|
.graph()
|
|
.conflicts_to_string(schedule.graph().conflicting_systems(), world.components())
|
|
.collect();
|
|
|
|
let expected = &[
|
|
(
|
|
"system_d".to_string(),
|
|
"system_a".to_string(),
|
|
vec!["bevy_ecs::schedule::tests::system_ambiguity::R"],
|
|
),
|
|
(
|
|
"system_d".to_string(),
|
|
"system_e".to_string(),
|
|
vec!["bevy_ecs::schedule::tests::system_ambiguity::R"],
|
|
),
|
|
(
|
|
"system_b".to_string(),
|
|
"system_a".to_string(),
|
|
vec!["bevy_ecs::schedule::tests::system_ambiguity::R"],
|
|
),
|
|
(
|
|
"system_b".to_string(),
|
|
"system_e".to_string(),
|
|
vec!["bevy_ecs::schedule::tests::system_ambiguity::R"],
|
|
),
|
|
];
|
|
|
|
// ordering isn't stable so do this
|
|
for entry in expected {
|
|
assert!(ambiguities.contains(entry));
|
|
}
|
|
}
|
|
|
|
// Test that anonymous set names work properly
|
|
// Related issue https://github.com/bevyengine/bevy/issues/9641
|
|
#[test]
|
|
fn anonymous_set_name() {
|
|
let mut schedule = Schedule::new(TestSchedule);
|
|
schedule.add_systems((resmut_system, resmut_system).run_if(|| true));
|
|
|
|
let mut world = World::new();
|
|
schedule.graph_mut().initialize(&mut world);
|
|
let _ = schedule.graph_mut().build_schedule(
|
|
world.components(),
|
|
TestSchedule.intern(),
|
|
&BTreeSet::new(),
|
|
);
|
|
|
|
let ambiguities: Vec<_> = schedule
|
|
.graph()
|
|
.conflicts_to_string(schedule.graph().conflicting_systems(), world.components())
|
|
.collect();
|
|
|
|
assert_eq!(
|
|
ambiguities[0],
|
|
(
|
|
"resmut_system (in set (resmut_system, resmut_system))".to_string(),
|
|
"resmut_system (in set (resmut_system, resmut_system))".to_string(),
|
|
vec!["bevy_ecs::schedule::tests::system_ambiguity::R"],
|
|
)
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn ignore_component_resource_ambiguities() {
|
|
let mut world = World::new();
|
|
world.insert_resource(R);
|
|
world.allow_ambiguous_resource::<R>();
|
|
let mut schedule = Schedule::new(TestSchedule);
|
|
|
|
//check resource
|
|
schedule.add_systems((resmut_system, res_system));
|
|
schedule.initialize(&mut world).unwrap();
|
|
assert!(schedule.graph().conflicting_systems().is_empty());
|
|
|
|
// check components
|
|
world.allow_ambiguous_component::<A>();
|
|
schedule.add_systems((write_component_system, read_component_system));
|
|
schedule.initialize(&mut world).unwrap();
|
|
assert!(schedule.graph().conflicting_systems().is_empty());
|
|
}
|
|
}
|
|
|
|
#[cfg(feature = "bevy_debug_stepping")]
|
|
mod stepping {
|
|
use super::*;
|
|
use bevy_ecs::system::SystemState;
|
|
|
|
#[derive(ScheduleLabel, Clone, Debug, PartialEq, Eq, Hash)]
|
|
pub struct TestSchedule;
|
|
|
|
macro_rules! assert_executor_supports_stepping {
|
|
($executor:expr) => {
|
|
// create a test schedule
|
|
let mut schedule = Schedule::new(TestSchedule);
|
|
schedule
|
|
.set_executor_kind($executor)
|
|
.add_systems(|| panic!("Executor ignored Stepping"));
|
|
|
|
// Add our schedule to stepping & and enable stepping; this should
|
|
// prevent any systems in the schedule from running
|
|
let mut stepping = Stepping::default();
|
|
stepping.add_schedule(TestSchedule).enable();
|
|
|
|
// create a world, and add the stepping resource
|
|
let mut world = World::default();
|
|
world.insert_resource(stepping);
|
|
|
|
// start a new frame by running ihe begin_frame() system
|
|
let mut system_state: SystemState<Option<ResMut<Stepping>>> =
|
|
SystemState::new(&mut world);
|
|
let res = system_state.get_mut(&mut world);
|
|
Stepping::begin_frame(res);
|
|
|
|
// now run the schedule; this will panic if the executor doesn't
|
|
// handle stepping
|
|
schedule.run(&mut world);
|
|
};
|
|
}
|
|
|
|
/// verify the [`SimpleExecutor`] supports stepping
|
|
#[test]
|
|
fn simple_executor() {
|
|
assert_executor_supports_stepping!(ExecutorKind::Simple);
|
|
}
|
|
|
|
/// verify the [`SingleThreadedExecutor`] supports stepping
|
|
#[test]
|
|
fn single_threaded_executor() {
|
|
assert_executor_supports_stepping!(ExecutorKind::SingleThreaded);
|
|
}
|
|
|
|
/// verify the [`MultiThreadedExecutor`] supports stepping
|
|
#[test]
|
|
fn multi_threaded_executor() {
|
|
assert_executor_supports_stepping!(ExecutorKind::MultiThreaded);
|
|
}
|
|
}
|
|
}
|