2023-02-16 17:09:44 +00:00
|
|
|
use bevy_utils::all_tuples;
|
2023-01-17 01:39:17 +00:00
|
|
|
|
|
|
|
use crate::{
|
2023-02-06 18:44:40 +00:00
|
|
|
schedule::{
|
2023-01-17 01:39:17 +00:00
|
|
|
condition::{BoxedCondition, Condition},
|
|
|
|
graph_utils::{Ambiguity, Dependency, DependencyKind, GraphInfo},
|
|
|
|
set::{BoxedSystemSet, IntoSystemSet, SystemSet},
|
|
|
|
},
|
|
|
|
system::{BoxedSystem, IntoSystem, System},
|
|
|
|
};
|
|
|
|
|
2023-02-23 04:37:08 +00:00
|
|
|
fn new_condition<M>(condition: impl Condition<M>) -> BoxedCondition {
|
2023-01-17 01:39:17 +00:00
|
|
|
let condition_system = IntoSystem::into_system(condition);
|
|
|
|
assert!(
|
|
|
|
condition_system.is_send(),
|
2023-02-28 03:38:02 +00:00
|
|
|
"Condition `{}` accesses `NonSend` resources. This is not currently supported.",
|
2023-01-17 01:39:17 +00:00
|
|
|
condition_system.name()
|
|
|
|
);
|
|
|
|
|
|
|
|
Box::new(condition_system)
|
|
|
|
}
|
|
|
|
|
|
|
|
fn ambiguous_with(graph_info: &mut GraphInfo, set: BoxedSystemSet) {
|
|
|
|
match &mut graph_info.ambiguous_with {
|
|
|
|
detection @ Ambiguity::Check => {
|
|
|
|
*detection = Ambiguity::IgnoreWithSet(vec![set]);
|
|
|
|
}
|
|
|
|
Ambiguity::IgnoreWithSet(ambiguous_with) => {
|
|
|
|
ambiguous_with.push(set);
|
|
|
|
}
|
|
|
|
Ambiguity::IgnoreAll => (),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-03-18 01:45:34 +00:00
|
|
|
impl<Marker, F> IntoSystemConfigs<Marker> for F
|
2023-03-02 17:19:47 +00:00
|
|
|
where
|
2023-03-18 01:45:34 +00:00
|
|
|
F: IntoSystem<(), (), Marker>,
|
2023-03-02 17:19:47 +00:00
|
|
|
{
|
2023-03-18 01:45:34 +00:00
|
|
|
fn into_configs(self) -> SystemConfigs {
|
|
|
|
SystemConfigs::new_system(Box::new(IntoSystem::into_system(self)))
|
2023-03-02 17:19:47 +00:00
|
|
|
}
|
2023-01-17 01:39:17 +00:00
|
|
|
}
|
|
|
|
|
2023-03-18 01:45:34 +00:00
|
|
|
impl IntoSystemConfigs<()> for BoxedSystem<(), ()> {
|
|
|
|
fn into_configs(self) -> SystemConfigs {
|
|
|
|
SystemConfigs::new_system(self)
|
2023-01-17 01:39:17 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-09-05 17:15:27 +00:00
|
|
|
/// Stores configuration for a single generic node.
|
|
|
|
pub struct NodeConfig<T> {
|
|
|
|
pub(crate) node: T,
|
2023-03-18 01:45:34 +00:00
|
|
|
pub(crate) graph_info: GraphInfo,
|
|
|
|
pub(crate) conditions: Vec<BoxedCondition>,
|
2023-01-17 01:39:17 +00:00
|
|
|
}
|
|
|
|
|
2023-09-05 17:15:27 +00:00
|
|
|
/// Stores configuration for a single system.
|
|
|
|
pub type SystemConfig = NodeConfig<BoxedSystem>;
|
|
|
|
|
|
|
|
/// A collections of generic [`NodeConfig`]s.
|
|
|
|
pub enum NodeConfigs<T> {
|
|
|
|
/// Configuratin for a single node.
|
|
|
|
NodeConfig(NodeConfig<T>),
|
|
|
|
/// Configuration for a tuple of nested `Configs` instances.
|
2023-03-18 01:45:34 +00:00
|
|
|
Configs {
|
2023-06-10 23:23:48 +00:00
|
|
|
/// Configuration for each element of the tuple.
|
2023-09-05 17:15:27 +00:00
|
|
|
configs: Vec<NodeConfigs<T>>,
|
2023-06-10 23:23:48 +00:00
|
|
|
/// Run conditions applied to everything in the tuple.
|
`run_if` for `SystemConfigs` via anonymous system sets (#7676)
# Objective
- Fixes #7659
## Solution
The idea of anonymous system sets or "implicit hidden organizational
sets" was briefly mentioned by @cart here:
https://github.com/bevyengine/bevy/pull/7634#issuecomment-1428619449.
- `Schedule::add_systems` creates an implicit, anonymous system set of
all systems in `SystemConfigs`.
- All dependencies and conditions from the `SystemConfigs` are now
applied to the implicit system set, instead of being applied to each
individual system. This should not change the behavior, AFAIU, because
`before`, `after`, `run_if` and `ambiguous_with` are transitive
properties from a set to its members.
- The newly added `AnonymousSystemSet` stores the names of its members
to provide better error messages.
- The names are stored in a reference counted slice, allowing fast
clones of the `AnonymousSystemSet`.
- However, only the pointer of the slice is used for hash and equality
operations
- This ensures that two `AnonymousSystemSet` are not equal, even if they
have the same members / member names.
- So two identical `add_systems` calls will produce two different
`AnonymousSystemSet`s.
- Clones of the same `AnonymousSystemSet` will be equal.
## Drawbacks
If my assumptions are correct, the observed behavior should stay the
same. But the number of system sets in the `Schedule` will increase with
each `add_systems` call. If this has negative performance implications,
`add_systems` could be changed to only create the implicit system set if
necessary / when a run condition was added.
---------
Co-authored-by: Carter Anderson <mcanders1@gmail.com>
2023-03-30 21:39:10 +00:00
|
|
|
collective_conditions: Vec<BoxedCondition>,
|
2023-03-18 01:45:34 +00:00
|
|
|
/// If `true`, adds `before -> after` ordering constraints between the successive elements.
|
|
|
|
chained: bool,
|
|
|
|
},
|
|
|
|
}
|
2023-01-17 01:39:17 +00:00
|
|
|
|
2023-09-05 17:15:27 +00:00
|
|
|
/// A collection of [`SystemConfig`].
|
|
|
|
pub type SystemConfigs = NodeConfigs<BoxedSystem>;
|
|
|
|
|
2023-03-18 01:45:34 +00:00
|
|
|
impl SystemConfigs {
|
|
|
|
fn new_system(system: BoxedSystem) -> Self {
|
|
|
|
// include system in its default sets
|
|
|
|
let sets = system.default_system_sets().into_iter().collect();
|
2023-09-05 17:15:27 +00:00
|
|
|
Self::NodeConfig(SystemConfig {
|
|
|
|
node: system,
|
2023-03-18 01:45:34 +00:00
|
|
|
graph_info: GraphInfo {
|
|
|
|
sets,
|
|
|
|
..Default::default()
|
|
|
|
},
|
|
|
|
conditions: Vec::new(),
|
|
|
|
})
|
2023-01-17 01:39:17 +00:00
|
|
|
}
|
2023-09-05 17:15:27 +00:00
|
|
|
}
|
2023-01-17 01:39:17 +00:00
|
|
|
|
2023-09-05 17:15:27 +00:00
|
|
|
impl<T> NodeConfigs<T> {
|
2023-08-27 17:53:37 +00:00
|
|
|
/// Adds a new boxed system set to the systems.
|
|
|
|
pub fn in_set_dyn(&mut self, set: BoxedSystemSet) {
|
2023-03-18 01:45:34 +00:00
|
|
|
match self {
|
2023-09-05 17:15:27 +00:00
|
|
|
Self::NodeConfig(config) => {
|
2023-03-18 01:45:34 +00:00
|
|
|
config.graph_info.sets.push(set);
|
|
|
|
}
|
2023-09-05 17:15:27 +00:00
|
|
|
Self::Configs { configs, .. } => {
|
2023-03-18 01:45:34 +00:00
|
|
|
for config in configs {
|
2023-08-27 17:53:37 +00:00
|
|
|
config.in_set_dyn(set.dyn_clone());
|
2023-03-18 01:45:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
Base Sets (#7466)
# Objective
NOTE: This depends on #7267 and should not be merged until #7267 is merged. If you are reviewing this before that is merged, I highly recommend viewing the Base Sets commit instead of trying to find my changes amongst those from #7267.
"Default sets" as described by the [Stageless RFC](https://github.com/bevyengine/rfcs/pull/45) have some [unfortunate consequences](https://github.com/bevyengine/bevy/discussions/7365).
## Solution
This adds "base sets" as a variant of `SystemSet`:
A set is a "base set" if `SystemSet::is_base` returns `true`. Typically this will be opted-in to using the `SystemSet` derive:
```rust
#[derive(SystemSet, Clone, Hash, Debug, PartialEq, Eq)]
#[system_set(base)]
enum MyBaseSet {
A,
B,
}
```
**Base sets are exclusive**: a system can belong to at most one "base set". Adding a system to more than one will result in an error. When possible we fail immediately during system-config-time with a nice file + line number. For the more nested graph-ey cases, this will fail at the final schedule build.
**Base sets cannot belong to other sets**: this is where the word "base" comes from
Systems and Sets can only be added to base sets using `in_base_set`. Calling `in_set` with a base set will fail. As will calling `in_base_set` with a normal set.
```rust
app.add_system(foo.in_base_set(MyBaseSet::A))
// X must be a normal set ... base sets cannot be added to base sets
.configure_set(X.in_base_set(MyBaseSet::A))
```
Base sets can still be configured like normal sets:
```rust
app.add_system(MyBaseSet::B.after(MyBaseSet::Ap))
```
The primary use case for base sets is enabling a "default base set":
```rust
schedule.set_default_base_set(CoreSet::Update)
// this will belong to CoreSet::Update by default
.add_system(foo)
// this will override the default base set with PostUpdate
.add_system(bar.in_base_set(CoreSet::PostUpdate))
```
This allows us to build apis that work by default in the standard Bevy style. This is a rough analog to the "default stage" model, but it use the new "stageless sets" model instead, with all of the ordering flexibility (including exclusive systems) that it provides.
---
## Changelog
- Added "base sets" and ported CoreSet to use them.
## Migration Guide
TODO
2023-02-06 03:10:08 +00:00
|
|
|
}
|
|
|
|
|
2023-03-18 01:45:34 +00:00
|
|
|
fn before_inner(&mut self, set: BoxedSystemSet) {
|
|
|
|
match self {
|
2023-09-05 17:15:27 +00:00
|
|
|
Self::NodeConfig(config) => {
|
2023-03-18 01:45:34 +00:00
|
|
|
config
|
|
|
|
.graph_info
|
|
|
|
.dependencies
|
|
|
|
.push(Dependency::new(DependencyKind::Before, set));
|
|
|
|
}
|
2023-09-05 17:15:27 +00:00
|
|
|
Self::Configs { configs, .. } => {
|
2023-03-18 01:45:34 +00:00
|
|
|
for config in configs {
|
|
|
|
config.before_inner(set.dyn_clone());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
Migrate engine to Schedule v3 (#7267)
Huge thanks to @maniwani, @devil-ira, @hymm, @cart, @superdump and @jakobhellermann for the help with this PR.
# Objective
- Followup #6587.
- Minimal integration for the Stageless Scheduling RFC: https://github.com/bevyengine/rfcs/pull/45
## Solution
- [x] Remove old scheduling module
- [x] Migrate new methods to no longer use extension methods
- [x] Fix compiler errors
- [x] Fix benchmarks
- [x] Fix examples
- [x] Fix docs
- [x] Fix tests
## Changelog
### Added
- a large number of methods on `App` to work with schedules ergonomically
- the `CoreSchedule` enum
- `App::add_extract_system` via the `RenderingAppExtension` trait extension method
- the private `prepare_view_uniforms` system now has a public system set for scheduling purposes, called `ViewSet::PrepareUniforms`
### Removed
- stages, and all code that mentions stages
- states have been dramatically simplified, and no longer use a stack
- `RunCriteriaLabel`
- `AsSystemLabel` trait
- `on_hierarchy_reports_enabled` run criteria (now just uses an ad hoc resource checking run condition)
- systems in `RenderSet/Stage::Extract` no longer warn when they do not read data from the main world
- `RunCriteriaLabel`
- `transform_propagate_system_set`: this was a nonstandard pattern that didn't actually provide enough control. The systems are already `pub`: the docs have been updated to ensure that the third-party usage is clear.
### Changed
- `System::default_labels` is now `System::default_system_sets`.
- `App::add_default_labels` is now `App::add_default_sets`
- `CoreStage` and `StartupStage` enums are now `CoreSet` and `StartupSet`
- `App::add_system_set` was renamed to `App::add_systems`
- The `StartupSchedule` label is now defined as part of the `CoreSchedules` enum
- `.label(SystemLabel)` is now referred to as `.in_set(SystemSet)`
- `SystemLabel` trait was replaced by `SystemSet`
- `SystemTypeIdLabel<T>` was replaced by `SystemSetType<T>`
- The `ReportHierarchyIssue` resource now has a public constructor (`new`), and implements `PartialEq`
- Fixed time steps now use a schedule (`CoreSchedule::FixedTimeStep`) rather than a run criteria.
- Adding rendering extraction systems now panics rather than silently failing if no subapp with the `RenderApp` label is found.
- the `calculate_bounds` system, with the `CalculateBounds` label, is now in `CoreSet::Update`, rather than in `CoreSet::PostUpdate` before commands are applied.
- `SceneSpawnerSystem` now runs under `CoreSet::Update`, rather than `CoreStage::PreUpdate.at_end()`.
- `bevy_pbr::add_clusters` is no longer an exclusive system
- the top level `bevy_ecs::schedule` module was replaced with `bevy_ecs::scheduling`
- `tick_global_task_pools_on_main_thread` is no longer run as an exclusive system. Instead, it has been replaced by `tick_global_task_pools`, which uses a `NonSend` resource to force running on the main thread.
## Migration Guide
- Calls to `.label(MyLabel)` should be replaced with `.in_set(MySet)`
- Stages have been removed. Replace these with system sets, and then add command flushes using the `apply_system_buffers` exclusive system where needed.
- The `CoreStage`, `StartupStage, `RenderStage` and `AssetStage` enums have been replaced with `CoreSet`, `StartupSet, `RenderSet` and `AssetSet`. The same scheduling guarantees have been preserved.
- Systems are no longer added to `CoreSet::Update` by default. Add systems manually if this behavior is needed, although you should consider adding your game logic systems to `CoreSchedule::FixedTimestep` instead for more reliable framerate-independent behavior.
- Similarly, startup systems are no longer part of `StartupSet::Startup` by default. In most cases, this won't matter to you.
- For example, `add_system_to_stage(CoreStage::PostUpdate, my_system)` should be replaced with
- `add_system(my_system.in_set(CoreSet::PostUpdate)`
- When testing systems or otherwise running them in a headless fashion, simply construct and run a schedule using `Schedule::new()` and `World::run_schedule` rather than constructing stages
- Run criteria have been renamed to run conditions. These can now be combined with each other and with states.
- Looping run criteria and state stacks have been removed. Use an exclusive system that runs a schedule if you need this level of control over system control flow.
- For app-level control flow over which schedules get run when (such as for rollback networking), create your own schedule and insert it under the `CoreSchedule::Outer` label.
- Fixed timesteps are now evaluated in a schedule, rather than controlled via run criteria. The `run_fixed_timestep` system runs this schedule between `CoreSet::First` and `CoreSet::PreUpdate` by default.
- Command flush points introduced by `AssetStage` have been removed. If you were relying on these, add them back manually.
- Adding extract systems is now typically done directly on the main app. Make sure the `RenderingAppExtension` trait is in scope, then call `app.add_extract_system(my_system)`.
- the `calculate_bounds` system, with the `CalculateBounds` label, is now in `CoreSet::Update`, rather than in `CoreSet::PostUpdate` before commands are applied. You may need to order your movement systems to occur before this system in order to avoid system order ambiguities in culling behavior.
- the `RenderLabel` `AppLabel` was renamed to `RenderApp` for clarity
- `App::add_state` now takes 0 arguments: the starting state is set based on the `Default` impl.
- Instead of creating `SystemSet` containers for systems that run in stages, simply use `.on_enter::<State::Variant>()` or its `on_exit` or `on_update` siblings.
- `SystemLabel` derives should be replaced with `SystemSet`. You will also need to add the `Debug`, `PartialEq`, `Eq`, and `Hash` traits to satisfy the new trait bounds.
- `with_run_criteria` has been renamed to `run_if`. Run criteria have been renamed to run conditions for clarity, and should now simply return a bool.
- States have been dramatically simplified: there is no longer a "state stack". To queue a transition to the next state, call `NextState::set`
## TODO
- [x] remove dead methods on App and World
- [x] add `App::add_system_to_schedule` and `App::add_systems_to_schedule`
- [x] avoid adding the default system set at inappropriate times
- [x] remove any accidental cycles in the default plugins schedule
- [x] migrate benchmarks
- [x] expose explicit labels for the built-in command flush points
- [x] migrate engine code
- [x] remove all mentions of stages from the docs
- [x] verify docs for States
- [x] fix uses of exclusive systems that use .end / .at_start / .before_commands
- [x] migrate RenderStage and AssetStage
- [x] migrate examples
- [x] ensure that transform propagation is exported in a sufficiently public way (the systems are already pub)
- [x] ensure that on_enter schedules are run at least once before the main app
- [x] re-enable opt-in to execution order ambiguities
- [x] revert change to `update_bounds` to ensure it runs in `PostUpdate`
- [x] test all examples
- [x] unbreak directional lights
- [x] unbreak shadows (see 3d_scene, 3d_shape, lighting, transparaency_3d examples)
- [x] game menu example shows loading screen and menu simultaneously
- [x] display settings menu is a blank screen
- [x] `without_winit` example panics
- [x] ensure all tests pass
- [x] SubApp doc test fails
- [x] runs_spawn_local tasks fails
- [x] [Fix panic_when_hierachy_cycle test hanging](https://github.com/alice-i-cecile/bevy/pull/120)
## Points of Difficulty and Controversy
**Reviewers, please give feedback on these and look closely**
1. Default sets, from the RFC, have been removed. These added a tremendous amount of implicit complexity and result in hard to debug scheduling errors. They're going to be tackled in the form of "base sets" by @cart in a followup.
2. The outer schedule controls which schedule is run when `App::update` is called.
3. I implemented `Label for `Box<dyn Label>` for our label types. This enables us to store schedule labels in concrete form, and then later run them. I ran into the same set of problems when working with one-shot systems. We've previously investigated this pattern in depth, and it does not appear to lead to extra indirection with nested boxes.
4. `SubApp::update` simply runs the default schedule once. This sucks, but this whole API is incomplete and this was the minimal changeset.
5. `time_system` and `tick_global_task_pools_on_main_thread` no longer use exclusive systems to attempt to force scheduling order
6. Implemetnation strategy for fixed timesteps
7. `AssetStage` was migrated to `AssetSet` without reintroducing command flush points. These did not appear to be used, and it's nice to remove these bottlenecks.
8. Migration of `bevy_render/lib.rs` and pipelined rendering. The logic here is unusually tricky, as we have complex scheduling requirements.
## Future Work (ideally before 0.10)
- Rename schedule_v3 module to schedule or scheduling
- Add a derive macro to states, and likely a `EnumIter` trait of some form
- Figure out what exactly to do with the "systems added should basically work by default" problem
- Improve ergonomics for working with fixed timesteps and states
- Polish FixedTime API to match Time
- Rebase and merge #7415
- Resolve all internal ambiguities (blocked on better tools, especially #7442)
- Add "base sets" to replace the removed default sets.
2023-02-06 02:04:50 +00:00
|
|
|
}
|
|
|
|
|
2023-03-18 01:45:34 +00:00
|
|
|
fn after_inner(&mut self, set: BoxedSystemSet) {
|
|
|
|
match self {
|
2023-09-05 17:15:27 +00:00
|
|
|
Self::NodeConfig(config) => {
|
2023-03-18 01:45:34 +00:00
|
|
|
config
|
|
|
|
.graph_info
|
|
|
|
.dependencies
|
|
|
|
.push(Dependency::new(DependencyKind::After, set));
|
|
|
|
}
|
2023-09-05 17:15:27 +00:00
|
|
|
Self::Configs { configs, .. } => {
|
2023-03-18 01:45:34 +00:00
|
|
|
for config in configs {
|
|
|
|
config.after_inner(set.dyn_clone());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2023-01-17 01:39:17 +00:00
|
|
|
}
|
|
|
|
|
2023-03-18 01:45:34 +00:00
|
|
|
fn distributive_run_if_inner<M>(&mut self, condition: impl Condition<M> + Clone) {
|
|
|
|
match self {
|
2023-09-05 17:15:27 +00:00
|
|
|
Self::NodeConfig(config) => {
|
2023-03-18 01:45:34 +00:00
|
|
|
config.conditions.push(new_condition(condition));
|
|
|
|
}
|
2023-09-05 17:15:27 +00:00
|
|
|
Self::Configs { configs, .. } => {
|
2023-03-18 01:45:34 +00:00
|
|
|
for config in configs {
|
|
|
|
config.distributive_run_if_inner(condition.clone());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2023-01-17 01:39:17 +00:00
|
|
|
}
|
|
|
|
|
2023-03-18 01:45:34 +00:00
|
|
|
fn ambiguous_with_inner(&mut self, set: BoxedSystemSet) {
|
|
|
|
match self {
|
2023-09-05 17:15:27 +00:00
|
|
|
Self::NodeConfig(config) => {
|
2023-03-18 01:45:34 +00:00
|
|
|
ambiguous_with(&mut config.graph_info, set);
|
|
|
|
}
|
2023-09-05 17:15:27 +00:00
|
|
|
Self::Configs { configs, .. } => {
|
2023-03-18 01:45:34 +00:00
|
|
|
for config in configs {
|
|
|
|
config.ambiguous_with_inner(set.dyn_clone());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2023-01-17 01:39:17 +00:00
|
|
|
}
|
|
|
|
|
2023-03-18 01:45:34 +00:00
|
|
|
fn ambiguous_with_all_inner(&mut self) {
|
|
|
|
match self {
|
2023-09-05 17:15:27 +00:00
|
|
|
Self::NodeConfig(config) => {
|
2023-03-18 01:45:34 +00:00
|
|
|
config.graph_info.ambiguous_with = Ambiguity::IgnoreAll;
|
|
|
|
}
|
2023-09-05 17:15:27 +00:00
|
|
|
Self::Configs { configs, .. } => {
|
2023-03-18 01:45:34 +00:00
|
|
|
for config in configs {
|
|
|
|
config.ambiguous_with_all_inner();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2023-01-17 01:39:17 +00:00
|
|
|
}
|
|
|
|
|
2023-08-27 17:53:37 +00:00
|
|
|
/// Adds a new boxed run condition to the systems.
|
|
|
|
///
|
|
|
|
/// This is useful if you have a run condition whose concrete type is unknown.
|
|
|
|
/// Prefer `run_if` for run conditions whose type is known at compile time.
|
|
|
|
pub fn run_if_dyn(&mut self, condition: BoxedCondition) {
|
2023-03-18 01:45:34 +00:00
|
|
|
match self {
|
2023-09-05 17:15:27 +00:00
|
|
|
Self::NodeConfig(config) => {
|
2023-03-18 01:45:34 +00:00
|
|
|
config.conditions.push(condition);
|
|
|
|
}
|
2023-09-05 17:15:27 +00:00
|
|
|
Self::Configs {
|
`run_if` for `SystemConfigs` via anonymous system sets (#7676)
# Objective
- Fixes #7659
## Solution
The idea of anonymous system sets or "implicit hidden organizational
sets" was briefly mentioned by @cart here:
https://github.com/bevyengine/bevy/pull/7634#issuecomment-1428619449.
- `Schedule::add_systems` creates an implicit, anonymous system set of
all systems in `SystemConfigs`.
- All dependencies and conditions from the `SystemConfigs` are now
applied to the implicit system set, instead of being applied to each
individual system. This should not change the behavior, AFAIU, because
`before`, `after`, `run_if` and `ambiguous_with` are transitive
properties from a set to its members.
- The newly added `AnonymousSystemSet` stores the names of its members
to provide better error messages.
- The names are stored in a reference counted slice, allowing fast
clones of the `AnonymousSystemSet`.
- However, only the pointer of the slice is used for hash and equality
operations
- This ensures that two `AnonymousSystemSet` are not equal, even if they
have the same members / member names.
- So two identical `add_systems` calls will produce two different
`AnonymousSystemSet`s.
- Clones of the same `AnonymousSystemSet` will be equal.
## Drawbacks
If my assumptions are correct, the observed behavior should stay the
same. But the number of system sets in the `Schedule` will increase with
each `add_systems` call. If this has negative performance implications,
`add_systems` could be changed to only create the implicit system set if
necessary / when a run condition was added.
---------
Co-authored-by: Carter Anderson <mcanders1@gmail.com>
2023-03-30 21:39:10 +00:00
|
|
|
collective_conditions,
|
|
|
|
..
|
|
|
|
} => {
|
|
|
|
collective_conditions.push(condition);
|
2023-03-18 01:45:34 +00:00
|
|
|
}
|
|
|
|
}
|
2023-01-17 01:39:17 +00:00
|
|
|
}
|
2023-09-05 17:15:27 +00:00
|
|
|
|
|
|
|
fn chain_inner(mut self) -> Self {
|
|
|
|
match &mut self {
|
|
|
|
Self::NodeConfig(_) => { /* no op */ }
|
|
|
|
Self::Configs { chained, .. } => {
|
|
|
|
*chained = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
self
|
|
|
|
}
|
2023-01-17 01:39:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Types that can convert into a [`SystemConfigs`].
|
2023-02-23 04:37:08 +00:00
|
|
|
pub trait IntoSystemConfigs<Marker>
|
2023-01-17 01:39:17 +00:00
|
|
|
where
|
|
|
|
Self: Sized,
|
|
|
|
{
|
|
|
|
/// Convert into a [`SystemConfigs`].
|
|
|
|
#[doc(hidden)]
|
|
|
|
fn into_configs(self) -> SystemConfigs;
|
|
|
|
|
|
|
|
/// Add these systems to the provided `set`.
|
Base Sets (#7466)
# Objective
NOTE: This depends on #7267 and should not be merged until #7267 is merged. If you are reviewing this before that is merged, I highly recommend viewing the Base Sets commit instead of trying to find my changes amongst those from #7267.
"Default sets" as described by the [Stageless RFC](https://github.com/bevyengine/rfcs/pull/45) have some [unfortunate consequences](https://github.com/bevyengine/bevy/discussions/7365).
## Solution
This adds "base sets" as a variant of `SystemSet`:
A set is a "base set" if `SystemSet::is_base` returns `true`. Typically this will be opted-in to using the `SystemSet` derive:
```rust
#[derive(SystemSet, Clone, Hash, Debug, PartialEq, Eq)]
#[system_set(base)]
enum MyBaseSet {
A,
B,
}
```
**Base sets are exclusive**: a system can belong to at most one "base set". Adding a system to more than one will result in an error. When possible we fail immediately during system-config-time with a nice file + line number. For the more nested graph-ey cases, this will fail at the final schedule build.
**Base sets cannot belong to other sets**: this is where the word "base" comes from
Systems and Sets can only be added to base sets using `in_base_set`. Calling `in_set` with a base set will fail. As will calling `in_base_set` with a normal set.
```rust
app.add_system(foo.in_base_set(MyBaseSet::A))
// X must be a normal set ... base sets cannot be added to base sets
.configure_set(X.in_base_set(MyBaseSet::A))
```
Base sets can still be configured like normal sets:
```rust
app.add_system(MyBaseSet::B.after(MyBaseSet::Ap))
```
The primary use case for base sets is enabling a "default base set":
```rust
schedule.set_default_base_set(CoreSet::Update)
// this will belong to CoreSet::Update by default
.add_system(foo)
// this will override the default base set with PostUpdate
.add_system(bar.in_base_set(CoreSet::PostUpdate))
```
This allows us to build apis that work by default in the standard Bevy style. This is a rough analog to the "default stage" model, but it use the new "stageless sets" model instead, with all of the ordering flexibility (including exclusive systems) that it provides.
---
## Changelog
- Added "base sets" and ported CoreSet to use them.
## Migration Guide
TODO
2023-02-06 03:10:08 +00:00
|
|
|
#[track_caller]
|
2023-03-18 01:45:34 +00:00
|
|
|
fn in_set(self, set: impl SystemSet) -> SystemConfigs {
|
2023-01-17 01:39:17 +00:00
|
|
|
self.into_configs().in_set(set)
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Run before all systems in `set`.
|
|
|
|
fn before<M>(self, set: impl IntoSystemSet<M>) -> SystemConfigs {
|
|
|
|
self.into_configs().before(set)
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Run after all systems in `set`.
|
|
|
|
fn after<M>(self, set: impl IntoSystemSet<M>) -> SystemConfigs {
|
|
|
|
self.into_configs().after(set)
|
|
|
|
}
|
|
|
|
|
2023-02-18 21:33:09 +00:00
|
|
|
/// Add a run condition to each contained system.
|
|
|
|
///
|
2023-03-18 01:45:34 +00:00
|
|
|
/// Each system will receive its own clone of the [`Condition`] and will only run
|
|
|
|
/// if the `Condition` is true.
|
2023-02-18 21:33:09 +00:00
|
|
|
///
|
|
|
|
/// Each individual condition will be evaluated at most once (per schedule run),
|
|
|
|
/// right before the corresponding system prepares to run.
|
|
|
|
///
|
2023-03-18 01:45:34 +00:00
|
|
|
/// This is equivalent to calling [`run_if`](IntoSystemConfigs::run_if) on each individual
|
2023-02-18 21:33:09 +00:00
|
|
|
/// system, as shown below:
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// # use bevy_ecs::prelude::*;
|
2023-08-28 20:44:48 +00:00
|
|
|
/// # let mut schedule = Schedule::default();
|
2023-02-18 21:33:09 +00:00
|
|
|
/// # fn a() {}
|
|
|
|
/// # fn b() {}
|
|
|
|
/// # fn condition() -> bool { true }
|
`run_if` for `SystemConfigs` via anonymous system sets (#7676)
# Objective
- Fixes #7659
## Solution
The idea of anonymous system sets or "implicit hidden organizational
sets" was briefly mentioned by @cart here:
https://github.com/bevyengine/bevy/pull/7634#issuecomment-1428619449.
- `Schedule::add_systems` creates an implicit, anonymous system set of
all systems in `SystemConfigs`.
- All dependencies and conditions from the `SystemConfigs` are now
applied to the implicit system set, instead of being applied to each
individual system. This should not change the behavior, AFAIU, because
`before`, `after`, `run_if` and `ambiguous_with` are transitive
properties from a set to its members.
- The newly added `AnonymousSystemSet` stores the names of its members
to provide better error messages.
- The names are stored in a reference counted slice, allowing fast
clones of the `AnonymousSystemSet`.
- However, only the pointer of the slice is used for hash and equality
operations
- This ensures that two `AnonymousSystemSet` are not equal, even if they
have the same members / member names.
- So two identical `add_systems` calls will produce two different
`AnonymousSystemSet`s.
- Clones of the same `AnonymousSystemSet` will be equal.
## Drawbacks
If my assumptions are correct, the observed behavior should stay the
same. But the number of system sets in the `Schedule` will increase with
each `add_systems` call. If this has negative performance implications,
`add_systems` could be changed to only create the implicit system set if
necessary / when a run condition was added.
---------
Co-authored-by: Carter Anderson <mcanders1@gmail.com>
2023-03-30 21:39:10 +00:00
|
|
|
/// schedule.add_systems((a, b).distributive_run_if(condition));
|
|
|
|
/// schedule.add_systems((a.run_if(condition), b.run_if(condition)));
|
2023-02-18 21:33:09 +00:00
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// # Note
|
|
|
|
///
|
|
|
|
/// Because the conditions are evaluated separately for each system, there is no guarantee
|
|
|
|
/// that all evaluations in a single schedule run will yield the same result. If another
|
|
|
|
/// system is run inbetween two evaluations it could cause the result of the condition to change.
|
|
|
|
///
|
2023-09-05 17:15:27 +00:00
|
|
|
/// Use [`run_if`](IntoSystemSetConfigs::run_if) on a [`SystemSet`] if you want to make sure
|
2023-02-18 21:33:09 +00:00
|
|
|
/// that either all or none of the systems are run, or you don't want to evaluate the run
|
|
|
|
/// condition for each contained system separately.
|
2023-02-23 04:37:08 +00:00
|
|
|
fn distributive_run_if<M>(self, condition: impl Condition<M> + Clone) -> SystemConfigs {
|
2023-02-18 21:33:09 +00:00
|
|
|
self.into_configs().distributive_run_if(condition)
|
|
|
|
}
|
|
|
|
|
2023-03-18 01:45:34 +00:00
|
|
|
/// Run the systems only if the [`Condition`] is `true`.
|
|
|
|
///
|
|
|
|
/// The `Condition` will be evaluated at most once (per schedule run),
|
|
|
|
/// the first time a system in this set prepares to run.
|
`run_if` for `SystemConfigs` via anonymous system sets (#7676)
# Objective
- Fixes #7659
## Solution
The idea of anonymous system sets or "implicit hidden organizational
sets" was briefly mentioned by @cart here:
https://github.com/bevyengine/bevy/pull/7634#issuecomment-1428619449.
- `Schedule::add_systems` creates an implicit, anonymous system set of
all systems in `SystemConfigs`.
- All dependencies and conditions from the `SystemConfigs` are now
applied to the implicit system set, instead of being applied to each
individual system. This should not change the behavior, AFAIU, because
`before`, `after`, `run_if` and `ambiguous_with` are transitive
properties from a set to its members.
- The newly added `AnonymousSystemSet` stores the names of its members
to provide better error messages.
- The names are stored in a reference counted slice, allowing fast
clones of the `AnonymousSystemSet`.
- However, only the pointer of the slice is used for hash and equality
operations
- This ensures that two `AnonymousSystemSet` are not equal, even if they
have the same members / member names.
- So two identical `add_systems` calls will produce two different
`AnonymousSystemSet`s.
- Clones of the same `AnonymousSystemSet` will be equal.
## Drawbacks
If my assumptions are correct, the observed behavior should stay the
same. But the number of system sets in the `Schedule` will increase with
each `add_systems` call. If this has negative performance implications,
`add_systems` could be changed to only create the implicit system set if
necessary / when a run condition was added.
---------
Co-authored-by: Carter Anderson <mcanders1@gmail.com>
2023-03-30 21:39:10 +00:00
|
|
|
///
|
|
|
|
/// If this set contains more than one system, calling `run_if` is equivalent to adding each
|
|
|
|
/// system to a common set and configuring the run condition on that set, as shown below:
|
|
|
|
///
|
|
|
|
/// # Examples
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// # use bevy_ecs::prelude::*;
|
2023-08-28 20:44:48 +00:00
|
|
|
/// # let mut schedule = Schedule::default();
|
`run_if` for `SystemConfigs` via anonymous system sets (#7676)
# Objective
- Fixes #7659
## Solution
The idea of anonymous system sets or "implicit hidden organizational
sets" was briefly mentioned by @cart here:
https://github.com/bevyengine/bevy/pull/7634#issuecomment-1428619449.
- `Schedule::add_systems` creates an implicit, anonymous system set of
all systems in `SystemConfigs`.
- All dependencies and conditions from the `SystemConfigs` are now
applied to the implicit system set, instead of being applied to each
individual system. This should not change the behavior, AFAIU, because
`before`, `after`, `run_if` and `ambiguous_with` are transitive
properties from a set to its members.
- The newly added `AnonymousSystemSet` stores the names of its members
to provide better error messages.
- The names are stored in a reference counted slice, allowing fast
clones of the `AnonymousSystemSet`.
- However, only the pointer of the slice is used for hash and equality
operations
- This ensures that two `AnonymousSystemSet` are not equal, even if they
have the same members / member names.
- So two identical `add_systems` calls will produce two different
`AnonymousSystemSet`s.
- Clones of the same `AnonymousSystemSet` will be equal.
## Drawbacks
If my assumptions are correct, the observed behavior should stay the
same. But the number of system sets in the `Schedule` will increase with
each `add_systems` call. If this has negative performance implications,
`add_systems` could be changed to only create the implicit system set if
necessary / when a run condition was added.
---------
Co-authored-by: Carter Anderson <mcanders1@gmail.com>
2023-03-30 21:39:10 +00:00
|
|
|
/// # fn a() {}
|
|
|
|
/// # fn b() {}
|
|
|
|
/// # fn condition() -> bool { true }
|
|
|
|
/// # #[derive(SystemSet, Debug, Eq, PartialEq, Hash, Clone, Copy)]
|
|
|
|
/// # struct C;
|
|
|
|
/// schedule.add_systems((a, b).run_if(condition));
|
2023-09-05 17:15:27 +00:00
|
|
|
/// schedule.add_systems((a, b).in_set(C)).configure_sets(C.run_if(condition));
|
`run_if` for `SystemConfigs` via anonymous system sets (#7676)
# Objective
- Fixes #7659
## Solution
The idea of anonymous system sets or "implicit hidden organizational
sets" was briefly mentioned by @cart here:
https://github.com/bevyengine/bevy/pull/7634#issuecomment-1428619449.
- `Schedule::add_systems` creates an implicit, anonymous system set of
all systems in `SystemConfigs`.
- All dependencies and conditions from the `SystemConfigs` are now
applied to the implicit system set, instead of being applied to each
individual system. This should not change the behavior, AFAIU, because
`before`, `after`, `run_if` and `ambiguous_with` are transitive
properties from a set to its members.
- The newly added `AnonymousSystemSet` stores the names of its members
to provide better error messages.
- The names are stored in a reference counted slice, allowing fast
clones of the `AnonymousSystemSet`.
- However, only the pointer of the slice is used for hash and equality
operations
- This ensures that two `AnonymousSystemSet` are not equal, even if they
have the same members / member names.
- So two identical `add_systems` calls will produce two different
`AnonymousSystemSet`s.
- Clones of the same `AnonymousSystemSet` will be equal.
## Drawbacks
If my assumptions are correct, the observed behavior should stay the
same. But the number of system sets in the `Schedule` will increase with
each `add_systems` call. If this has negative performance implications,
`add_systems` could be changed to only create the implicit system set if
necessary / when a run condition was added.
---------
Co-authored-by: Carter Anderson <mcanders1@gmail.com>
2023-03-30 21:39:10 +00:00
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// # Note
|
|
|
|
///
|
|
|
|
/// Because the condition will only be evaluated once, there is no guarantee that the condition
|
|
|
|
/// is upheld after the first system has run. You need to make sure that no other systems that
|
|
|
|
/// could invalidate the condition are scheduled inbetween the first and last run system.
|
|
|
|
///
|
|
|
|
/// Use [`distributive_run_if`](IntoSystemConfigs::distributive_run_if) if you want the
|
|
|
|
/// condition to be evaluated for each individual system, right before one is run.
|
2023-03-18 01:45:34 +00:00
|
|
|
fn run_if<M>(self, condition: impl Condition<M>) -> SystemConfigs {
|
|
|
|
self.into_configs().run_if(condition)
|
|
|
|
}
|
|
|
|
|
2023-01-17 01:39:17 +00:00
|
|
|
/// Suppress warnings and errors that would result from these systems having ambiguities
|
|
|
|
/// (conflicting access but indeterminate order) with systems in `set`.
|
|
|
|
fn ambiguous_with<M>(self, set: impl IntoSystemSet<M>) -> SystemConfigs {
|
|
|
|
self.into_configs().ambiguous_with(set)
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Suppress warnings and errors that would result from these systems having ambiguities
|
|
|
|
/// (conflicting access but indeterminate order) with any other system.
|
|
|
|
fn ambiguous_with_all(self) -> SystemConfigs {
|
|
|
|
self.into_configs().ambiguous_with_all()
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Treat this collection as a sequence of systems.
|
|
|
|
///
|
|
|
|
/// Ordering constraints will be applied between the successive elements.
|
|
|
|
fn chain(self) -> SystemConfigs {
|
|
|
|
self.into_configs().chain()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl IntoSystemConfigs<()> for SystemConfigs {
|
|
|
|
fn into_configs(self) -> Self {
|
|
|
|
self
|
|
|
|
}
|
|
|
|
|
Base Sets (#7466)
# Objective
NOTE: This depends on #7267 and should not be merged until #7267 is merged. If you are reviewing this before that is merged, I highly recommend viewing the Base Sets commit instead of trying to find my changes amongst those from #7267.
"Default sets" as described by the [Stageless RFC](https://github.com/bevyengine/rfcs/pull/45) have some [unfortunate consequences](https://github.com/bevyengine/bevy/discussions/7365).
## Solution
This adds "base sets" as a variant of `SystemSet`:
A set is a "base set" if `SystemSet::is_base` returns `true`. Typically this will be opted-in to using the `SystemSet` derive:
```rust
#[derive(SystemSet, Clone, Hash, Debug, PartialEq, Eq)]
#[system_set(base)]
enum MyBaseSet {
A,
B,
}
```
**Base sets are exclusive**: a system can belong to at most one "base set". Adding a system to more than one will result in an error. When possible we fail immediately during system-config-time with a nice file + line number. For the more nested graph-ey cases, this will fail at the final schedule build.
**Base sets cannot belong to other sets**: this is where the word "base" comes from
Systems and Sets can only be added to base sets using `in_base_set`. Calling `in_set` with a base set will fail. As will calling `in_base_set` with a normal set.
```rust
app.add_system(foo.in_base_set(MyBaseSet::A))
// X must be a normal set ... base sets cannot be added to base sets
.configure_set(X.in_base_set(MyBaseSet::A))
```
Base sets can still be configured like normal sets:
```rust
app.add_system(MyBaseSet::B.after(MyBaseSet::Ap))
```
The primary use case for base sets is enabling a "default base set":
```rust
schedule.set_default_base_set(CoreSet::Update)
// this will belong to CoreSet::Update by default
.add_system(foo)
// this will override the default base set with PostUpdate
.add_system(bar.in_base_set(CoreSet::PostUpdate))
```
This allows us to build apis that work by default in the standard Bevy style. This is a rough analog to the "default stage" model, but it use the new "stageless sets" model instead, with all of the ordering flexibility (including exclusive systems) that it provides.
---
## Changelog
- Added "base sets" and ported CoreSet to use them.
## Migration Guide
TODO
2023-02-06 03:10:08 +00:00
|
|
|
#[track_caller]
|
2023-01-17 01:39:17 +00:00
|
|
|
fn in_set(mut self, set: impl SystemSet) -> Self {
|
|
|
|
assert!(
|
2023-02-16 22:25:48 +00:00
|
|
|
set.system_type().is_none(),
|
2023-01-17 01:39:17 +00:00
|
|
|
"adding arbitrary systems to a system type set is not allowed"
|
|
|
|
);
|
|
|
|
|
2023-08-27 17:53:37 +00:00
|
|
|
self.in_set_dyn(set.dyn_clone());
|
Base Sets (#7466)
# Objective
NOTE: This depends on #7267 and should not be merged until #7267 is merged. If you are reviewing this before that is merged, I highly recommend viewing the Base Sets commit instead of trying to find my changes amongst those from #7267.
"Default sets" as described by the [Stageless RFC](https://github.com/bevyengine/rfcs/pull/45) have some [unfortunate consequences](https://github.com/bevyengine/bevy/discussions/7365).
## Solution
This adds "base sets" as a variant of `SystemSet`:
A set is a "base set" if `SystemSet::is_base` returns `true`. Typically this will be opted-in to using the `SystemSet` derive:
```rust
#[derive(SystemSet, Clone, Hash, Debug, PartialEq, Eq)]
#[system_set(base)]
enum MyBaseSet {
A,
B,
}
```
**Base sets are exclusive**: a system can belong to at most one "base set". Adding a system to more than one will result in an error. When possible we fail immediately during system-config-time with a nice file + line number. For the more nested graph-ey cases, this will fail at the final schedule build.
**Base sets cannot belong to other sets**: this is where the word "base" comes from
Systems and Sets can only be added to base sets using `in_base_set`. Calling `in_set` with a base set will fail. As will calling `in_base_set` with a normal set.
```rust
app.add_system(foo.in_base_set(MyBaseSet::A))
// X must be a normal set ... base sets cannot be added to base sets
.configure_set(X.in_base_set(MyBaseSet::A))
```
Base sets can still be configured like normal sets:
```rust
app.add_system(MyBaseSet::B.after(MyBaseSet::Ap))
```
The primary use case for base sets is enabling a "default base set":
```rust
schedule.set_default_base_set(CoreSet::Update)
// this will belong to CoreSet::Update by default
.add_system(foo)
// this will override the default base set with PostUpdate
.add_system(bar.in_base_set(CoreSet::PostUpdate))
```
This allows us to build apis that work by default in the standard Bevy style. This is a rough analog to the "default stage" model, but it use the new "stageless sets" model instead, with all of the ordering flexibility (including exclusive systems) that it provides.
---
## Changelog
- Added "base sets" and ported CoreSet to use them.
## Migration Guide
TODO
2023-02-06 03:10:08 +00:00
|
|
|
|
|
|
|
self
|
|
|
|
}
|
|
|
|
|
2023-01-17 01:39:17 +00:00
|
|
|
fn before<M>(mut self, set: impl IntoSystemSet<M>) -> Self {
|
|
|
|
let set = set.into_system_set();
|
2023-03-18 01:45:34 +00:00
|
|
|
self.before_inner(set.dyn_clone());
|
2023-01-17 01:39:17 +00:00
|
|
|
self
|
|
|
|
}
|
|
|
|
|
|
|
|
fn after<M>(mut self, set: impl IntoSystemSet<M>) -> Self {
|
|
|
|
let set = set.into_system_set();
|
2023-03-18 01:45:34 +00:00
|
|
|
self.after_inner(set.dyn_clone());
|
2023-01-17 01:39:17 +00:00
|
|
|
self
|
|
|
|
}
|
|
|
|
|
2023-02-23 04:37:08 +00:00
|
|
|
fn distributive_run_if<M>(mut self, condition: impl Condition<M> + Clone) -> SystemConfigs {
|
2023-03-18 01:45:34 +00:00
|
|
|
self.distributive_run_if_inner(condition);
|
2023-02-18 21:33:09 +00:00
|
|
|
self
|
|
|
|
}
|
|
|
|
|
2023-01-17 01:39:17 +00:00
|
|
|
fn ambiguous_with<M>(mut self, set: impl IntoSystemSet<M>) -> Self {
|
|
|
|
let set = set.into_system_set();
|
2023-03-18 01:45:34 +00:00
|
|
|
self.ambiguous_with_inner(set.dyn_clone());
|
2023-01-17 01:39:17 +00:00
|
|
|
self
|
|
|
|
}
|
|
|
|
|
|
|
|
fn ambiguous_with_all(mut self) -> Self {
|
2023-03-18 01:45:34 +00:00
|
|
|
self.ambiguous_with_all_inner();
|
|
|
|
self
|
|
|
|
}
|
2023-01-17 01:39:17 +00:00
|
|
|
|
2023-03-18 01:45:34 +00:00
|
|
|
fn run_if<M>(mut self, condition: impl Condition<M>) -> SystemConfigs {
|
2023-08-27 17:53:37 +00:00
|
|
|
self.run_if_dyn(new_condition(condition));
|
2023-01-17 01:39:17 +00:00
|
|
|
self
|
|
|
|
}
|
|
|
|
|
2023-09-05 17:15:27 +00:00
|
|
|
fn chain(self) -> Self {
|
|
|
|
self.chain_inner()
|
2023-03-18 01:45:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-06-10 23:23:48 +00:00
|
|
|
#[doc(hidden)]
|
2023-03-18 01:45:34 +00:00
|
|
|
pub struct SystemConfigTupleMarker;
|
|
|
|
|
|
|
|
macro_rules! impl_system_collection {
|
|
|
|
($(($param: ident, $sys: ident)),*) => {
|
|
|
|
impl<$($param, $sys),*> IntoSystemConfigs<(SystemConfigTupleMarker, $($param,)*)> for ($($sys,)*)
|
|
|
|
where
|
|
|
|
$($sys: IntoSystemConfigs<$param>),*
|
|
|
|
{
|
|
|
|
#[allow(non_snake_case)]
|
|
|
|
fn into_configs(self) -> SystemConfigs {
|
|
|
|
let ($($sys,)*) = self;
|
|
|
|
SystemConfigs::Configs {
|
|
|
|
configs: vec![$($sys.into_configs(),)*],
|
`run_if` for `SystemConfigs` via anonymous system sets (#7676)
# Objective
- Fixes #7659
## Solution
The idea of anonymous system sets or "implicit hidden organizational
sets" was briefly mentioned by @cart here:
https://github.com/bevyengine/bevy/pull/7634#issuecomment-1428619449.
- `Schedule::add_systems` creates an implicit, anonymous system set of
all systems in `SystemConfigs`.
- All dependencies and conditions from the `SystemConfigs` are now
applied to the implicit system set, instead of being applied to each
individual system. This should not change the behavior, AFAIU, because
`before`, `after`, `run_if` and `ambiguous_with` are transitive
properties from a set to its members.
- The newly added `AnonymousSystemSet` stores the names of its members
to provide better error messages.
- The names are stored in a reference counted slice, allowing fast
clones of the `AnonymousSystemSet`.
- However, only the pointer of the slice is used for hash and equality
operations
- This ensures that two `AnonymousSystemSet` are not equal, even if they
have the same members / member names.
- So two identical `add_systems` calls will produce two different
`AnonymousSystemSet`s.
- Clones of the same `AnonymousSystemSet` will be equal.
## Drawbacks
If my assumptions are correct, the observed behavior should stay the
same. But the number of system sets in the `Schedule` will increase with
each `add_systems` call. If this has negative performance implications,
`add_systems` could be changed to only create the implicit system set if
necessary / when a run condition was added.
---------
Co-authored-by: Carter Anderson <mcanders1@gmail.com>
2023-03-30 21:39:10 +00:00
|
|
|
collective_conditions: Vec::new(),
|
2023-03-18 01:45:34 +00:00
|
|
|
chained: false,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
all_tuples!(impl_system_collection, 1, 20, P, S);
|
|
|
|
|
|
|
|
/// A [`SystemSet`] with scheduling metadata.
|
2023-09-05 17:15:27 +00:00
|
|
|
pub type SystemSetConfig = NodeConfig<BoxedSystemSet>;
|
2023-03-18 01:45:34 +00:00
|
|
|
|
|
|
|
impl SystemSetConfig {
|
clean up configure_set(s) erroring (#9577)
# Objective
- have errors in configure_set and configure_sets show the line number
of the user calling location rather than pointing to schedule.rs
- use display formatting for the errors
## Example Error Text
```text
// dependency loop
// before
thread 'main' panicked at 'called `Result::unwrap()` on an `Err` value: DependencyLoop("A")', crates\bevy_ecs\src\schedule\schedule.rs:682:39
// after
thread 'main' panicked at 'System set `A` depends on itself.', examples/stress_tests/bevymark.rs:16:9
// hierarchy loop
// before
thread 'main' panicked at 'called `Result::unwrap()` on an `Err` value: HierarchyLoop("A")', crates\bevy_ecs\src\schedule\schedule.rs:682:3
// after
thread 'main' panicked at 'System set `A` contains itself.', examples/stress_tests/bevymark.rs:16:9
// configuring a system type set
// before
thread 'main' panicked at 'configuring system type sets is not allowed', crates\bevy_ecs\src\schedule\config.rs:394:9
//after
thread 'main' panicked at 'configuring system type sets is not allowed', examples/stress_tests/bevymark.rs:16:9
```
Code to produce errors:
```rust
use bevy::prelude::*;
#[derive(SystemSet, Clone, Debug, PartialEq, Eq, Hash)]
enum TestSet {
A,
}
fn main() {
fn foo() {}
let mut app = App::empty();
// Hierarchy Loop
app.configure_set(Main, TestSet::A.in_set(TestSet::A));
// Dependency Loop
app.configure_set(Main, TestSet::A.after(TestSet::A));
// Configure System Type Set
app.configure_set(Main, foo.into_system_set());
}
```
2023-08-28 17:44:52 +00:00
|
|
|
#[track_caller]
|
2023-09-05 17:15:27 +00:00
|
|
|
pub(super) fn new(set: BoxedSystemSet) -> Self {
|
2023-03-18 01:45:34 +00:00
|
|
|
// system type sets are automatically populated
|
|
|
|
// to avoid unintentionally broad changes, they cannot be configured
|
|
|
|
assert!(
|
|
|
|
set.system_type().is_none(),
|
|
|
|
"configuring system type sets is not allowed"
|
|
|
|
);
|
|
|
|
|
|
|
|
Self {
|
2023-09-05 17:15:27 +00:00
|
|
|
node: set,
|
2023-03-18 01:45:34 +00:00
|
|
|
graph_info: GraphInfo::default(),
|
|
|
|
conditions: Vec::new(),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-01-17 01:39:17 +00:00
|
|
|
/// A collection of [`SystemSetConfig`].
|
2023-09-05 17:15:27 +00:00
|
|
|
pub type SystemSetConfigs = NodeConfigs<BoxedSystemSet>;
|
2023-01-17 01:39:17 +00:00
|
|
|
|
|
|
|
/// Types that can convert into a [`SystemSetConfigs`].
|
|
|
|
pub trait IntoSystemSetConfigs
|
|
|
|
where
|
|
|
|
Self: Sized,
|
|
|
|
{
|
|
|
|
/// Convert into a [`SystemSetConfigs`].
|
|
|
|
#[doc(hidden)]
|
|
|
|
fn into_configs(self) -> SystemSetConfigs;
|
|
|
|
|
|
|
|
/// Add these system sets to the provided `set`.
|
Base Sets (#7466)
# Objective
NOTE: This depends on #7267 and should not be merged until #7267 is merged. If you are reviewing this before that is merged, I highly recommend viewing the Base Sets commit instead of trying to find my changes amongst those from #7267.
"Default sets" as described by the [Stageless RFC](https://github.com/bevyengine/rfcs/pull/45) have some [unfortunate consequences](https://github.com/bevyengine/bevy/discussions/7365).
## Solution
This adds "base sets" as a variant of `SystemSet`:
A set is a "base set" if `SystemSet::is_base` returns `true`. Typically this will be opted-in to using the `SystemSet` derive:
```rust
#[derive(SystemSet, Clone, Hash, Debug, PartialEq, Eq)]
#[system_set(base)]
enum MyBaseSet {
A,
B,
}
```
**Base sets are exclusive**: a system can belong to at most one "base set". Adding a system to more than one will result in an error. When possible we fail immediately during system-config-time with a nice file + line number. For the more nested graph-ey cases, this will fail at the final schedule build.
**Base sets cannot belong to other sets**: this is where the word "base" comes from
Systems and Sets can only be added to base sets using `in_base_set`. Calling `in_set` with a base set will fail. As will calling `in_base_set` with a normal set.
```rust
app.add_system(foo.in_base_set(MyBaseSet::A))
// X must be a normal set ... base sets cannot be added to base sets
.configure_set(X.in_base_set(MyBaseSet::A))
```
Base sets can still be configured like normal sets:
```rust
app.add_system(MyBaseSet::B.after(MyBaseSet::Ap))
```
The primary use case for base sets is enabling a "default base set":
```rust
schedule.set_default_base_set(CoreSet::Update)
// this will belong to CoreSet::Update by default
.add_system(foo)
// this will override the default base set with PostUpdate
.add_system(bar.in_base_set(CoreSet::PostUpdate))
```
This allows us to build apis that work by default in the standard Bevy style. This is a rough analog to the "default stage" model, but it use the new "stageless sets" model instead, with all of the ordering flexibility (including exclusive systems) that it provides.
---
## Changelog
- Added "base sets" and ported CoreSet to use them.
## Migration Guide
TODO
2023-02-06 03:10:08 +00:00
|
|
|
#[track_caller]
|
2023-03-18 01:45:34 +00:00
|
|
|
fn in_set(self, set: impl SystemSet) -> SystemSetConfigs {
|
2023-01-17 01:39:17 +00:00
|
|
|
self.into_configs().in_set(set)
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Run before all systems in `set`.
|
|
|
|
fn before<M>(self, set: impl IntoSystemSet<M>) -> SystemSetConfigs {
|
|
|
|
self.into_configs().before(set)
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Run after all systems in `set`.
|
|
|
|
fn after<M>(self, set: impl IntoSystemSet<M>) -> SystemSetConfigs {
|
|
|
|
self.into_configs().after(set)
|
|
|
|
}
|
|
|
|
|
2023-09-05 17:15:27 +00:00
|
|
|
/// Run the systems in this set(s) only if the [`Condition`] is `true`.
|
|
|
|
///
|
|
|
|
/// The `Condition` will be evaluated at most once (per schedule run),
|
|
|
|
/// the first time a system in this set(s) prepares to run.
|
|
|
|
fn run_if<M>(self, condition: impl Condition<M>) -> SystemSetConfigs {
|
|
|
|
self.into_configs().run_if(condition)
|
|
|
|
}
|
|
|
|
|
2023-01-17 01:39:17 +00:00
|
|
|
/// Suppress warnings and errors that would result from systems in these sets having ambiguities
|
|
|
|
/// (conflicting access but indeterminate order) with systems in `set`.
|
|
|
|
fn ambiguous_with<M>(self, set: impl IntoSystemSet<M>) -> SystemSetConfigs {
|
|
|
|
self.into_configs().ambiguous_with(set)
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Suppress warnings and errors that would result from systems in these sets having ambiguities
|
|
|
|
/// (conflicting access but indeterminate order) with any other system.
|
|
|
|
fn ambiguous_with_all(self) -> SystemSetConfigs {
|
|
|
|
self.into_configs().ambiguous_with_all()
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Treat this collection as a sequence of system sets.
|
|
|
|
///
|
|
|
|
/// Ordering constraints will be applied between the successive elements.
|
|
|
|
fn chain(self) -> SystemSetConfigs {
|
|
|
|
self.into_configs().chain()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl IntoSystemSetConfigs for SystemSetConfigs {
|
|
|
|
fn into_configs(self) -> Self {
|
|
|
|
self
|
|
|
|
}
|
|
|
|
|
Base Sets (#7466)
# Objective
NOTE: This depends on #7267 and should not be merged until #7267 is merged. If you are reviewing this before that is merged, I highly recommend viewing the Base Sets commit instead of trying to find my changes amongst those from #7267.
"Default sets" as described by the [Stageless RFC](https://github.com/bevyengine/rfcs/pull/45) have some [unfortunate consequences](https://github.com/bevyengine/bevy/discussions/7365).
## Solution
This adds "base sets" as a variant of `SystemSet`:
A set is a "base set" if `SystemSet::is_base` returns `true`. Typically this will be opted-in to using the `SystemSet` derive:
```rust
#[derive(SystemSet, Clone, Hash, Debug, PartialEq, Eq)]
#[system_set(base)]
enum MyBaseSet {
A,
B,
}
```
**Base sets are exclusive**: a system can belong to at most one "base set". Adding a system to more than one will result in an error. When possible we fail immediately during system-config-time with a nice file + line number. For the more nested graph-ey cases, this will fail at the final schedule build.
**Base sets cannot belong to other sets**: this is where the word "base" comes from
Systems and Sets can only be added to base sets using `in_base_set`. Calling `in_set` with a base set will fail. As will calling `in_base_set` with a normal set.
```rust
app.add_system(foo.in_base_set(MyBaseSet::A))
// X must be a normal set ... base sets cannot be added to base sets
.configure_set(X.in_base_set(MyBaseSet::A))
```
Base sets can still be configured like normal sets:
```rust
app.add_system(MyBaseSet::B.after(MyBaseSet::Ap))
```
The primary use case for base sets is enabling a "default base set":
```rust
schedule.set_default_base_set(CoreSet::Update)
// this will belong to CoreSet::Update by default
.add_system(foo)
// this will override the default base set with PostUpdate
.add_system(bar.in_base_set(CoreSet::PostUpdate))
```
This allows us to build apis that work by default in the standard Bevy style. This is a rough analog to the "default stage" model, but it use the new "stageless sets" model instead, with all of the ordering flexibility (including exclusive systems) that it provides.
---
## Changelog
- Added "base sets" and ported CoreSet to use them.
## Migration Guide
TODO
2023-02-06 03:10:08 +00:00
|
|
|
#[track_caller]
|
2023-01-17 01:39:17 +00:00
|
|
|
fn in_set(mut self, set: impl SystemSet) -> Self {
|
|
|
|
assert!(
|
2023-02-16 22:25:48 +00:00
|
|
|
set.system_type().is_none(),
|
2023-01-17 01:39:17 +00:00
|
|
|
"adding arbitrary systems to a system type set is not allowed"
|
|
|
|
);
|
2023-09-05 17:15:27 +00:00
|
|
|
self.in_set_dyn(set.dyn_clone());
|
2023-01-17 01:39:17 +00:00
|
|
|
|
|
|
|
self
|
|
|
|
}
|
|
|
|
|
|
|
|
fn before<M>(mut self, set: impl IntoSystemSet<M>) -> Self {
|
|
|
|
let set = set.into_system_set();
|
2023-09-05 17:15:27 +00:00
|
|
|
self.before_inner(set.dyn_clone());
|
2023-01-17 01:39:17 +00:00
|
|
|
|
|
|
|
self
|
|
|
|
}
|
|
|
|
|
|
|
|
fn after<M>(mut self, set: impl IntoSystemSet<M>) -> Self {
|
|
|
|
let set = set.into_system_set();
|
2023-09-05 17:15:27 +00:00
|
|
|
self.after_inner(set.dyn_clone());
|
|
|
|
|
|
|
|
self
|
|
|
|
}
|
|
|
|
|
|
|
|
fn run_if<M>(mut self, condition: impl Condition<M>) -> SystemSetConfigs {
|
|
|
|
self.run_if_dyn(new_condition(condition));
|
2023-01-17 01:39:17 +00:00
|
|
|
|
|
|
|
self
|
|
|
|
}
|
|
|
|
|
|
|
|
fn ambiguous_with<M>(mut self, set: impl IntoSystemSet<M>) -> Self {
|
|
|
|
let set = set.into_system_set();
|
2023-09-05 17:15:27 +00:00
|
|
|
self.ambiguous_with_inner(set.dyn_clone());
|
2023-01-17 01:39:17 +00:00
|
|
|
|
|
|
|
self
|
|
|
|
}
|
|
|
|
|
|
|
|
fn ambiguous_with_all(mut self) -> Self {
|
2023-09-05 17:15:27 +00:00
|
|
|
self.ambiguous_with_all_inner();
|
2023-01-17 01:39:17 +00:00
|
|
|
|
|
|
|
self
|
|
|
|
}
|
|
|
|
|
2023-09-05 17:15:27 +00:00
|
|
|
fn chain(self) -> Self {
|
|
|
|
self.chain_inner()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<S: SystemSet> IntoSystemSetConfigs for S {
|
|
|
|
fn into_configs(self) -> SystemSetConfigs {
|
|
|
|
SystemSetConfigs::NodeConfig(SystemSetConfig::new(Box::new(self)))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl IntoSystemSetConfigs for BoxedSystemSet {
|
|
|
|
fn into_configs(self) -> SystemSetConfigs {
|
|
|
|
SystemSetConfigs::NodeConfig(SystemSetConfig::new(self))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl IntoSystemSetConfigs for SystemSetConfig {
|
|
|
|
fn into_configs(self) -> SystemSetConfigs {
|
|
|
|
SystemSetConfigs::NodeConfig(self)
|
2023-01-17 01:39:17 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
macro_rules! impl_system_set_collection {
|
|
|
|
($($set: ident),*) => {
|
2023-09-05 17:15:27 +00:00
|
|
|
impl<$($set: IntoSystemSetConfigs),*> IntoSystemSetConfigs for ($($set,)*)
|
2023-01-17 01:39:17 +00:00
|
|
|
{
|
|
|
|
#[allow(non_snake_case)]
|
|
|
|
fn into_configs(self) -> SystemSetConfigs {
|
|
|
|
let ($($set,)*) = self;
|
2023-09-05 17:15:27 +00:00
|
|
|
SystemSetConfigs::Configs {
|
|
|
|
configs: vec![$($set.into_configs(),)*],
|
|
|
|
collective_conditions: Vec::new(),
|
2023-01-17 01:39:17 +00:00
|
|
|
chained: false,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-09-05 17:15:27 +00:00
|
|
|
all_tuples!(impl_system_set_collection, 1, 20, S);
|