mirror of
https://github.com/bevyengine/bevy
synced 2024-11-26 22:50:19 +00:00
dcc03724a5
# 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
92 lines
3.1 KiB
Rust
92 lines
3.1 KiB
Rust
//! Creates a hierarchy of parents and children entities.
|
|
|
|
use std::f32::consts::*;
|
|
|
|
use bevy::prelude::*;
|
|
|
|
fn main() {
|
|
App::new()
|
|
.add_plugins(DefaultPlugins)
|
|
.add_startup_system(setup)
|
|
.add_system(rotate)
|
|
.run();
|
|
}
|
|
|
|
fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
|
|
commands.spawn(Camera2dBundle::default());
|
|
let texture = asset_server.load("branding/icon.png");
|
|
|
|
// Spawn a root entity with no parent
|
|
let parent = commands
|
|
.spawn(SpriteBundle {
|
|
transform: Transform::from_scale(Vec3::splat(0.75)),
|
|
texture: texture.clone(),
|
|
..default()
|
|
})
|
|
// With that entity as a parent, run a lambda that spawns its children
|
|
.with_children(|parent| {
|
|
// parent is a ChildBuilder, which has a similar API to Commands
|
|
parent.spawn(SpriteBundle {
|
|
transform: Transform::from_xyz(250.0, 0.0, 0.0).with_scale(Vec3::splat(0.75)),
|
|
texture: texture.clone(),
|
|
sprite: Sprite {
|
|
color: Color::BLUE,
|
|
..default()
|
|
},
|
|
..default()
|
|
});
|
|
})
|
|
// Store parent entity for next sections
|
|
.id();
|
|
|
|
// Another way is to use the push_children function to add children after the parent
|
|
// entity has already been spawned.
|
|
let child = commands
|
|
.spawn(SpriteBundle {
|
|
transform: Transform::from_xyz(0.0, 250.0, 0.0).with_scale(Vec3::splat(0.75)),
|
|
texture,
|
|
sprite: Sprite {
|
|
color: Color::GREEN,
|
|
..default()
|
|
},
|
|
..default()
|
|
})
|
|
.id();
|
|
|
|
// Add child to the parent.
|
|
commands.entity(parent).add_child(child);
|
|
}
|
|
|
|
// A simple system to rotate the root entity, and rotate all its children separately
|
|
fn rotate(
|
|
mut commands: Commands,
|
|
time: Res<Time>,
|
|
mut parents_query: Query<(Entity, &Children), With<Sprite>>,
|
|
mut transform_query: Query<&mut Transform, With<Sprite>>,
|
|
) {
|
|
for (parent, children) in &mut parents_query {
|
|
if let Ok(mut transform) = transform_query.get_mut(parent) {
|
|
transform.rotate_z(-PI / 2. * time.delta_seconds());
|
|
}
|
|
|
|
// To iterate through the entities children, just treat the Children component as a Vec
|
|
// Alternatively, you could query entities that have a Parent component
|
|
for child in children {
|
|
if let Ok(mut transform) = transform_query.get_mut(*child) {
|
|
transform.rotate_z(PI * time.delta_seconds());
|
|
}
|
|
}
|
|
|
|
// To demonstrate removing children, we'll remove a child after a couple of seconds.
|
|
if time.elapsed_seconds() >= 2.0 && children.len() == 2 {
|
|
let child = children.last().unwrap();
|
|
commands.entity(*child).despawn_recursive();
|
|
}
|
|
|
|
if time.elapsed_seconds() >= 4.0 {
|
|
// This will remove the entity from its parent's list of children, as well as despawn
|
|
// any children the entity has.
|
|
commands.entity(parent).despawn_recursive();
|
|
}
|
|
}
|
|
}
|