Mirrors/bevy
2
0
Fork 0
mirror of https://github.com/bevyengine/bevy synced 2024-11-25 22:20:20 +00:00
Code Issues Projects Releases Packages Wiki Activity

Remove apply_deferred example (#11142)

Browse source 
# Objective

Re this comment:
https://github.com/bevyengine/bevy/pull/11141#issuecomment-1872455313

Since https://github.com/bevyengine/bevy/pull/9822, Bevy automatically
inserts `apply_deferred` between systems with dependencies where needed,
so manually inserted `apply_deferred` doesn't to anything useful, and in
current state this example does more harm than good.

## Solution

The example can be modified with removal of automatic `apply_deferred`
insertion, but that would immediately upgrade this example from beginner
level, to upper intermediate. Most users don't need to disable automatic
sync point insertion, and remaining few who do probably already know how
it works.

CC @hymm
This commit is contained in:
Stepan Koltsov 2024-01-08 22:34:32 +00:00 committed by GitHub
parent df2ba09989
commit 42e990861c
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
3 changed files with 0 additions and 187 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
Cargo.toml
View file

@ -1283,11 +1283,6 @@ description = "Full guide to Bevy's ECS"
category = "ECS (Entity Component System)"
wasm = false
[[example]]
name = "apply_deferred"
path = "examples/ecs/apply_deferred.rs"
doc-scrape-examples = true
[package.metadata.example.apply_deferred]
name = "Apply System Buffers"
description = "Show how to use `apply_deferred` system"

1
examples/README.md
View file

@ -219,7 +219,6 @@ Example | Description
Example | Description
--- | ---
[Apply System Buffers](../examples/ecs/apply_deferred.rs) | Show how to use `apply_deferred` system
[Component Change Detection](../examples/ecs/component_change_detection.rs) | Change detection on components
[Custom Query Parameters](../examples/ecs/custom_query_param.rs) | Groups commonly used compound queries and query filters into a single type
[ECS Guide](../examples/ecs/ecs_guide.rs) | Full guide to Bevy's ECS

181
examples/ecs/apply_deferred.rs
View file

@ -1,181 +0,0 @@
//! This example illustrates how to use the `apply_deferred` system
//! to flush commands added by systems that have already run,
//! but have not had their buffers applied yet.
//!
//! This is useful when you don't want to wait until the next time Bevy
//! automatically flushes commands (by default, after all systems have run in any
//! particular schedule) but want to flush commands immediately.
//!
//! It is important that systems are ordered correctly with respect to
//! `apply_deferred`, to avoid surprising non-deterministic system execution order.
use bevy::prelude::*;
fn main() {
App::new()
.add_plugins(DefaultPlugins)
.init_resource::<Timers>()
.add_systems(Startup, setup)
.add_systems(
Update,
(
(
despawn_old_and_spawn_new_fruits,
// We encourage adding apply_deferred to a custom set
// to improve diagnostics. This is optional, but useful when debugging!
apply_deferred.in_set(CustomFlush),
count_apple,
)
.chain(),
count_orange,
bevy::window::close_on_esc,
),
)
.run();
}
#[derive(Resource)]
struct Timers {
repeating: Timer,
}
impl Default for Timers {
fn default() -> Self {
Self {
repeating: Timer::from_seconds(0.5, TimerMode::Repeating),
}
}
}
#[derive(Debug, Hash, PartialEq, Eq, Clone, SystemSet)]
struct CustomFlush;
#[derive(Component)]
struct Apple;
#[derive(Component)]
struct Orange;
#[derive(Component)]
struct AppleCount;
#[derive(Component)]
struct OrangeCount;
// Setup the counters in the UI.
fn setup(mut commands: Commands) {
commands.spawn(Camera2dBundle::default());
commands
.spawn(NodeBundle {
style: Style {
width: Val::Percent(100.0),
height: Val::Percent(100.0),
align_items: AlignItems::Center,
justify_content: JustifyContent::Center,
flex_direction: FlexDirection::Column,
..default()
},
..default()
})
.with_children(|parent| {
parent.spawn((
TextBundle::from_section(
"Apple: nothing counted yet".to_string(),
TextStyle {
font_size: 80.0,
color: Color::ORANGE,
..default()
},
),
AppleCount,
));
parent.spawn((
TextBundle::from_section(
"Orange: nothing counted yet".to_string(),
TextStyle {
font_size: 80.0,
color: Color::ORANGE,
..default()
},
),
OrangeCount,
));
});
}
// Every tick, before the CustomFlush we added, we despawn any Apple and Orange
// we have previously spawned, if any. Then we tick the timer, and if the timer
// has finished during this tick, we spawn a new Apple and a new Orange.
//
// The commands that we have added here will normally be flushed by Bevy
// after all systems in the schedule have run, but because we have ordered
// this system to run before `apply_deferred.in_set(CustomFlush)`,
// these commands added here will be flushed during our custom flush.
fn despawn_old_and_spawn_new_fruits(
mut commands: Commands,
time: Res<Time>,
mut timers: ResMut<Timers>,
apple: Query<Entity, With<Apple>>,
orange: Query<Entity, With<Orange>>,
) {
if let Ok(apple_entity) = apple.get_single() {
commands.entity(apple_entity).despawn();
}
if let Ok(orange_entity) = orange.get_single() {
commands.entity(orange_entity).despawn();
}
timers.repeating.tick(time.delta());
if timers.repeating.just_finished() {
commands.spawn(Apple);
commands.spawn(Orange);
}
}
// If the timer has finished during this tick, we see if there is an entity
// with an Apple component or not, and update the UI accordingly.
//
// Since this system is ordered `.after(CustomFlush)` it will be guaranteed
// to run after our CustomFlush set, so the Apple will always be counted.
//
// We will see the AppleCount go from "Apple: nothing counted yet" to "Apple: counted"
fn count_apple(
timers: Res<Timers>,
apple: Query<&Apple>,
mut apple_count: Query<&mut Text, With<AppleCount>>,
) {
if timers.repeating.just_finished() {
let mut apples_text = apple_count.single_mut();
apples_text.sections[0].value = if apple.is_empty() {
"Apple: not counted".to_string()
} else {
"Apple: counted".to_string()
};
}
}
// If the timer has finished during this tick, we see if there is an entity
// with an Orange component or not, and update the UI accordingly.
//
// Since this system is not ordered `.after(CustomFlush)`, it may or may not run
// before the custom flush, therefore you will see the UI either show "Orange: counted"
// or "Orange: not counted" or alternate between the two.
//
// Try to re-run the example multiple times as well.
fn count_orange(
timers: Res<Timers>,
orange: Query<&Orange>,
mut orange_count: Query<&mut Text, With<OrangeCount>>,
) {
if timers.repeating.just_finished() {
let mut oranges_text = orange_count.single_mut();
oranges_text.sections[0].value = if orange.is_empty() {
"Orange: not counted".to_string()
} else {
"Orange: counted".to_string()
};
}
}