mirror of
https://github.com/bevyengine/bevy
synced 2024-11-10 15:14:50 +00:00
474b55a29c
# Objective Any time we wish to transform the output of a system, we currently use system piping to do so: ```rust my_system.pipe(|In(x)| do_something(x)) ``` Unfortunately, system piping is not a zero cost abstraction. Each call to `.pipe` requires allocating two extra access sets: one for the second system and one for the combined accesses of both systems. This also adds extra work to each call to `update_archetype_component_access`, which stacks as one adds multiple layers of system piping. ## Solution Add the `AdapterSystem` abstraction: similar to `CombinatorSystem`, this allows you to implement a trait to generically control how a system is run and how its inputs and outputs are processed. Unlike `CombinatorSystem`, this does not have any overhead when computing world accesses which makes it ideal for simple operations such as inverting or ignoring the output of a system. Add the extension method `.map(...)`: this is similar to `.pipe(...)`, only it accepts a closure as an argument instead of an `In<T>` system. ```rust my_system.map(do_something) ``` This has the added benefit of making system names less messy: a system that ignores its output will just be called `my_system`, instead of `Pipe(my_system, ignore)` --- ## Changelog TODO ## Migration Guide The `system_adapter` functions have been deprecated: use `.map` instead, which is a lightweight alternative to `.pipe`. ```rust // Before: my_system.pipe(system_adapter::ignore) my_system.pipe(system_adapter::unwrap) my_system.pipe(system_adapter::new(T::from)) // After: my_system.map(std::mem::drop) my_system.map(Result::unwrap) my_system.map(T::from) // Before: my_system.pipe(system_adapter::info) my_system.pipe(system_adapter::dbg) my_system.pipe(system_adapter::warn) my_system.pipe(system_adapter::error) // After: my_system.map(bevy_utils::info) my_system.map(bevy_utils::dbg) my_system.map(bevy_utils::warn) my_system.map(bevy_utils::error) ``` --------- Co-authored-by: Alice Cecile <alice.i.cecile@gmail.com>
69 lines
2.4 KiB
Rust
69 lines
2.4 KiB
Rust
//! Illustrates how to make a single system from multiple functions running in sequence,
|
|
//! passing the output of the first into the input of the next.
|
|
|
|
use bevy::prelude::*;
|
|
use std::num::ParseIntError;
|
|
|
|
use bevy::log::LogPlugin;
|
|
use bevy::utils::{dbg, error, info, tracing::Level, warn};
|
|
|
|
fn main() {
|
|
App::new()
|
|
.insert_resource(Message("42".to_string()))
|
|
.insert_resource(OptionalWarning(Err("Got to rusty?".to_string())))
|
|
.add_plugins(LogPlugin {
|
|
level: Level::TRACE,
|
|
filter: "".to_string(),
|
|
})
|
|
.add_systems(
|
|
Update,
|
|
(
|
|
parse_message_system.pipe(handler_system),
|
|
data_pipe_system.map(info),
|
|
parse_message_system.map(dbg),
|
|
warning_pipe_system.map(warn),
|
|
parse_error_message_system.map(error),
|
|
parse_message_system.map(std::mem::drop),
|
|
),
|
|
)
|
|
.run();
|
|
}
|
|
|
|
#[derive(Resource, Deref)]
|
|
struct Message(String);
|
|
|
|
#[derive(Resource, Deref)]
|
|
struct OptionalWarning(Result<(), String>);
|
|
|
|
// This system produces a Result<usize> output by trying to parse the Message resource.
|
|
fn parse_message_system(message: Res<Message>) -> Result<usize, ParseIntError> {
|
|
message.parse::<usize>()
|
|
}
|
|
|
|
// This system produces a Result<()> output by trying to parse the Message resource.
|
|
fn parse_error_message_system(message: Res<Message>) -> Result<(), ParseIntError> {
|
|
message.parse::<usize>()?;
|
|
Ok(())
|
|
}
|
|
|
|
// This system takes a Result<usize> input and either prints the parsed value or the error message
|
|
// Try changing the Message resource to something that isn't an integer. You should see the error
|
|
// message printed.
|
|
fn handler_system(In(result): In<Result<usize, ParseIntError>>) {
|
|
match result {
|
|
Ok(value) => println!("parsed message: {value}"),
|
|
Err(err) => println!("encountered an error: {err:?}"),
|
|
}
|
|
}
|
|
|
|
// This system produces a String output by trying to clone the String from the Message resource.
|
|
fn data_pipe_system(message: Res<Message>) -> String {
|
|
message.0.clone()
|
|
}
|
|
|
|
// This system produces an Result<String> output by trying to extract a String from the
|
|
// OptionalWarning resource. Try changing the OptionalWarning resource to None. You should
|
|
// not see the warning message printed.
|
|
fn warning_pipe_system(message: Res<OptionalWarning>) -> Result<(), String> {
|
|
message.0.clone()
|
|
}
|