9e34c748c6
# Objective
I'm build a UI system for bevy. In this UI system there is a concept of a system per UI entity. I had an issue where change detection wasn't working how I would expect and it's because when a function system is ran the `last_change_tick` is updated with the latest tick(from world). In my particular case I want to "wait" to update the `last_change_tick` until after my system runs for each entity.
## Solution
Initially I thought bypassing the change detection all together would be a good fix, but on talking to some users in discord a simpler fix is to just expose `last_change_tick` to the end users. This is achieved by adding the following to the `System` trait:
```rust
/// Allows users to get the system's last change tick.
fn get_last_change_tick(&self) -> u32;
/// Allows users to set the system's last change tick.
fn set_last_change_tick(&mut self, last_change_tick: u32);
```
This causes a bit of weirdness with two implementors of `System`. `FixedTimestep` and `ChainSystem` both implement system and thus it's required that some sort of implementation be given for the new functions. I solved this by outputting a warning and not doing anything for these systems.
I think it's important to understand why I can't add the new functions only to the function system and not to the `System` trait. In my code I store the systems generically as `Box<dyn System<...>>`. I do this because I have differing parameters that are being passed in depending on the UI widget's system. As far as I can tell there isn't a way to take a system trait and cast it into a specific type without knowing what those parameters are.
In my own code this ends up looking something like:
```rust
// Runs per entity.
let old_tick = widget_system.get_last_change_tick();
should_update_children = widget_system.run((widget_tree.clone(), entity.0), world);
widget_system.set_last_change_tick(old_tick);
// later on after all the entities have been processed:
for system in context.systems.values_mut() {
system.set_last_change_tick(world.read_change_tick());
}
```
## Changelog
- Added `get_last_change_tick` and `set_last_change_tick` to `System`'s.
95 lines
4.1 KiB
Rust
95 lines
4.1 KiB
Rust
use bevy_utils::tracing::warn;
|
|
|
|
use crate::{
|
|
archetype::ArchetypeComponentId, change_detection::MAX_CHANGE_AGE, component::ComponentId,
|
|
query::Access, schedule::SystemLabelId, world::World,
|
|
};
|
|
use std::borrow::Cow;
|
|
|
|
/// An ECS system that can be added to a [`Schedule`](crate::schedule::Schedule)
|
|
///
|
|
/// Systems are functions with all arguments implementing
|
|
/// [`SystemParam`](crate::system::SystemParam).
|
|
///
|
|
/// Systems are added to an application using `App::add_system(my_system)`
|
|
/// or similar methods, and will generally run once per pass of the main loop.
|
|
///
|
|
/// Systems are executed in parallel, in opportunistic order; data access is managed automatically.
|
|
/// It's possible to specify explicit execution order between specific systems,
|
|
/// see [`SystemDescriptor`](crate::schedule::SystemDescriptor).
|
|
pub trait System: Send + Sync + 'static {
|
|
/// The system's input. See [`In`](crate::system::In) for
|
|
/// [`FunctionSystem`](crate::system::FunctionSystem)s.
|
|
type In;
|
|
/// The system's output.
|
|
type Out;
|
|
/// Returns the system's name.
|
|
fn name(&self) -> Cow<'static, str>;
|
|
/// Returns the system's component [`Access`].
|
|
fn component_access(&self) -> &Access<ComponentId>;
|
|
/// Returns the system's archetype component [`Access`].
|
|
fn archetype_component_access(&self) -> &Access<ArchetypeComponentId>;
|
|
/// Returns true if the system is [`Send`].
|
|
fn is_send(&self) -> bool;
|
|
|
|
/// Runs the system with the given input in the world. Unlike [`System::run`], this function
|
|
/// takes a shared reference to [`World`] and may therefore break Rust's aliasing rules, making
|
|
/// it unsafe to call.
|
|
///
|
|
/// # Safety
|
|
///
|
|
/// This might access world and resources in an unsafe manner. This should only be called in one
|
|
/// of the following contexts:
|
|
/// 1. This system is the only system running on the given world across all threads.
|
|
/// 2. This system only runs in parallel with other systems that do not conflict with the
|
|
/// [`System::archetype_component_access()`].
|
|
unsafe fn run_unsafe(&mut self, input: Self::In, world: &World) -> Self::Out;
|
|
/// Runs the system with the given input in the world.
|
|
fn run(&mut self, input: Self::In, world: &mut World) -> Self::Out {
|
|
self.update_archetype_component_access(world);
|
|
// SAFETY: world and resources are exclusively borrowed
|
|
unsafe { self.run_unsafe(input, world) }
|
|
}
|
|
fn apply_buffers(&mut self, world: &mut World);
|
|
/// Initialize the system.
|
|
fn initialize(&mut self, _world: &mut World);
|
|
/// Update the system's archetype component [`Access`].
|
|
fn update_archetype_component_access(&mut self, world: &World);
|
|
fn check_change_tick(&mut self, change_tick: u32);
|
|
/// The default labels for the system
|
|
fn default_labels(&self) -> Vec<SystemLabelId> {
|
|
Vec::new()
|
|
}
|
|
/// Gets the system's last change tick
|
|
fn get_last_change_tick(&self) -> u32;
|
|
/// Sets the system's last change tick
|
|
/// # Warning
|
|
/// This is a complex and error-prone operation, that can have unexpected consequences on any system relying on this code.
|
|
/// However, it can be an essential escape hatch when, for example,
|
|
/// you are trying to synchronize representations using change detection and need to avoid infinite recursion.
|
|
fn set_last_change_tick(&mut self, last_change_tick: u32);
|
|
}
|
|
|
|
/// A convenience type alias for a boxed [`System`] trait object.
|
|
pub type BoxedSystem<In = (), Out = ()> = Box<dyn System<In = In, Out = Out>>;
|
|
|
|
pub(crate) fn check_system_change_tick(
|
|
last_change_tick: &mut u32,
|
|
change_tick: u32,
|
|
system_name: &str,
|
|
) {
|
|
let age = change_tick.wrapping_sub(*last_change_tick);
|
|
// This comparison assumes that `age` has not overflowed `u32::MAX` before, which will be true
|
|
// so long as this check always runs before that can happen.
|
|
if age > MAX_CHANGE_AGE {
|
|
warn!(
|
|
"System '{}' has not run for {} ticks. \
|
|
Changes older than {} ticks will not be detected.",
|
|
system_name,
|
|
age,
|
|
MAX_CHANGE_AGE - 1,
|
|
);
|
|
*last_change_tick = change_tick.wrapping_sub(MAX_CHANGE_AGE);
|
|
}
|
|
}
|