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 } ,
2023-03-18 01:45:34 +00:00
ScheduleLabel ,
2023-01-17 01:39:17 +00:00
} ,
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-03-18 01:45:34 +00:00
pub struct SystemConfig {
pub ( crate ) system : BoxedSystem ,
pub ( crate ) graph_info : GraphInfo ,
pub ( crate ) conditions : Vec < BoxedCondition > ,
2023-01-17 01:39:17 +00:00
}
2023-03-18 01:45:34 +00:00
/// A collection of [`SystemConfig`].
pub enum SystemConfigs {
SystemConfig ( SystemConfig ) ,
Configs {
configs : Vec < SystemConfigs > ,
`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-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 ( ) ;
Self ::SystemConfig ( SystemConfig {
system ,
graph_info : GraphInfo {
sets ,
.. Default ::default ( )
} ,
conditions : Vec ::new ( ) ,
} )
2023-01-17 01:39:17 +00:00
}
`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
pub ( crate ) fn in_set_inner ( & mut self , set : BoxedSystemSet ) {
2023-03-18 01:45:34 +00:00
match self {
SystemConfigs ::SystemConfig ( config ) = > {
config . graph_info . sets . push ( set ) ;
}
SystemConfigs ::Configs { configs , .. } = > {
for config in configs {
config . in_set_inner ( 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
}
2023-03-18 01:45:34 +00:00
fn before_inner ( & mut self , set : BoxedSystemSet ) {
match self {
SystemConfigs ::SystemConfig ( config ) = > {
config
. graph_info
. dependencies
. push ( Dependency ::new ( DependencyKind ::Before , set ) ) ;
}
SystemConfigs ::Configs { configs , .. } = > {
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 {
SystemConfigs ::SystemConfig ( config ) = > {
config
. graph_info
. dependencies
. push ( Dependency ::new ( DependencyKind ::After , set ) ) ;
}
SystemConfigs ::Configs { configs , .. } = > {
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 {
SystemConfigs ::SystemConfig ( config ) = > {
config . conditions . push ( new_condition ( condition ) ) ;
}
SystemConfigs ::Configs { configs , .. } = > {
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 {
SystemConfigs ::SystemConfig ( config ) = > {
ambiguous_with ( & mut config . graph_info , set ) ;
}
SystemConfigs ::Configs { configs , .. } = > {
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 {
SystemConfigs ::SystemConfig ( config ) = > {
config . graph_info . ambiguous_with = Ambiguity ::IgnoreAll ;
}
SystemConfigs ::Configs { configs , .. } = > {
for config in configs {
config . ambiguous_with_all_inner ( ) ;
}
}
}
2023-01-17 01:39:17 +00:00
}
`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
pub ( crate ) fn run_if_inner ( & mut self , condition : BoxedCondition ) {
2023-03-18 01:45:34 +00:00
match self {
SystemConfigs ::SystemConfig ( config ) = > {
config . conditions . push ( 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
SystemConfigs ::Configs {
collective_conditions ,
..
} = > {
collective_conditions . push ( condition ) ;
2023-03-18 01:45:34 +00:00
}
}
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::*;
`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
/// # let mut schedule = Schedule::new();
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.
///
/// Use [`run_if`](IntoSystemSetConfig::run_if) on a [`SystemSet`] if you want to make sure
/// 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::*;
/// # let mut schedule = Schedule::new();
/// # 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));
/// schedule.add_systems((a, b).in_set(C)).configure_set(C.run_if(condition));
/// ```
///
/// # 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 ( )
}
2023-03-18 01:45:34 +00:00
/// This used to add the system to `CoreSchedule::Startup`.
/// This was a shorthand for `self.in_schedule(CoreSchedule::Startup)`.
///
/// # Panics
///
/// Always panics. Please migrate to the new `App::add_systems` with the `Startup` schedule:
/// Ex: `app.add_system(foo.on_startup())` -> `app.add_systems(Startup, foo)`
#[ deprecated(
since = " 0.11.0 " ,
note = " `app.add_system(foo.on_startup())` has been deprecated in favor of `app.add_systems(Startup, foo)`. Please migrate to that API. "
) ]
fn on_startup ( self ) -> SystemConfigs {
panic! ( " `app.add_system(foo.on_startup())` has been deprecated in favor of `app.add_systems(Startup, foo)`. Please migrate to that API. " ) ;
}
/// This used to add the system to the provided `schedule`.
///
/// # Panics
///
/// Always panics. Please migrate to the new `App::add_systems`:
/// Ex: `app.add_system(foo.in_schedule(SomeSchedule))` -> `app.add_systems(SomeSchedule, foo)`
#[ deprecated(
since = " 0.11.0 " ,
note = " `app.add_system(foo.in_schedule(SomeSchedule))` has been deprecated in favor of `app.add_systems(SomeSchedule, foo)`. Please migrate to that API. "
) ]
fn in_schedule ( self , _schedule : impl ScheduleLabel ) -> SystemConfigs {
panic! ( " `app.add_system(foo.in_schedule(SomeSchedule))` has been deprecated in favor of `app.add_systems(SomeSchedule, foo)`. Please migrate to that API. " ) ;
}
2023-01-17 01:39:17 +00:00
}
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-03-18 01:45:34 +00:00
self . in_set_inner ( 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 {
self . run_if_inner ( new_condition ( condition ) ) ;
2023-01-17 01:39:17 +00:00
self
}
fn chain ( mut self ) -> Self {
2023-03-18 01:45:34 +00:00
match & mut self {
SystemConfigs ::SystemConfig ( _ ) = > { /* no op */ }
SystemConfigs ::Configs { chained , .. } = > {
* chained = true ;
}
}
self
}
}
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.
pub struct SystemSetConfig {
pub ( super ) set : BoxedSystemSet ,
pub ( super ) graph_info : GraphInfo ,
pub ( super ) conditions : Vec < BoxedCondition > ,
}
impl SystemSetConfig {
fn new ( set : BoxedSystemSet ) -> Self {
// 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 {
set ,
graph_info : GraphInfo ::default ( ) ,
conditions : Vec ::new ( ) ,
}
}
}
/// Types that can be converted into a [`SystemSetConfig`].
///
/// This has been implemented for all types that implement [`SystemSet`] and boxed trait objects.
pub trait IntoSystemSetConfig : Sized {
/// Convert into a [`SystemSetConfig`].
#[ doc(hidden) ]
fn into_config ( self ) -> SystemSetConfig ;
/// Add to the provided `set`.
#[ track_caller ]
fn in_set ( self , set : impl SystemSet ) -> SystemSetConfig {
self . into_config ( ) . in_set ( set )
}
/// Run before all systems in `set`.
fn before < M > ( self , set : impl IntoSystemSet < M > ) -> SystemSetConfig {
self . into_config ( ) . before ( set )
}
/// Run after all systems in `set`.
fn after < M > ( self , set : impl IntoSystemSet < M > ) -> SystemSetConfig {
self . into_config ( ) . after ( set )
}
/// Run the systems in this set 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.
fn run_if < M > ( self , condition : impl Condition < M > ) -> SystemSetConfig {
self . into_config ( ) . run_if ( condition )
}
/// Suppress warnings and errors that would result from systems in this set having ambiguities
/// (conflicting access but indeterminate order) with systems in `set`.
fn ambiguous_with < M > ( self , set : impl IntoSystemSet < M > ) -> SystemSetConfig {
self . into_config ( ) . ambiguous_with ( set )
}
/// Suppress warnings and errors that would result from systems in this set having ambiguities
/// (conflicting access but indeterminate order) with any other system.
fn ambiguous_with_all ( self ) -> SystemSetConfig {
self . into_config ( ) . ambiguous_with_all ( )
}
/// This used to configure the set in the `CoreSchedule::Startup` schedule.
/// This was a shorthand for `self.in_schedule(CoreSchedule::Startup)`.
///
/// # Panics
///
/// Always panics. Please migrate to the new `App::configure_set` with the `Startup` schedule:
/// Ex: `app.configure_set(MySet.on_startup())` -> `app.configure_set(Startup, MySet)`
#[ deprecated(
since = " 0.11.0 " ,
note = " `app.configure_set(MySet.on_startup())` has been deprecated in favor of `app.configure_set(Startup, MySet)`. Please migrate to that API. "
) ]
fn on_startup ( self ) -> SystemSetConfigs {
panic! ( " `app.configure_set(MySet.on_startup())` has been deprecated in favor of `app.configure_set(Startup, MySet)`. Please migrate to that API. " ) ;
}
/// This used to configure the set in the provided `schedule`.
///
/// # Panics
///
/// Always panics. Please migrate to the new `App::configure_set`:
/// Ex: `app.configure_set(MySet.in_schedule(SomeSchedule))` -> `app.configure_set(SomeSchedule, MySet)`
#[ deprecated(
since = " 0.11.0 " ,
note = " `app.configure_set(MySet.in_schedule(SomeSchedule))` has been deprecated in favor of `app.configure_set(SomeSchedule, MySet)`. Please migrate to that API. "
) ]
fn in_schedule ( self , _schedule : impl ScheduleLabel ) -> SystemSetConfigs {
panic! ( " `app.configure_set(MySet.in_schedule(SomeSchedule))` has been deprecated in favor of `app.configure_set(SomeSchedule, MySet)`. Please migrate to that API. " ) ;
}
}
impl < S : SystemSet > IntoSystemSetConfig for S {
fn into_config ( self ) -> SystemSetConfig {
SystemSetConfig ::new ( Box ::new ( self ) )
}
}
impl IntoSystemSetConfig for BoxedSystemSet {
fn into_config ( self ) -> SystemSetConfig {
SystemSetConfig ::new ( self )
}
}
impl IntoSystemSetConfig for SystemSetConfig {
fn into_config ( self ) -> Self {
self
}
#[ track_caller ]
fn in_set ( mut self , set : impl SystemSet ) -> Self {
assert! (
set . system_type ( ) . is_none ( ) ,
" adding arbitrary systems to a system type set is not allowed "
) ;
self . graph_info . sets . push ( Box ::new ( set ) ) ;
self
}
fn before < M > ( mut self , set : impl IntoSystemSet < M > ) -> Self {
self . graph_info . dependencies . push ( Dependency ::new (
DependencyKind ::Before ,
Box ::new ( set . into_system_set ( ) ) ,
) ) ;
self
}
fn after < M > ( mut self , set : impl IntoSystemSet < M > ) -> Self {
self . graph_info . dependencies . push ( Dependency ::new (
DependencyKind ::After ,
Box ::new ( set . into_system_set ( ) ) ,
) ) ;
self
}
fn run_if < M > ( mut self , condition : impl Condition < M > ) -> Self {
self . conditions . push ( new_condition ( condition ) ) ;
self
}
fn ambiguous_with < M > ( mut self , set : impl IntoSystemSet < M > ) -> Self {
ambiguous_with ( & mut self . graph_info , Box ::new ( set . into_system_set ( ) ) ) ;
self
}
fn ambiguous_with_all ( mut self ) -> Self {
self . graph_info . ambiguous_with = Ambiguity ::IgnoreAll ;
2023-01-17 01:39:17 +00:00
self
}
}
/// A collection of [`SystemSetConfig`].
pub struct SystemSetConfigs {
pub ( super ) sets : Vec < SystemSetConfig > ,
/// If `true`, adds `before -> after` ordering constraints between the successive elements.
pub ( super ) chained : bool ,
}
/// 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 )
}
/// 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 ( )
}
2023-03-18 01:45:34 +00:00
/// This used to configure the sets in the `CoreSchedule::Startup` schedule.
/// This was a shorthand for `self.in_schedule(CoreSchedule::Startup)`.
///
/// # Panics
///
/// Always panics. Please migrate to the new `App::configure_sets` with the `Startup` schedule:
/// Ex: `app.configure_sets((A, B).on_startup())` -> `app.configure_sets(Startup, (A, B))`
#[ deprecated(
since = " 0.11.0 " ,
note = " `app.configure_sets((A, B).on_startup())` has been deprecated in favor of `app.configure_sets(Startup, (A, B))`. Please migrate to that API. "
) ]
fn on_startup ( self ) -> SystemSetConfigs {
panic! ( " `app.configure_sets((A, B).on_startup())` has been deprecated in favor of `app.configure_sets(Startup, (A, B))`. Please migrate to that API. " ) ;
}
/// This used to configure the sets in the provided `schedule`.
///
/// # Panics
///
/// Always panics. Please migrate to the new `App::configure_set`:
/// Ex: `app.configure_sets((A, B).in_schedule(SomeSchedule))` -> `app.configure_sets(SomeSchedule, (A, B))`
#[ deprecated(
since = " 0.11.0 " ,
note = " `app.configure_sets((A, B).in_schedule(SomeSchedule))` has been deprecated in favor of `app.configure_sets(SomeSchedule, (A, B))`. Please migrate to that API. "
) ]
fn in_schedule ( self , _schedule : impl ScheduleLabel ) -> SystemSetConfigs {
panic! ( " `app.configure_sets((A, B).in_schedule(SomeSchedule))` has been deprecated in favor of `app.configure_sets(SomeSchedule, (A, B))`. Please migrate to that API. " ) ;
}
2023-01-17 01:39:17 +00:00
}
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 "
) ;
for config in & mut self . sets {
config . graph_info . sets . push ( set . dyn_clone ( ) ) ;
}
self
}
fn before < M > ( mut self , set : impl IntoSystemSet < M > ) -> Self {
let set = set . into_system_set ( ) ;
for config in & mut self . sets {
config
. graph_info
. dependencies
. push ( Dependency ::new ( DependencyKind ::Before , set . dyn_clone ( ) ) ) ;
}
self
}
fn after < M > ( mut self , set : impl IntoSystemSet < M > ) -> Self {
let set = set . into_system_set ( ) ;
for config in & mut self . sets {
config
. graph_info
. dependencies
. push ( Dependency ::new ( DependencyKind ::After , set . dyn_clone ( ) ) ) ;
}
self
}
fn ambiguous_with < M > ( mut self , set : impl IntoSystemSet < M > ) -> Self {
let set = set . into_system_set ( ) ;
for config in & mut self . sets {
ambiguous_with ( & mut config . graph_info , set . dyn_clone ( ) ) ;
}
self
}
fn ambiguous_with_all ( mut self ) -> Self {
for config in & mut self . sets {
config . graph_info . ambiguous_with = Ambiguity ::IgnoreAll ;
}
self
}
fn chain ( mut self ) -> Self {
self . chained = true ;
self
}
}
macro_rules ! impl_system_set_collection {
( $( $set : ident ) , * ) = > {
impl < $( $set : IntoSystemSetConfig ) , * > IntoSystemSetConfigs for ( $( $set , ) * )
{
#[ allow(non_snake_case) ]
fn into_configs ( self ) -> SystemSetConfigs {
let ( $( $set , ) * ) = self ;
SystemSetConfigs {
sets : vec ! [ $( $set . into_config ( ) , ) * ] ,
chained : false ,
}
}
}
}
}
all_tuples! ( impl_system_set_collection , 0 , 15 , S ) ;